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

[RFC] Add basic driver for the Cloud-Hypervisor



This patch adds support for the following initial VM actions using the
Cloud-Hypervsior API:
 * vm.create
 * vm.delete
 * vm.boot
 * vm.shutdown
 * vm.reboot
 * vm.pause
 * vm.resume

To use the Cloud-Hypervisor driver, the v0.9.0 (the as of now current)
release of Cloud-Hypervisor is required to be installed.

Signed-off-by: William Douglas <william douglas intel com>
---
 include/libvirt/virterror.h |   1 +
 libvirt.spec.in             |  32 ++
 meson.build                 |   5 +
 meson_options.txt           |   1 +
 po/POTFILES.in              |   5 +
 src/ch/ch_conf.c            | 239 +++++++++
 src/ch/ch_conf.h            |  87 ++++
 src/ch/ch_domain.c          | 219 +++++++++
 src/ch/ch_domain.h          |  68 +++
 src/ch/ch_driver.c          | 937 ++++++++++++++++++++++++++++++++++++
 src/ch/ch_driver.h          |  24 +
 src/ch/ch_monitor.c         | 796 ++++++++++++++++++++++++++++++
 src/ch/ch_monitor.h         |  62 +++
 src/ch/ch_process.c         | 125 +++++
 src/ch/ch_process.h         |  30 ++
 src/ch/meson.build          |  44 ++
 src/conf/domain_conf.c      |   1 +
 src/conf/domain_conf.h      |   1 +
 src/meson.build             |   1 +
 src/qemu/qemu_command.c     |   1 +
 src/remote/remote_daemon.c  |   4 +
 src/util/virerror.c         |   1 +
 tools/virsh.c               |   3 +
 23 files changed, 2687 insertions(+)
 create mode 100644 src/ch/ch_conf.c
 create mode 100644 src/ch/ch_conf.h
 create mode 100644 src/ch/ch_domain.c
 create mode 100644 src/ch/ch_domain.h
 create mode 100644 src/ch/ch_driver.c
 create mode 100644 src/ch/ch_driver.h
 create mode 100644 src/ch/ch_monitor.c
 create mode 100644 src/ch/ch_monitor.h
 create mode 100644 src/ch/ch_process.c
 create mode 100644 src/ch/ch_process.h
 create mode 100644 src/ch/meson.build

diff --git a/include/libvirt/virterror.h b/include/libvirt/virterror.h
index 0f1c32283d..21faa8f128 100644
--- a/include/libvirt/virterror.h
+++ b/include/libvirt/virterror.h
@@ -136,6 +136,7 @@ typedef enum {
 
     VIR_FROM_TPM = 70,          /* Error from TPM */
     VIR_FROM_BPF = 71,          /* Error from BPF code */
+    VIR_FROM_CH = 72,           /* Error from Cloud-Hypervisor driver */
 
 # ifdef VIR_ENUM_SENTINELS
     VIR_ERR_DOMAIN_LAST
diff --git a/libvirt.spec.in b/libvirt.spec.in
index bb74443484..66edb1fa76 100644
--- a/libvirt.spec.in
+++ b/libvirt.spec.in
@@ -14,6 +14,7 @@
 
 # The hypervisor drivers that run in libvirtd
 %define with_qemu          0%{!?_without_qemu:1}
+%define with_ch            0%{!?_without_ch:1}
 %define with_lxc           0%{!?_without_lxc:1}
 %define with_libxl         0%{!?_without_libxl:1}
 %define with_vbox          0%{!?_without_vbox:1}
@@ -232,6 +233,9 @@ Requires: libvirt-daemon-driver-lxc = %{version}-%{release}
 %if %{with_qemu}
 Requires: libvirt-daemon-driver-qemu = %{version}-%{release}
 %endif
+%if %{with_ch}
+Requires: libvirt-daemon-driver-ch = %{version}-%{release}
+%endif
 # We had UML driver, but we've removed it.
 Obsoletes: libvirt-daemon-driver-uml <= 5.0.0
 Obsoletes: libvirt-daemon-uml <= 5.0.0
@@ -744,6 +748,20 @@ QEMU
 %endif
 
 
+%if %{with_ch}
+%package daemon-driver-ch
+Summary: Cloud-Hypervisor driver plugin for the libvirtd daemon
+Requires: libvirt-daemon = %{version}-%{release}
+Requires: libvirt-libs = %{version}-%{release}
+Requires: /usr/bin/cloud-hypervisor
+
+%description daemon-driver-ch
+The Cloud-Hypervisor driver plugin for the libvirtd daemon,
+providing an implementation of the hypervisor driver APIs
+using Cloud-Hypervisor
+%endif
+
+
 %if %{with_lxc}
 %package daemon-driver-lxc
 Summary: LXC driver plugin for the libvirtd daemon
@@ -1001,6 +1019,12 @@ exit 1
     %define arg_qemu -Ddriver_qemu=disabled
 %endif
 
+%if %{with_ch}
+    %define arg_ch -Ddriver_ch=enabled
+%else
+    %define arg_ch -Ddriver_ch=disabled
+%endif
+
 %if %{with_openvz}
     %define arg_openvz -Ddriver_openvz=enabled
 %else
@@ -1132,6 +1156,7 @@ export SOURCE_DATE_EPOCH=$(stat --printf='%Y' %{_specdir}/%{name}.spec)
 %meson \
            -Drunstatedir=%{_rundir} \
            %{?arg_qemu} \
+           %{?arg_ch} \
            %{?arg_openvz} \
            %{?arg_lxc} \
            %{?arg_vbox} \
@@ -1739,6 +1764,13 @@ exit 0
 %{_mandir}/man1/virt-qemu-run.1*
 %endif
 
+%if %{with_ch}
+%files daemon-driver-ch
+%dir %attr(0700, root, root) %{_localstatedir}/log/libvirt/ch/
+%ghost %dir %{_rundir}/libvirt/ch/
+%{_libdir}/%{name}/connection-driver/libvirt_driver_ch.so
+%endif
+
 %if %{with_lxc}
 %files daemon-driver-lxc
 %config(noreplace) %{_sysconfdir}/sysconfig/virtlxcd
diff --git a/meson.build b/meson.build
index dabd4196e6..a6759cb051 100644
--- a/meson.build
+++ b/meson.build
@@ -1722,6 +1722,10 @@ elif get_option('driver_lxc').enabled()
   error('linux and remote_driver are required for LXC')
 endif
 
+if not get_option('driver_ch').disabled() and host_machine.system() == 'linux' and conf.has('WITH_LIBVIRTD')
+  conf.set('WITH_CH', 1)
+endif
+
 # there's no use compiling the network driver without the libvirt
 # daemon, nor compiling it for macOS, where it breaks the compile
 if not get_option('driver_network').disabled() and conf.has('WITH_LIBVIRTD') and host_machine.system() != 'darwin'
@@ -2369,6 +2373,7 @@ driver_summary = {
   'VBox': conf.has('WITH_VBOX'),
   'libxl': conf.has('WITH_LIBXL'),
   'LXC': conf.has('WITH_LXC'),
+  'Cloud-Hypervisor': conf.has('WITH_CH'),
   'ESX': conf.has('WITH_ESX'),
   'Hyper-V': conf.has('WITH_HYPERV'),
   'vz': conf.has('WITH_VZ'),
diff --git a/meson_options.txt b/meson_options.txt
index 79554c3186..bfb3e79e1a 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -55,6 +55,7 @@ option('driver_interface', type: 'feature', value: 'auto', description: 'host in
 option('driver_libvirtd', type: 'feature', value: 'auto', description: 'libvirtd driver')
 option('driver_libxl', type: 'feature', value: 'auto', description: 'libxenlight driver')
 option('driver_lxc', type: 'feature', value: 'auto', description: 'Linux Container driver')
+option('driver_ch', type: 'feature', value: 'auto', description: 'Cloud-Hypervisor driver')
 option('driver_network', type: 'feature', value: 'auto', description: 'virtual network driver')
 option('driver_openvz', type: 'feature', value: 'auto', description: 'OpenVZ driver')
 option('driver_qemu', type: 'feature', value: 'auto', description: 'QEMU/KVM driver')
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 3d6c20c55f..b12a1b1e56 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -18,6 +18,11 @@
 @SRCDIR src/bhyve/bhyve_monitor.c
 @SRCDIR src/bhyve/bhyve_parse_command.c
 @SRCDIR src/bhyve/bhyve_process.c
+ SRCDIR@src/ch/ch_conf.c
+ SRCDIR@src/ch/ch_domain.c
+ SRCDIR@src/ch/ch_driver.c
+ SRCDIR@src/ch/ch_monitor.c
+ SRCDIR@src/ch/ch_process.c
 @SRCDIR src/conf/backup_conf.c
 @SRCDIR src/conf/capabilities.c
 @SRCDIR src/conf/checkpoint_conf.c
diff --git a/src/ch/ch_conf.c b/src/ch/ch_conf.c
new file mode 100644
index 0000000000..8769b0f7e2
--- /dev/null
+++ b/src/ch/ch_conf.c
@@ -0,0 +1,239 @@
+/*
+ * Copyright Intel Corp. 2020
+ *
+ * ch_driver.h: header file for Cloud-Hypervisor driver functions
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#include "configmake.h"
+#include "viralloc.h"
+#include "vircommand.h"
+#include "virlog.h"
+#include "virobject.h"
+#include "virstring.h"
+#include "virutil.h"
+
+#include "ch_conf.h"
+#include "ch_domain.h"
+
+#define VIR_FROM_THIS VIR_FROM_CH
+
+VIR_LOG_INIT("ch.ch_conf");
+
+static virClassPtr virCHDriverConfigClass;
+static void virCHDriverConfigDispose(void *obj);
+
+static int virCHConfigOnceInit(void)
+{
+    if (!VIR_CLASS_NEW(virCHDriverConfig, virClassForObject()))
+        return -1;
+
+    return 0;
+}
+
+VIR_ONCE_GLOBAL_INIT(virCHConfig);
+
+
+/* Functions */
+virCapsPtr virCHDriverCapsInit(void)
+{
+    virCapsPtr caps;
+    virCapsGuestPtr guest;
+
+    if ((caps = virCapabilitiesNew(virArchFromHost(),
+                                   false, false)) == NULL)
+        goto cleanup;
+
+    if (!(caps->host.numa = virCapabilitiesHostNUMANewHost()))
+        goto cleanup;
+
+    if (virCapabilitiesInitCaches(caps) < 0)
+        goto cleanup;
+
+    if ((guest = virCapabilitiesAddGuest(caps,
+                                         VIR_DOMAIN_OSTYPE_HVM,
+                                         caps->host.arch,
+                                         NULL,
+                                         NULL,
+                                         0,
+                                         NULL)) == NULL)
+        goto cleanup;
+
+    if (virCapabilitiesAddGuestDomain(guest,
+                                      VIR_DOMAIN_VIRT_CH,
+                                      NULL,
+                                      NULL,
+                                      0,
+                                      NULL) == NULL)
+        goto cleanup;
+
+    return caps;
+
+ cleanup:
+    virObjectUnref(caps);
+    return NULL;
+}
+
+/**
+ * virCHDriverGetCapabilities:
+ *
+ * Get a reference to the virCapsPtr instance for the
+ * driver. If @refresh is true, the capabilities will be
+ * rebuilt first
+ *
+ * The caller must release the reference with virObjetUnref
+ *
+ * Returns: a reference to a virCapsPtr instance or NULL
+ */
+virCapsPtr virCHDriverGetCapabilities(virCHDriverPtr driver,
+                                      bool refresh)
+{
+    virCapsPtr ret;
+    if (refresh) {
+        virCapsPtr caps = NULL;
+        if ((caps = virCHDriverCapsInit()) == NULL)
+            return NULL;
+
+        chDriverLock(driver);
+        virObjectUnref(driver->caps);
+        driver->caps = caps;
+    } else {
+        chDriverLock(driver);
+    }
+
+    ret = virObjectRef(driver->caps);
+    chDriverUnlock(driver);
+    return ret;
+}
+
+virDomainXMLOptionPtr
+chDomainXMLConfInit(virCHDriverPtr driver)
+{
+    virCHDriverDomainDefParserConfig.priv = driver;
+    return virDomainXMLOptionNew(&virCHDriverDomainDefParserConfig,
+                                 &virCHDriverPrivateDataCallbacks,
+                                 NULL, NULL, NULL);
+}
+
+virCHDriverConfigPtr
+virCHDriverConfigNew(void)
+{
+    virCHDriverConfigPtr cfg;
+
+    if (virCHConfigInitialize() < 0)
+        return NULL;
+
+    if (!(cfg = virObjectNew(virCHDriverConfigClass)))
+        return NULL;
+
+    cfg->stateDir = g_strdup(CH_STATE_DIR);
+    cfg->logDir = g_strdup(CH_LOG_DIR);
+
+    return cfg;
+}
+
+virCHDriverConfigPtr virCHDriverGetConfig(virCHDriverPtr driver)
+{
+    virCHDriverConfigPtr cfg;
+    chDriverLock(driver);
+    cfg = virObjectRef(driver->config);
+    chDriverUnlock(driver);
+    return cfg;
+}
+
+static void
+virCHDriverConfigDispose(void *obj)
+{
+    virCHDriverConfigPtr cfg = obj;
+
+    VIR_FREE(cfg->stateDir);
+    VIR_FREE(cfg->logDir);
+}
+
+static int
+chExtractVersionInfo(int *retversion)
+{
+    int ret = -1;
+    unsigned long version;
+    char *help = NULL;
+    char *tmp;
+    virCommandPtr cmd = virCommandNewArgList(CH_CMD, "--version", NULL);
+
+    if (retversion)
+        *retversion = 0;
+
+    virCommandAddEnvString(cmd, "LC_ALL=C");
+    virCommandSetOutputBuffer(cmd, &help);
+
+    if (virCommandRun(cmd, NULL) < 0)
+        goto cleanup;
+
+    tmp = help;
+
+    /* expected format: cloud-hypervisor v<major>.<minor>.<micro> */
+    if ((tmp = STRSKIP(tmp, "cloud-hypervisor v")) == NULL)
+        goto cleanup;
+
+    if (virParseVersionString(tmp, &version, false) < 0)
+        goto cleanup;
+
+    // v0.9.0 is the minimum supported version
+    if ((unsigned int)(version / 1000000) < 1) {
+        if (((unsigned int)((unsigned long)(version % 1000000)) / 1000) < 9) {
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Cloud-Hypervisor version is too old (v0.9.0 is the minimum supported version)"));
+            goto cleanup;
+        }
+    }
+
+
+    if (retversion)
+        *retversion = version;
+
+    ret = 0;
+
+ cleanup:
+    virCommandFree(cmd);
+    VIR_FREE(help);
+
+    return ret;
+}
+
+int chExtractVersion(virCHDriverPtr driver)
+{
+    if (driver->version > 0)
+        return 0;
+
+    if (chExtractVersionInfo(&driver->version) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Could not extract Cloud-Hypervisor version"));
+        return -1;
+    }
+
+    return 0;
+}
+
+int chStrToInt(const char *str)
+{
+    int val;
+
+    if (virStrToLong_i(str, NULL, 10, &val) < 0)
+        return 0;
+
+    return val;
+}
diff --git a/src/ch/ch_conf.h b/src/ch/ch_conf.h
new file mode 100644
index 0000000000..04334130f7
--- /dev/null
+++ b/src/ch/ch_conf.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright Intel Corp. 2020
+ *
+ * ch_driver.h: header file for Cloud-Hypervisor driver functions
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "virdomainobjlist.h"
+#include "virthread.h"
+
+#define CH_DRIVER_NAME "CH"
+#define CH_CMD "cloud-hypervisor"
+
+#define CH_STATE_DIR RUNSTATEDIR "/libvirt/ch"
+#define CH_LOG_DIR LOCALSTATEDIR "/log/libvirt/ch"
+
+typedef struct _virCHDriver virCHDriver;
+typedef virCHDriver *virCHDriverPtr;
+
+typedef struct _virCHDriverConfig virCHDriverConfig;
+typedef virCHDriverConfig *virCHDriverConfigPtr;
+
+struct _virCHDriverConfig {
+    virObject parent;
+
+    char *stateDir;
+    char *logDir;
+};
+
+struct _virCHDriver
+{
+    virMutex lock;
+
+    /* Require lock to get a reference on the object,
+     * lockless access thereafter */
+    virCapsPtr caps;
+
+    /* Immutable pointer, Immutable object */
+    virDomainXMLOptionPtr xmlopt;
+
+    /* Immutable pointer, self-locking APIs */
+    virDomainObjListPtr domains;
+
+    /* Cloud-Hypervisor version */
+    int version;
+
+    /* Require lock to get reference on 'config',
+     * then lockless thereafter */
+    virCHDriverConfigPtr config;
+
+    /* pid file FD, ensures two copies of the driver can't use the same root */
+    int lockFD;
+};
+
+virCapsPtr virCHDriverCapsInit(void);
+virCapsPtr virCHDriverGetCapabilities(virCHDriverPtr driver,
+                                      bool refresh);
+virDomainXMLOptionPtr chDomainXMLConfInit(virCHDriverPtr driver);
+virCHDriverConfigPtr virCHDriverConfigNew(void);
+virCHDriverConfigPtr virCHDriverGetConfig(virCHDriverPtr driver);
+int chExtractVersion(virCHDriverPtr driver);
+int chStrToInt(const char *str);
+
+static inline void chDriverLock(virCHDriverPtr driver)
+{
+    virMutexLock(&driver->lock);
+}
+
+static inline void chDriverUnlock(virCHDriverPtr driver)
+{
+    virMutexUnlock(&driver->lock);
+}
diff --git a/src/ch/ch_domain.c b/src/ch/ch_domain.c
new file mode 100644
index 0000000000..a46641d50d
--- /dev/null
+++ b/src/ch/ch_domain.c
@@ -0,0 +1,219 @@
+/*
+ * Copyright Intel Corp. 2020
+ *
+ * ch_driver.h: header file for Cloud-Hypervisor driver functions
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#include "ch_domain.h"
+#include "viralloc.h"
+#include "virlog.h"
+#include "virtime.h"
+
+#define VIR_FROM_THIS VIR_FROM_CH
+
+VIR_ENUM_IMPL(virCHDomainJob,
+              CH_JOB_LAST,
+              "none",
+              "query",
+              "destroy",
+              "modify",
+);
+
+VIR_LOG_INIT("ch.ch_domain");
+
+static int
+virCHDomainObjInitJob(virCHDomainObjPrivatePtr priv)
+{
+    memset(&priv->job, 0, sizeof(priv->job));
+
+    if (virCondInit(&priv->job.cond) < 0)
+        return -1;
+
+    return 0;
+}
+
+static void
+virCHDomainObjResetJob(virCHDomainObjPrivatePtr priv)
+{
+    struct virCHDomainJobObj *job = &priv->job;
+
+    job->active = CH_JOB_NONE;
+    job->owner = 0;
+}
+
+static void
+virCHDomainObjFreeJob(virCHDomainObjPrivatePtr priv)
+{
+    ignore_value(virCondDestroy(&priv->job.cond));
+}
+
+/*
+ * obj must be locked before calling, virCHDriverPtr must NOT be locked
+ *
+ * This must be called by anything that will change the VM state
+ * in any way
+ *
+ * Upon successful return, the object will have its ref count increased.
+ * Successful calls must be followed by EndJob eventually.
+ */
+int
+virCHDomainObjBeginJob(virDomainObjPtr obj, enum virCHDomainJob job)
+{
+    virCHDomainObjPrivatePtr priv = obj->privateData;
+    unsigned long long now;
+    unsigned long long then;
+
+    if (virTimeMillisNow(&now) < 0)
+        return -1;
+    then = now + CH_JOB_WAIT_TIME;
+
+    while (priv->job.active) {
+        VIR_DEBUG("Wait normal job condition for starting job: %s",
+                  virCHDomainJobTypeToString(job));
+        if (virCondWaitUntil(&priv->job.cond, &obj->parent.lock, then) < 0)
+            goto error;
+    }
+
+    virCHDomainObjResetJob(priv);
+
+    VIR_DEBUG("Starting job: %s", virCHDomainJobTypeToString(job));
+    priv->job.active = job;
+    priv->job.owner = virThreadSelfID();
+
+    return 0;
+
+ error:
+    VIR_WARN("Cannot start job (%s) for domain %s;"
+             " current job is (%s) owned by (%d)",
+             virCHDomainJobTypeToString(job),
+             obj->def->name,
+             virCHDomainJobTypeToString(priv->job.active),
+             priv->job.owner);
+
+    if (errno == ETIMEDOUT)
+        virReportError(VIR_ERR_OPERATION_TIMEOUT,
+                       "%s", _("cannot acquire state change lock"));
+    else
+        virReportSystemError(errno,
+                             "%s", _("cannot acquire job mutex"));
+    return -1;
+}
+
+/*
+ * obj must be locked and have a reference before calling
+ *
+ * To be called after completing the work associated with the
+ * earlier virCHDomainBeginJob() call
+ */
+void
+virCHDomainObjEndJob(virDomainObjPtr obj)
+{
+    virCHDomainObjPrivatePtr priv = obj->privateData;
+    enum virCHDomainJob job = priv->job.active;
+
+    VIR_DEBUG("Stopping job: %s",
+              virCHDomainJobTypeToString(job));
+
+    virCHDomainObjResetJob(priv);
+    virCondSignal(&priv->job.cond);
+}
+
+static void *
+virCHDomainObjPrivateAlloc(void *opaque G_GNUC_UNUSED)
+{
+    virCHDomainObjPrivatePtr priv;
+
+    if (VIR_ALLOC(priv) < 0)
+        return NULL;
+
+    if (virCHDomainObjInitJob(priv) < 0) {
+        VIR_FREE(priv);
+        return NULL;
+    }
+
+    return priv;
+}
+
+static void
+virCHDomainObjPrivateFree(void *data)
+{
+    virCHDomainObjPrivatePtr priv = data;
+
+    virCHDomainObjFreeJob(priv);
+    VIR_FREE(priv);
+}
+
+static int
+virCHDomainObjPrivateXMLFormat(virBufferPtr buf,
+                               virDomainObjPtr vm)
+{
+    virCHDomainObjPrivatePtr priv = vm->privateData;
+    virBufferAsprintf(buf, "<init pid='%lld'/>\n",
+                      (long long)priv->initpid);
+
+    return 0;
+}
+
+static int
+virCHDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt,
+                              virDomainObjPtr vm,
+                              virDomainDefParserConfigPtr config G_GNUC_UNUSED)
+{
+    virCHDomainObjPrivatePtr priv = vm->privateData;
+    long long thepid;
+
+    if (virXPathLongLong("string(./init[1]/@pid)", ctxt, &thepid) < 0) {
+        VIR_WARN("Failed to load init pid from state %s",
+                 virGetLastErrorMessage());
+        priv->initpid = 0;
+    } else {
+        priv->initpid = thepid;
+    }
+
+    return 0;
+}
+
+virDomainXMLPrivateDataCallbacks virCHDriverPrivateDataCallbacks = {
+    .alloc = virCHDomainObjPrivateAlloc,
+    .free = virCHDomainObjPrivateFree,
+    .format = virCHDomainObjPrivateXMLFormat,
+    .parse  = virCHDomainObjPrivateXMLParse,
+};
+
+static int
+virCHDomainDefPostParse(virDomainDefPtr def,
+                        unsigned int parseFlags G_GNUC_UNUSED,
+                        void *opaque,
+                        void *parseOpaque G_GNUC_UNUSED)
+{
+    virCHDriverPtr driver = opaque;
+    g_autoptr(virCaps) caps = virCHDriverGetCapabilities(driver, false);
+    if (!caps)
+        return -1;
+    if (!virCapabilitiesDomainSupported(caps, def->os.type,
+                                        def->os.arch,
+                                        def->virtType))
+        return -1;
+
+    return 0;
+}
+
+virDomainDefParserConfig virCHDriverDomainDefParserConfig = {
+    .domainPostParseCallback = virCHDomainDefPostParse,
+};
diff --git a/src/ch/ch_domain.h b/src/ch/ch_domain.h
new file mode 100644
index 0000000000..144f147173
--- /dev/null
+++ b/src/ch/ch_domain.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright Intel Corp. 2020
+ *
+ * ch_driver.h: header file for Cloud-Hypervisor driver functions
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ch_conf.h"
+#include "ch_monitor.h"
+
+/* Give up waiting for mutex after 30 seconds */
+#define CH_JOB_WAIT_TIME (1000ull * 30)
+
+/* Only 1 job is allowed at any time
+ * A job includes *all* ch.so api, even those just querying
+ * information, not merely actions */
+
+enum virCHDomainJob {
+    CH_JOB_NONE = 0,      /* Always set to 0 for easy if (jobActive) conditions */
+    CH_JOB_QUERY,         /* Doesn't change any state */
+    CH_JOB_DESTROY,       /* Destroys the domain (cannot be masked out) */
+    CH_JOB_MODIFY,        /* May change state */
+    CH_JOB_LAST
+};
+VIR_ENUM_DECL(virCHDomainJob);
+
+
+struct virCHDomainJobObj {
+    virCond cond;                       /* Use to coordinate jobs */
+    enum virCHDomainJob active;        /* Currently running job */
+    int owner;                          /* Thread which set current job */
+};
+
+
+typedef struct _virCHDomainObjPrivate virCHDomainObjPrivate;
+typedef virCHDomainObjPrivate *virCHDomainObjPrivatePtr;
+struct _virCHDomainObjPrivate {
+    pid_t initpid;
+
+    struct virCHDomainJobObj job;
+
+    virCHMonitorPtr monitor;
+};
+
+extern virDomainXMLPrivateDataCallbacks virCHDriverPrivateDataCallbacks;
+extern virDomainDefParserConfig virCHDriverDomainDefParserConfig;
+
+int
+virCHDomainObjBeginJob(virDomainObjPtr obj, enum virCHDomainJob job)
+    G_GNUC_WARN_UNUSED_RESULT;
+
+void
+virCHDomainObjEndJob(virDomainObjPtr obj);
diff --git a/src/ch/ch_driver.c b/src/ch/ch_driver.c
new file mode 100644
index 0000000000..e5b027f71f
--- /dev/null
+++ b/src/ch/ch_driver.c
@@ -0,0 +1,937 @@
+/*
+ * Copyright Intel Corp. 2020
+ *
+ * ch_driver.h: header file for Cloud-Hypervisor driver functions
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#include "ch_conf.h"
+#include "ch_domain.h"
+#include "ch_driver.h"
+#include "ch_monitor.h"
+#include "ch_process.h"
+#include "datatypes.h"
+#include "driver.h"
+#include "viraccessapicheck.h"
+#include "viralloc.h"
+#include "virbuffer.h"
+#include "vircommand.h"
+#include "virerror.h"
+#include "virfile.h"
+#include "virlog.h"
+#include "virnetdevtap.h"
+#include "virobject.h"
+#include "virstring.h"
+#include "virtypedparam.h"
+#include "viruri.h"
+#include "virutil.h"
+#include "viruuid.h"
+
+#define VIR_FROM_THIS VIR_FROM_CH
+
+VIR_LOG_INIT("ch.ch_driver");
+
+static int chStateInitialize(bool privileged,
+                             const char *root,
+                             virStateInhibitCallback callback,
+                             void *opaque);
+static int chStateCleanup(void);
+virCHDriverPtr ch_driver = NULL;
+
+static virDomainObjPtr
+chDomObjFromDomain(virDomainPtr domain)
+{
+    virDomainObjPtr vm;
+    virCHDriverPtr driver = domain->conn->privateData;
+    char uuidstr[VIR_UUID_STRING_BUFLEN];
+
+    vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
+    if (!vm) {
+        virUUIDFormat(domain->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s' (%s)"),
+                       uuidstr, domain->name);
+        return NULL;
+    }
+
+    return vm;
+}
+
+/* Functions */
+static int
+chConnectURIProbe(char **uri)
+{
+    if (ch_driver == NULL)
+        return 0;
+
+    *uri = g_strdup("ch:///system");
+    return 1;
+}
+
+static virDrvOpenStatus chConnectOpen(virConnectPtr conn,
+                                      virConnectAuthPtr auth G_GNUC_UNUSED,
+                                      virConfPtr conf G_GNUC_UNUSED,
+                                      unsigned int flags)
+{
+    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
+
+    /* URI was good, but driver isn't active */
+    if (ch_driver == NULL) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("Cloud-Hypervisor state driver is not active"));
+        return VIR_DRV_OPEN_ERROR;
+    }
+
+    if (virConnectOpenEnsureACL(conn) < 0)
+        return VIR_DRV_OPEN_ERROR;
+
+    conn->privateData = ch_driver;
+
+    return VIR_DRV_OPEN_SUCCESS;
+}
+
+static int chConnectClose(virConnectPtr conn)
+{
+    conn->privateData = NULL;
+    return 0;
+}
+
+static const char *chConnectGetType(virConnectPtr conn)
+{
+    if (virConnectGetTypeEnsureACL(conn) < 0)
+        return NULL;
+
+    return "CH";
+}
+
+static int chConnectGetVersion(virConnectPtr conn,
+                               unsigned long *version)
+{
+    virCHDriverPtr driver = conn->privateData;
+
+    if (virConnectGetVersionEnsureACL(conn) < 0)
+        return -1;
+
+    chDriverLock(driver);
+    *version = driver->version;
+    chDriverUnlock(driver);
+    return 0;
+}
+
+static char *chConnectGetHostname(virConnectPtr conn)
+{
+    if (virConnectGetHostnameEnsureACL(conn) < 0)
+        return NULL;
+
+    return virGetHostname();
+}
+
+static int chConnectNumOfDomains(virConnectPtr conn)
+{
+    virCHDriverPtr driver = conn->privateData;
+
+    if (virConnectNumOfDomainsEnsureACL(conn) < 0)
+        return -1;
+
+    return virDomainObjListNumOfDomains(driver->domains, true,
+                                        virConnectNumOfDomainsCheckACL, conn);
+}
+
+static int chConnectListDomains(virConnectPtr conn, int *ids, int nids)
+{
+    virCHDriverPtr driver = conn->privateData;
+
+    if (virConnectListDomainsEnsureACL(conn) < 0)
+        return -1;
+
+    return virDomainObjListGetActiveIDs(driver->domains, ids, nids,
+                                     virConnectListDomainsCheckACL, conn);
+}
+
+static int
+chConnectListAllDomains(virConnectPtr conn,
+                        virDomainPtr **domains,
+                        unsigned int flags)
+{
+    virCHDriverPtr driver = conn->privateData;
+
+    virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
+
+    if (virConnectListAllDomainsEnsureACL(conn) < 0)
+        return -1;
+
+    return virDomainObjListExport(driver->domains, conn, domains,
+                                 virConnectListAllDomainsCheckACL, flags);
+}
+
+static int chNodeGetInfo(virConnectPtr conn,
+                         virNodeInfoPtr nodeinfo)
+{
+    if (virNodeGetInfoEnsureACL(conn) < 0)
+        return -1;
+
+    return virCapabilitiesGetNodeInfo(nodeinfo);
+}
+
+static char *chConnectGetCapabilities(virConnectPtr conn)
+{
+    virCHDriverPtr driver = conn->privateData;
+    virCapsPtr caps;
+    char *xml;
+
+    if (virConnectGetCapabilitiesEnsureACL(conn) < 0)
+        return NULL;
+
+    if (!(caps = virCHDriverGetCapabilities(driver, true)))
+        return NULL;
+
+    xml = virCapabilitiesFormatXML(caps);
+
+    virObjectUnref(caps);
+    return xml;
+}
+
+/**
+ * chDomainCreateXML:
+ * @conn: pointer to connection
+ * @xml: XML definition of domain
+ * @flags: bitwise-OR of supported virDomainCreateFlags
+ *
+ * Creates a domain based on xml and starts it
+ *
+ * Returns a new domain object or NULL in case of failure.
+ */
+static virDomainPtr
+chDomainCreateXML(virConnectPtr conn,
+                           const char *xml,
+                           unsigned int flags)
+{
+    virCHDriverPtr driver = conn->privateData;
+    virDomainDefPtr vmdef = NULL;
+    virDomainObjPtr vm = NULL;
+    virDomainPtr dom = NULL;
+    unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
+
+    virCheckFlags(VIR_DOMAIN_START_VALIDATE, NULL);
+
+    if (flags & VIR_DOMAIN_START_VALIDATE)
+        parse_flags |= VIR_DOMAIN_DEF_PARSE_VALIDATE_SCHEMA;
+
+
+    if ((vmdef = virDomainDefParseString(xml, driver->xmlopt,
+                                         NULL, parse_flags)) == NULL)
+        goto cleanup;
+
+    if (virDomainCreateXMLEnsureACL(conn, vmdef) < 0)
+        goto cleanup;
+
+    if (!(vm = virDomainObjListAdd(driver->domains,
+                                   vmdef,
+                                   driver->xmlopt,
+                                   VIR_DOMAIN_OBJ_LIST_ADD_LIVE |
+                                       VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
+                                   NULL)))
+        goto cleanup;
+
+    vmdef = NULL;
+    vm->persistent = 1;
+
+    if (virCHDomainObjBeginJob(vm, CH_JOB_MODIFY) < 0)
+        goto cleanup;
+
+    if (virCHProcessStart(driver, vm, VIR_DOMAIN_RUNNING_BOOTED) < 0)
+        goto cleanup;
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid, vm->def->id);
+
+    virCHDomainObjEndJob(vm);
+
+ cleanup:
+    virDomainDefFree(vmdef);
+    virDomainObjEndAPI(&vm);
+    chDriverUnlock(driver);
+    return dom;
+}
+
+static int
+chDomainCreateWithFlags(virDomainPtr dom, unsigned int flags)
+{
+    virCHDriverPtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    if (virDomainCreateWithFlagsEnsureACL(dom->conn, vm->def) < 0)
+        goto cleanup;
+
+    if (virCHDomainObjBeginJob(vm, CH_JOB_MODIFY) < 0)
+        goto cleanup;
+
+    ret = virCHProcessStart(driver, vm, VIR_DOMAIN_RUNNING_BOOTED);
+
+    virCHDomainObjEndJob(vm);
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return ret;
+}
+
+static int
+chDomainCreate(virDomainPtr dom)
+{
+    return chDomainCreateWithFlags(dom, 0);
+}
+
+static virDomainPtr
+chDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
+{
+    virCHDriverPtr driver = conn->privateData;
+    virDomainDefPtr vmdef = NULL;
+    virDomainObjPtr vm = NULL;
+    virDomainPtr dom = NULL;
+    unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
+
+    virCheckFlags(VIR_DOMAIN_DEFINE_VALIDATE, NULL);
+
+    if (flags & VIR_DOMAIN_START_VALIDATE)
+        parse_flags |= VIR_DOMAIN_DEF_PARSE_VALIDATE_SCHEMA;
+
+    if ((vmdef = virDomainDefParseString(xml, driver->xmlopt,
+                                         NULL, parse_flags)) == NULL)
+        goto cleanup;
+
+    if (virXMLCheckIllegalChars("name", vmdef->name, "\n") < 0)
+        goto cleanup;
+
+    if (virDomainDefineXMLFlagsEnsureACL(conn, vmdef) < 0)
+        goto cleanup;
+
+    if (!(vm = virDomainObjListAdd(driver->domains, vmdef,
+                                   driver->xmlopt,
+                                   0, NULL)))
+        goto cleanup;
+
+    vmdef = NULL;
+    vm->persistent = 1;
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid, vm->def->id);
+
+ cleanup:
+    virDomainDefFree(vmdef);
+    virDomainObjEndAPI(&vm);
+    return dom;
+}
+
+static virDomainPtr
+chDomainDefineXML(virConnectPtr conn, const char *xml)
+{
+    return chDomainDefineXMLFlags(conn, xml, 0);
+}
+
+static int
+chDomainUndefineFlags(virDomainPtr dom,
+                      unsigned int flags)
+{
+    virCHDriverPtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    if (virDomainUndefineFlagsEnsureACL(dom->conn, vm->def) < 0)
+        goto cleanup;
+
+    if (!vm->persistent) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       "%s", _("Cannot undefine transient domain"));
+        goto cleanup;
+    }
+
+    if (virDomainObjIsActive(vm)) {
+        vm->persistent = 0;
+    } else {
+        virDomainObjListRemove(driver->domains, vm);
+    }
+
+    ret = 0;
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return ret;
+}
+
+static int
+chDomainUndefine(virDomainPtr dom)
+{
+    return chDomainUndefineFlags(dom, 0);
+}
+
+static int chDomainIsActive(virDomainPtr dom)
+{
+    virCHDriverPtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    chDriverLock(driver);
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    if (virDomainIsActiveEnsureACL(dom->conn, vm->def) < 0)
+        goto cleanup;
+
+    ret = virDomainObjIsActive(vm);
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    chDriverUnlock(driver);
+    return ret;
+}
+
+static int
+chDomainShutdownFlags(virDomainPtr dom,
+                      unsigned int flags)
+{
+    virCHDomainObjPrivatePtr priv;
+    virDomainObjPtr vm;
+    virDomainState state;
+    int ret = -1;
+
+    virCheckFlags(VIR_DOMAIN_SHUTDOWN_INITCTL |
+                  VIR_DOMAIN_SHUTDOWN_SIGNAL, -1);
+
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    priv = vm->privateData;
+
+    if (virDomainShutdownFlagsEnsureACL(dom->conn, vm->def, flags) < 0)
+        goto cleanup;
+
+    if (virCHDomainObjBeginJob(vm, CH_JOB_MODIFY) < 0)
+        goto cleanup;
+
+    if (virDomainObjCheckActive(vm) < 0)
+        goto endjob;
+
+    state = virDomainObjGetState(vm, NULL);
+    if (state != VIR_DOMAIN_RUNNING && state != VIR_DOMAIN_PAUSED) {
+        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+                       _("only can shutdown running/paused domain"));
+        goto endjob;
+    } else {
+        if (virCHMonitorShutdownVM(priv->monitor) < 0) {
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                        _("failed to shutdown guest VM"));
+            goto endjob;
+        }
+    }
+
+    virDomainObjSetState(vm, VIR_DOMAIN_SHUTDOWN, VIR_DOMAIN_SHUTDOWN_USER);
+
+    ret = 0;
+
+ endjob:
+    virCHDomainObjEndJob(vm);
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return ret;
+}
+
+static int
+chDomainShutdown(virDomainPtr dom)
+{
+    return chDomainShutdownFlags(dom, 0);
+}
+
+
+static int
+chDomainReboot(virDomainPtr dom, unsigned int flags)
+{
+    virCHDomainObjPrivatePtr priv;
+    virDomainObjPtr vm;
+    virDomainState state;
+    int ret = -1;
+
+    virCheckFlags(VIR_DOMAIN_REBOOT_INITCTL |
+                  VIR_DOMAIN_REBOOT_SIGNAL, -1);
+
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    priv = vm->privateData;
+
+    if (virDomainRebootEnsureACL(dom->conn, vm->def, flags) < 0)
+        goto cleanup;
+
+    if (virCHDomainObjBeginJob(vm, CH_JOB_MODIFY) < 0)
+        goto cleanup;
+
+    if (virDomainObjCheckActive(vm) < 0)
+        goto endjob;
+
+    state = virDomainObjGetState(vm, NULL);
+    if (state != VIR_DOMAIN_RUNNING && state != VIR_DOMAIN_PAUSED) {
+        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
+                       _("only can reboot running/paused domain"));
+        goto endjob;
+    } else {
+        if (virCHMonitorRebootVM(priv->monitor) < 0) {
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("failed to reboot domain"));
+            goto endjob;
+        }
+    }
+
+    if (state == VIR_DOMAIN_RUNNING)
+        virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED);
+    else
+        virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED);
+
+    ret = 0;
+
+ endjob:
+    virCHDomainObjEndJob(vm);
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return ret;
+}
+
+static int
+chDomainSuspend(virDomainPtr dom)
+{
+    virCHDomainObjPrivatePtr priv;
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    priv = vm->privateData;
+
+    if (virDomainSuspendEnsureACL(dom->conn, vm->def) < 0)
+        goto cleanup;
+
+    if (virCHDomainObjBeginJob(vm, CH_JOB_MODIFY) < 0)
+        goto cleanup;
+
+    if (virDomainObjCheckActive(vm) < 0)
+        goto endjob;
+
+    if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {
+        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
+                       _("only can suspend running domain"));
+        goto endjob;
+    } else {
+        if (virCHMonitorSuspendVM(priv->monitor) < 0) {
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                        _("failed to suspend domain"));
+            goto endjob;
+        }
+    }
+
+    virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER);
+
+    ret = 0;
+
+ endjob:
+    virCHDomainObjEndJob(vm);
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return ret;
+}
+
+static int
+chDomainResume(virDomainPtr dom)
+{
+    virCHDomainObjPrivatePtr priv;
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    priv = vm->privateData;
+
+    if (virDomainResumeEnsureACL(dom->conn, vm->def) < 0)
+        goto cleanup;
+
+    if (virCHDomainObjBeginJob(vm, CH_JOB_MODIFY) < 0)
+        goto cleanup;
+
+    if (virDomainObjCheckActive(vm) < 0)
+        goto endjob;
+
+    if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) {
+        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
+                       _("only can resume paused domain"));
+        goto endjob;
+    } else {
+        if (virCHMonitorResumeVM(priv->monitor) < 0) {
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                        _("failed to resume domain"));
+            goto endjob;
+        }
+    }
+
+    virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED);
+
+    ret = 0;
+
+ endjob:
+    virCHDomainObjEndJob(vm);
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return ret;
+}
+
+/**
+ * chDomainDestroyFlags:
+ * @dom: pointer to domain to destroy
+ * @flags: extra flags; not used yet.
+ *
+ * Sends SIGKILL to Cloud-Hypervisor process to terminate it
+ *
+ * Returns 0 on success or -1 in case of error
+ */
+static int
+chDomainDestroyFlags(virDomainPtr dom, unsigned int flags)
+{
+    virCHDriverPtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    if (virDomainDestroyFlagsEnsureACL(dom->conn, vm->def) < 0)
+        goto cleanup;
+
+    if (virCHDomainObjBeginJob(vm, CH_JOB_DESTROY) < 0)
+        goto cleanup;
+
+    if (virDomainObjCheckActive(vm) < 0)
+        goto endjob;
+
+    ret = virCHProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED);
+
+ endjob:
+    virCHDomainObjEndJob(vm);
+    if (!vm->persistent)
+        virDomainObjListRemove(driver->domains, vm);
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return ret;
+}
+
+static int
+chDomainDestroy(virDomainPtr dom)
+{
+    return chDomainDestroyFlags(dom, 0);
+}
+
+static virDomainPtr chDomainLookupByID(virConnectPtr conn,
+                                       int id)
+{
+    virCHDriverPtr driver = conn->privateData;
+    virDomainObjPtr vm;
+    virDomainPtr dom = NULL;
+
+    chDriverLock(driver);
+    vm = virDomainObjListFindByID(driver->domains, id);
+    chDriverUnlock(driver);
+
+    if (!vm) {
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching id '%d'"), id);
+        goto cleanup;
+    }
+
+    if (virDomainLookupByIDEnsureACL(conn, vm->def) < 0)
+        goto cleanup;
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid, vm->def->id);
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return dom;
+}
+
+static virDomainPtr chDomainLookupByName(virConnectPtr conn,
+                                         const char *name)
+{
+    virCHDriverPtr driver = conn->privateData;
+    virDomainObjPtr vm;
+    virDomainPtr dom = NULL;
+
+    chDriverLock(driver);
+    vm = virDomainObjListFindByName(driver->domains, name);
+    chDriverUnlock(driver);
+
+    if (!vm) {
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching name '%s'"), name);
+        goto cleanup;
+    }
+
+    if (virDomainLookupByNameEnsureACL(conn, vm->def) < 0)
+        goto cleanup;
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid, vm->def->id);
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return dom;
+}
+
+static virDomainPtr chDomainLookupByUUID(virConnectPtr conn,
+                                         const unsigned char *uuid)
+{
+    virCHDriverPtr driver = conn->privateData;
+    virDomainObjPtr vm;
+    virDomainPtr dom = NULL;
+
+    chDriverLock(driver);
+    vm = virDomainObjListFindByUUID(driver->domains, uuid);
+    chDriverUnlock(driver);
+
+    if (!vm) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(uuid, uuidstr);
+        virReportError(VIR_ERR_NO_DOMAIN,
+                       _("no domain with matching uuid '%s'"), uuidstr);
+        goto cleanup;
+    }
+
+    if (virDomainLookupByUUIDEnsureACL(conn, vm->def) < 0)
+        goto cleanup;
+
+    dom = virGetDomain(conn, vm->def->name, vm->def->uuid, vm->def->id);
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return dom;
+}
+
+static int
+chDomainGetState(virDomainPtr dom,
+                 int *state,
+                 int *reason,
+                 unsigned int flags)
+{
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    if (virDomainGetStateEnsureACL(dom->conn, vm->def) < 0)
+        goto cleanup;
+
+    *state = virDomainObjGetState(vm, reason);
+    ret = 0;
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return ret;
+}
+
+static char *chDomainGetXMLDesc(virDomainPtr dom,
+                                unsigned int flags)
+{
+    virCHDriverPtr driver = dom->conn->privateData;
+    virDomainObjPtr vm;
+    char *ret = NULL;
+
+    virCheckFlags(VIR_DOMAIN_XML_COMMON_FLAGS, NULL);
+
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    if (virDomainGetXMLDescEnsureACL(dom->conn, vm->def, flags) < 0)
+        goto cleanup;
+
+    ret = virDomainDefFormat(vm->def, driver->xmlopt,
+                             virDomainDefFormatConvertXMLFlags(flags));
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return ret;
+}
+
+static int chDomainGetInfo(virDomainPtr dom,
+                           virDomainInfoPtr info)
+{
+    virDomainObjPtr vm;
+    int ret = -1;
+
+    if (!(vm = chDomObjFromDomain(dom)))
+        goto cleanup;
+
+    if (virDomainGetInfoEnsureACL(dom->conn, vm->def) < 0)
+        goto cleanup;
+
+    info->state = virDomainObjGetState(vm, NULL);
+
+    info->cpuTime = 0;
+
+    info->maxMem = virDomainDefGetMemoryTotal(vm->def);
+    info->memory = vm->def->mem.cur_balloon;
+    info->nrVirtCpu = virDomainDefGetVcpus(vm->def);
+
+    ret = 0;
+
+ cleanup:
+    virDomainObjEndAPI(&vm);
+    return ret;
+}
+
+static int chStateCleanup(void)
+{
+    if (ch_driver == NULL)
+        return -1;
+
+    virObjectUnref(ch_driver->domains);
+    virObjectUnref(ch_driver->xmlopt);
+    virObjectUnref(ch_driver->caps);
+    virObjectUnref(ch_driver->config);
+    virMutexDestroy(&ch_driver->lock);
+    VIR_FREE(ch_driver);
+
+    return 0;
+}
+
+static int chStateInitialize(bool privileged,
+                             const char *root,
+                             virStateInhibitCallback callback G_GNUC_UNUSED,
+                             void *opaque G_GNUC_UNUSED)
+{
+    if (root != NULL) {
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("Driver does not support embedded mode"));
+        return -1;
+    }
+
+    /* Check that the user is root, silently disable if not */
+    if (!privileged) {
+        VIR_INFO("Not running privileged, disabling driver");
+        return VIR_DRV_STATE_INIT_SKIPPED;
+    }
+
+    if (VIR_ALLOC(ch_driver) < 0)
+        return VIR_DRV_STATE_INIT_ERROR;
+
+    if (virMutexInit(&ch_driver->lock) < 0) {
+        VIR_FREE(ch_driver);
+        return VIR_DRV_STATE_INIT_ERROR;
+    }
+
+    if (!(ch_driver->domains = virDomainObjListNew()))
+        goto cleanup;
+
+    if (!(ch_driver->caps = virCHDriverCapsInit()))
+        goto cleanup;
+
+    if (!(ch_driver->xmlopt = chDomainXMLConfInit(ch_driver)))
+        goto cleanup;
+
+    if (!(ch_driver->config = virCHDriverConfigNew()))
+        goto cleanup;
+
+    if (chExtractVersion(ch_driver) < 0)
+        goto cleanup;
+
+    return VIR_DRV_STATE_INIT_COMPLETE;
+
+ cleanup:
+    chStateCleanup();
+    return VIR_DRV_STATE_INIT_ERROR;
+}
+
+/* Function Tables */
+static virHypervisorDriver chHypervisorDriver = {
+    .name = "CH",
+    .connectURIProbe = chConnectURIProbe,
+    .connectOpen = chConnectOpen,                           /* 6.7.0 */
+    .connectClose = chConnectClose,                         /* 6.7.0 */
+    .connectGetType = chConnectGetType,                     /* 6.7.0 */
+    .connectGetVersion = chConnectGetVersion,               /* 6.7.0 */
+    .connectGetHostname = chConnectGetHostname,             /* 6.7.0 */
+    .connectNumOfDomains = chConnectNumOfDomains,           /* 6.7.0 */
+    .connectListAllDomains = chConnectListAllDomains,       /* 6.7.0 */
+    .connectListDomains = chConnectListDomains,             /* 6.7.0 */
+    .connectGetCapabilities = chConnectGetCapabilities,     /* 6.7.0 */
+    .domainCreateXML = chDomainCreateXML,                   /* 6.7.0 */
+    .domainCreate = chDomainCreate,                         /* 6.7.0 */
+    .domainCreateWithFlags = chDomainCreateWithFlags,       /* 6.7.0 */
+    .domainShutdown = chDomainShutdown,                     /* 6.7.0 */
+    .domainShutdownFlags = chDomainShutdownFlags,           /* 6.7.0 */
+    .domainReboot = chDomainReboot,                         /* 6.7.0 */
+    .domainSuspend = chDomainSuspend,                       /* 6.7.0 */
+    .domainResume = chDomainResume,                         /* 6.7.0 */
+    .domainDestroy = chDomainDestroy,                       /* 6.7.0 */
+    .domainDestroyFlags = chDomainDestroyFlags,             /* 6.7.0 */
+    .domainDefineXML = chDomainDefineXML,                   /* 6.7.0 */
+    .domainDefineXMLFlags = chDomainDefineXMLFlags,         /* 6.7.0 */
+    .domainUndefine = chDomainUndefine,                     /* 6.7.0 */
+    .domainUndefineFlags = chDomainUndefineFlags,           /* 6.7.0 */
+    .domainLookupByID = chDomainLookupByID,                 /* 6.7.0 */
+    .domainLookupByUUID = chDomainLookupByUUID,             /* 6.7.0 */
+    .domainLookupByName = chDomainLookupByName,             /* 6.7.0 */
+    .domainGetState = chDomainGetState,                     /* 6.7.0 */
+    .domainGetXMLDesc = chDomainGetXMLDesc,                 /* 6.7.0 */
+    .domainGetInfo = chDomainGetInfo,                       /* 6.7.0 */
+    .domainIsActive = chDomainIsActive,                     /* 6.7.0 */
+    .nodeGetInfo = chNodeGetInfo,                           /* 6.7.0 */
+};
+
+static virConnectDriver chConnectDriver = {
+    .localOnly = true,
+    .uriSchemes = (const char *[]){"CH", "Ch", "ch", "Cloud-Hypervisor", NULL},
+    .hypervisorDriver = &chHypervisorDriver,
+};
+
+static virStateDriver chStateDriver = {
+    .name = "CH",
+    .stateInitialize = chStateInitialize,
+    .stateCleanup = chStateCleanup,
+};
+
+int chRegister(void)
+{
+    if (virRegisterConnectDriver(&chConnectDriver, false) < 0)
+        return -1;
+    if (virRegisterStateDriver(&chStateDriver) < 0)
+        return -1;
+    return 0;
+}
diff --git a/src/ch/ch_driver.h b/src/ch/ch_driver.h
new file mode 100644
index 0000000000..0516c91c24
--- /dev/null
+++ b/src/ch/ch_driver.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright Intel Corp. 2020
+ *
+ * ch_driver.h: header file for Cloud-Hypervisor driver functions
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+/* Function declarations */
+int chRegister(void);
diff --git a/src/ch/ch_monitor.c b/src/ch/ch_monitor.c
new file mode 100644
index 0000000000..ccef70f719
--- /dev/null
+++ b/src/ch/ch_monitor.c
@@ -0,0 +1,796 @@
+/*
+ * Copyright Intel Corp. 2020
+ *
+ * ch_driver.h: header file for Cloud-Hypervisor driver functions
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <curl/curl.h>
+
+#include "ch_conf.h"
+#include "ch_monitor.h"
+#include "viralloc.h"
+#include "vircommand.h"
+#include "virerror.h"
+#include "virfile.h"
+#include "virjson.h"
+#include "virlog.h"
+#include "virtime.h"
+
+#define VIR_FROM_THIS VIR_FROM_CH
+
+VIR_LOG_INIT("ch.ch_monitor");
+
+static virClassPtr virCHMonitorClass;
+static void virCHMonitorDispose(void *obj);
+
+static int virCHMonitorOnceInit(void)
+{
+    if (!VIR_CLASS_NEW(virCHMonitor, virClassForObjectLockable()))
+        return -1;
+
+    return 0;
+}
+
+VIR_ONCE_GLOBAL_INIT(virCHMonitor);
+
+int virCHMonitorShutdownVMM(virCHMonitorPtr mon);
+int virCHMonitorPutNoContent(virCHMonitorPtr mon, const char *endpoint);
+int virCHMonitorGet(virCHMonitorPtr mon, const char *endpoint);
+int virCHMonitorPingVMM(virCHMonitorPtr mon);
+
+static int
+virCHMonitorBuildCPUJson(virJSONValuePtr content, virDomainDefPtr vmdef)
+{
+    virJSONValuePtr cpus;
+    unsigned int maxvcpus = 0;
+    unsigned int nvcpus = 0;
+    virDomainVcpuDefPtr vcpu;
+    size_t i;
+
+    /* count maximum allowed number vcpus and enabled vcpus when boot.*/
+    maxvcpus = virDomainDefGetVcpusMax(vmdef);
+    for (i = 0; i < maxvcpus; i++) {
+        vcpu = virDomainDefGetVcpu(vmdef, i);
+        if (vcpu->online)
+            nvcpus++;
+    }
+
+    if (maxvcpus != 0 || nvcpus != 0) {
+        cpus = virJSONValueNewObject();
+        if (virJSONValueObjectAppendNumberInt(cpus, "boot_vcpus", nvcpus) < 0)
+            goto cleanup;
+        if (virJSONValueObjectAppendNumberInt(cpus, "max_vcpus", vmdef->maxvcpus) < 0)
+            goto cleanup;
+        if (virJSONValueObjectAppend(content, "cpus", cpus) < 0)
+            goto cleanup;
+    }
+
+    return 0;
+
+ cleanup:
+    virJSONValueFree(cpus);
+    return -1;
+}
+
+static int
+virCHMonitorBuildKernelJson(virJSONValuePtr content, virDomainDefPtr vmdef)
+{
+    virJSONValuePtr kernel;
+
+    if (vmdef->os.kernel == NULL) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Kernel image path in this domain is not defined"));
+        return -1;
+    } else {
+        kernel = virJSONValueNewObject();
+        if (virJSONValueObjectAppendString(kernel, "path", vmdef->os.kernel) < 0)
+            goto cleanup;
+        if (virJSONValueObjectAppend(content, "kernel", kernel) < 0)
+            goto cleanup;
+    }
+
+    return 0;
+
+ cleanup:
+    virJSONValueFree(kernel);
+    return -1;
+}
+
+static int
+virCHMonitorBuildCmdlineJson(virJSONValuePtr content, virDomainDefPtr vmdef)
+{
+    virJSONValuePtr cmdline;
+
+    cmdline = virJSONValueNewObject();
+    if (vmdef->os.cmdline) {
+        if (virJSONValueObjectAppendString(cmdline, "args", vmdef->os.cmdline) < 0)
+            goto cleanup;
+        if (virJSONValueObjectAppend(content, "cmdline", cmdline) < 0)
+            goto cleanup;
+    }
+
+    return 0;
+
+ cleanup:
+    virJSONValueFree(cmdline);
+    return -1;
+}
+
+static int
+virCHMonitorBuildMemoryJson(virJSONValuePtr content, virDomainDefPtr vmdef)
+{
+    virJSONValuePtr memory;
+    unsigned long long total_memory = virDomainDefGetMemoryInitial(vmdef) * 1024;
+
+    if (total_memory != 0) {
+        memory = virJSONValueNewObject();
+        if (virJSONValueObjectAppendNumberUlong(memory, "size", total_memory) < 0)
+            goto cleanup;
+        if (virJSONValueObjectAppend(content, "memory", memory) < 0)
+            goto cleanup;
+    }
+
+    return 0;
+
+ cleanup:
+    virJSONValueFree(memory);
+    return -1;
+}
+
+static int
+virCHMonitorBuildInitramfsJson(virJSONValuePtr content, virDomainDefPtr vmdef)
+{
+    virJSONValuePtr initramfs;
+
+    if (vmdef->os.initrd != NULL) {
+        initramfs = virJSONValueNewObject();
+        if (virJSONValueObjectAppendString(initramfs, "path", vmdef->os.initrd) < 0)
+            goto cleanup;
+        if (virJSONValueObjectAppend(content, "initramfs", initramfs) < 0)
+            goto cleanup;
+    }
+
+    return 0;
+
+ cleanup:
+    virJSONValueFree(initramfs);
+    return -1;
+}
+
+static int
+virCHMonitorBuildDiskJson(virJSONValuePtr disks, virDomainDiskDefPtr diskdef)
+{
+    virJSONValuePtr disk;
+
+    if (diskdef->src != NULL && diskdef->src->path != NULL) {
+        disk = virJSONValueNewObject();
+        if (virJSONValueObjectAppendString(disk, "path", diskdef->src->path) < 0)
+            goto cleanup;
+        if (diskdef->src->readonly) {
+            if (virJSONValueObjectAppendBoolean(disk, "readonly", true) < 0)
+                goto cleanup;
+        }
+        if (virJSONValueArrayAppend(disks, disk) < 0)
+            goto cleanup;
+    }
+
+    return 0;
+
+ cleanup:
+    virJSONValueFree(disk);
+    return -1;
+}
+
+static int
+virCHMonitorBuildDisksJson(virJSONValuePtr content, virDomainDefPtr vmdef)
+{
+    virJSONValuePtr disks;
+    size_t i;
+
+    if (vmdef->ndisks > 0) {
+        disks = virJSONValueNewArray();
+
+        for (i = 0; i < vmdef->ndisks; i++) {
+            if (virCHMonitorBuildDiskJson(disks, vmdef->disks[i]) < 0)
+                goto cleanup;
+        }
+        if (virJSONValueObjectAppend(content, "disks", disks) < 0)
+            goto cleanup;
+    }
+
+    return 0;
+
+ cleanup:
+    virJSONValueFree(disks);
+    return -1;
+}
+
+static int
+virCHMonitorBuildNetJson(virJSONValuePtr nets, virDomainNetDefPtr netdef)
+{
+    virDomainNetType netType = virDomainNetGetActualType(netdef);
+    char macaddr[VIR_MAC_STRING_BUFLEN];
+    virJSONValuePtr net;
+
+    // check net type at first
+    net = virJSONValueNewObject();
+
+    switch (netType) {
+    case VIR_DOMAIN_NET_TYPE_ETHERNET:
+        if (netdef->guestIP.nips == 1) {
+            const virNetDevIPAddr *ip = netdef->guestIP.ips[0];
+            g_autofree char *addr = NULL;
+            virSocketAddr netmask;
+            g_autofree char *netmaskStr = NULL;
+            if (!(addr = virSocketAddrFormat(&ip->address)))
+                goto cleanup;
+            if (virJSONValueObjectAppendString(net, "ip", addr) < 0)
+                goto cleanup;
+
+            if (virSocketAddrPrefixToNetmask(ip->prefix, &netmask, AF_INET) < 0) {
+                virReportError(VIR_ERR_INTERNAL_ERROR,
+                               _("Failed to translate net prefix %d to netmask"),
+                               ip->prefix);
+                goto cleanup;
+            }
+            if (!(netmaskStr = virSocketAddrFormat(&netmask)))
+                goto cleanup;
+            if (virJSONValueObjectAppendString(net, "mask", netmaskStr) < 0)
+                goto cleanup;
+        }
+        break;
+    case VIR_DOMAIN_NET_TYPE_VHOSTUSER:
+        if ((virDomainChrType)netdef->data.vhostuser->type != VIR_DOMAIN_CHR_TYPE_UNIX) {
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("vhost_user type support UNIX socket in this CH"));
+            goto cleanup;
+        } else {
+            if (virJSONValueObjectAppendString(net, "vhost_socket", netdef->data.vhostuser->data.nix.path) < 0)
+                goto cleanup;
+            if (virJSONValueObjectAppendBoolean(net, "vhost_user", true) < 0)
+                goto cleanup;
+        }
+        break;
+    case VIR_DOMAIN_NET_TYPE_BRIDGE:
+    case VIR_DOMAIN_NET_TYPE_NETWORK:
+    case VIR_DOMAIN_NET_TYPE_DIRECT:
+    case VIR_DOMAIN_NET_TYPE_USER:
+    case VIR_DOMAIN_NET_TYPE_SERVER:
+    case VIR_DOMAIN_NET_TYPE_CLIENT:
+    case VIR_DOMAIN_NET_TYPE_MCAST:
+    case VIR_DOMAIN_NET_TYPE_INTERNAL:
+    case VIR_DOMAIN_NET_TYPE_HOSTDEV:
+    case VIR_DOMAIN_NET_TYPE_UDP:
+    case VIR_DOMAIN_NET_TYPE_LAST:
+    default:
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                       _("Only ethernet and vhost_user type network types are "
+                         "supported in this CH"));
+        goto cleanup;
+    }
+
+    if (netdef->ifname != NULL) {
+        if (virJSONValueObjectAppendString(net, "tap", netdef->ifname) < 0)
+            goto cleanup;
+    }
+    if (virJSONValueObjectAppendString(net, "mac", virMacAddrFormat(&netdef->mac, macaddr)) < 0)
+        goto cleanup;
+
+
+    if (netdef->virtio != NULL) {
+        if (netdef->virtio->iommu == VIR_TRISTATE_SWITCH_ON) {
+            if (virJSONValueObjectAppendBoolean(net, "iommu", true) < 0)
+                goto cleanup;
+        }
+    }
+    if (netdef->driver.virtio.queues) {
+        if (virJSONValueObjectAppendNumberInt(net, "num_queues", netdef->driver.virtio.queues) < 0)
+            goto cleanup;
+    }
+
+    if (netdef->driver.virtio.rx_queue_size || netdef->driver.virtio.tx_queue_size) {
+        if (netdef->driver.virtio.rx_queue_size != netdef->driver.virtio.tx_queue_size) {
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+               _("virtio rx_queue_size option %d is not same with tx_queue_size %d"),
+               netdef->driver.virtio.rx_queue_size,
+               netdef->driver.virtio.tx_queue_size);
+            goto cleanup;
+        }
+        if (virJSONValueObjectAppendNumberInt(net, "queue_size", netdef->driver.virtio.rx_queue_size) < 0)
+            goto cleanup;
+    }
+
+    if (virJSONValueArrayAppend(nets, net) < 0)
+        goto cleanup;
+
+    return 0;
+
+ cleanup:
+    virJSONValueFree(net);
+    return -1;
+}
+
+static int
+virCHMonitorBuildNetsJson(virJSONValuePtr content, virDomainDefPtr vmdef)
+{
+    virJSONValuePtr nets;
+    size_t i;
+
+    if (vmdef->nnets > 0) {
+        nets = virJSONValueNewArray();
+
+        for (i = 0; i < vmdef->nnets; i++) {
+            if (virCHMonitorBuildNetJson(nets, vmdef->nets[i]) < 0)
+                goto cleanup;
+        }
+        if (virJSONValueObjectAppend(content, "net", nets) < 0)
+            goto cleanup;
+    }
+
+    return 0;
+
+ cleanup:
+    virJSONValueFree(nets);
+    return -1;
+}
+
+static int
+virCHMonitorBuildVMJson(virDomainDefPtr vmdef, char **jsonstr)
+{
+    virJSONValuePtr content = virJSONValueNewObject();
+    int ret = -1;
+
+    if (vmdef == NULL) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("VM is not defined"));
+        goto cleanup;
+    }
+
+    if (virCHMonitorBuildCPUJson(content, vmdef) < 0)
+        goto cleanup;
+
+    if (virCHMonitorBuildMemoryJson(content, vmdef) < 0)
+        goto cleanup;
+
+    if (virCHMonitorBuildKernelJson(content, vmdef) < 0)
+        goto cleanup;
+
+    if (virCHMonitorBuildCmdlineJson(content, vmdef) < 0)
+        goto cleanup;
+
+    if (virCHMonitorBuildInitramfsJson(content, vmdef) < 0)
+        goto cleanup;
+
+    if (virCHMonitorBuildDisksJson(content, vmdef) < 0)
+        goto cleanup;
+
+    if (virCHMonitorBuildNetsJson(content, vmdef) < 0)
+        goto cleanup;
+
+    if (!(*jsonstr = virJSONValueToString(content, false)))
+        goto cleanup;
+
+    ret = 0;
+
+ cleanup:
+    virJSONValueFree(content);
+    return ret;
+}
+
+/* generate command to launch Cloud-Hypervisor socket
+   return -1 - error
+           0 - OK
+   Caller has to free the cmd
+*/
+static virCommandPtr
+chMonitorBuildSocketCmd(virDomainObjPtr vm, const char *socket_path)
+{
+    virCommandPtr cmd;
+
+    if (vm->def == NULL) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("VM is not defined"));
+        return NULL;
+    }
+
+    if (vm->def->emulator != NULL)
+        cmd = virCommandNew(vm->def->emulator);
+    else
+        cmd = virCommandNew(CH_CMD);
+
+    virCommandAddArgList(cmd, "--api-socket", socket_path, NULL);
+
+    return cmd;
+}
+
+virCHMonitorPtr
+virCHMonitorNew(virDomainObjPtr vm, const char *socketdir)
+{
+    virCHMonitorPtr ret = NULL;
+    virCHMonitorPtr mon = NULL;
+    virCommandPtr cmd = NULL;
+    int pings = 0;
+
+    if (virCHMonitorInitialize() < 0)
+        return NULL;
+
+    if (!(mon = virObjectLockableNew(virCHMonitorClass)))
+        return NULL;
+
+    mon->socketpath = g_strdup_printf("%s/%s-socket", socketdir, vm->def->name);
+
+    /* prepare to launch Cloud-Hypervisor socket */
+    if (!(cmd = chMonitorBuildSocketCmd(vm, mon->socketpath)))
+        goto cleanup;
+
+    if (virFileMakePath(socketdir) < 0) {
+        virReportSystemError(errno,
+                             _("Cannot create socket directory '%s'"),
+                             socketdir);
+        goto cleanup;
+    }
+
+    /* launch Cloud-Hypervisor socket */
+    if (virCommandRunAsync(cmd, &mon->pid) < 0)
+        goto cleanup;
+
+    /* get a curl handle */
+    mon->handle = curl_easy_init();
+
+    /* try to ping VMM socket 5 times to make sure it is ready */
+    while (pings < 5) {
+        if (virCHMonitorPingVMM(mon) == 0)
+            break;
+        if (pings == 5)
+            goto cleanup;
+
+        g_usleep(100 * 1000);
+    }
+
+    /* now has its own reference */
+    virObjectRef(mon);
+    mon->vm = virObjectRef(vm);
+
+    ret = mon;
+
+ cleanup:
+    virCommandFree(cmd);
+    return ret;
+}
+
+static void virCHMonitorDispose(void *opaque)
+{
+    virCHMonitorPtr mon = opaque;
+
+    VIR_DEBUG("mon=%p", mon);
+    virObjectUnref(mon->vm);
+}
+
+void virCHMonitorClose(virCHMonitorPtr mon)
+{
+    if (!mon)
+        return;
+
+    if (mon->pid > 0) {
+        /* try cleaning up the Cloud-Hypervisor process */
+        virProcessAbort(mon->pid);
+        mon->pid = 0;
+    }
+
+    if (mon->handle)
+        curl_easy_cleanup(mon->handle);
+
+    if (mon->socketpath) {
+        if (virFileRemove(mon->socketpath, -1, -1) < 0) {
+            VIR_WARN("Unable to remove CH socket file '%s'",
+                     mon->socketpath);
+        }
+        VIR_FREE(mon->socketpath);
+    }
+
+    virObjectUnref(mon);
+    if (mon->vm)
+        virObjectUnref(mon->vm);
+}
+
+
+struct data {
+  char trace_ascii; /* 1 or 0 */
+};
+
+static void dump(const char *text,
+                 FILE *stream,
+                 unsigned char *ptr,
+                 size_t size,
+                 char nohex)
+{
+    size_t i;
+    size_t c;
+
+    unsigned int width = 0x10;
+
+    if (nohex)
+        /* without the hex output, we can fit more on screen */
+        width = 0x40;
+
+    fprintf(stream, "%s, %10.10lu bytes (0x%8.8lx)\n", text, (unsigned long)size,
+            (unsigned long)size);
+
+    for (i = 0; i < size; i += width) {
+
+        fprintf(stream, "%4.4lx: ", (unsigned long)i);
+
+        if (!nohex) {
+            /* hex not disabled, show it */
+            for (c = 0; c < width; c++) {
+                if (i + c < size)
+                    fprintf(stream, "%02x ", ptr[i + c]);
+                else
+                    fputs("   ", stream);
+            }
+        }
+
+        for (c = 0; (c < width) && (i + c < size); c++) {
+            /* check for 0D0A; if found, skip past and start a new line of output */
+            if (nohex && (i + c + 1 < size) && ptr[i + c] == 0x0D &&
+                ptr[i + c + 1] == 0x0A) {
+                i += (c + 2 - width);
+                break;
+            }
+            fprintf(stream, "%c",
+                    (ptr[i + c] >= 0x20) && (ptr[i + c] < 0x80) ? ptr[i + c] : '.');
+            /* check again for 0D0A, to avoid an extra \n if it's at width */
+            if (nohex && (i + c + 2 < size) && ptr[i + c + 1] == 0x0D &&
+                ptr[i + c + 2] == 0x0A) {
+                i += (c + 3 - width);
+                break;
+            }
+        }
+        fputc('\n', stream); /* newline */
+    }
+    fflush(stream);
+}
+
+static int my_trace(CURL *handle,
+                    curl_infotype type,
+                    char *data,
+                    size_t size,
+                    void *userp)
+{
+    struct data *config = (struct data *)userp;
+    const char *text = "";
+    (void)handle; /* prevent compiler warning */
+
+    switch (type) {
+    case CURLINFO_TEXT:
+        fprintf(stderr, "== Info: %s", data);
+        /* FALLTHROUGH */
+    case CURLINFO_END: /* in case a new one is introduced to shock us */
+        break;
+    case CURLINFO_HEADER_OUT:
+        text = "=> Send header";
+        break;
+    case CURLINFO_DATA_OUT:
+        text = "=> Send data";
+        break;
+    case CURLINFO_SSL_DATA_OUT:
+        text = "=> Send SSL data";
+        break;
+    case CURLINFO_HEADER_IN:
+        text = "<= Recv header";
+        break;
+    case CURLINFO_DATA_IN:
+        text = "<= Recv data";
+        break;
+    case CURLINFO_SSL_DATA_IN:
+        text = "<= Recv SSL data";
+        break;
+    }
+
+    dump(text, stderr, (unsigned char *)data, size, config->trace_ascii);
+    return 0;
+}
+
+static int
+virCHMonitorCurlPerform(CURL *handle)
+{
+    CURLcode errorCode;
+    long responseCode = 0;
+
+    struct data config;
+
+    config.trace_ascii = 1; /* enable ascii tracing */
+
+    curl_easy_setopt(handle, CURLOPT_DEBUGFUNCTION, my_trace);
+    curl_easy_setopt(handle, CURLOPT_DEBUGDATA, &config);
+
+    /* the DEBUGFUNCTION has no effect until we enable VERBOSE */
+    curl_easy_setopt(handle, CURLOPT_VERBOSE, 1L);
+
+    errorCode = curl_easy_perform(handle);
+
+    if (errorCode != CURLE_OK) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("curl_easy_perform() returned an error: %s (%d)"),
+                       curl_easy_strerror(errorCode), errorCode);
+        return -1;
+    }
+
+    errorCode = curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE,
+                                  &responseCode);
+
+    if (errorCode != CURLE_OK) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("curl_easy_getinfo(CURLINFO_RESPONSE_CODE) returned an "
+                         "error: %s (%d)"), curl_easy_strerror(errorCode),
+                       errorCode);
+        return -1;
+    }
+
+    if (responseCode < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("curl_easy_getinfo(CURLINFO_RESPONSE_CODE) returned a "
+                         "negative response code"));
+        return -1;
+    }
+
+    return responseCode;
+}
+
+int
+virCHMonitorPutNoContent(virCHMonitorPtr mon, const char *endpoint)
+{
+    char *url;
+    int responseCode = 0;
+    int ret = -1;
+
+    url = g_strdup_printf("%s/%s", URL_ROOT, endpoint);
+
+    virObjectLock(mon);
+
+    /* reset all options of a libcurl session handle at first */
+    curl_easy_reset(mon->handle);
+
+    curl_easy_setopt(mon->handle, CURLOPT_UNIX_SOCKET_PATH, mon->socketpath);
+    curl_easy_setopt(mon->handle, CURLOPT_URL, url);
+    curl_easy_setopt(mon->handle, CURLOPT_PUT, true);
+    curl_easy_setopt(mon->handle, CURLOPT_HTTPHEADER, NULL);
+
+    responseCode = virCHMonitorCurlPerform(mon->handle);
+
+    virObjectUnlock(mon);
+
+    if (responseCode == 200 || responseCode == 204)
+        ret = 0;
+
+    VIR_FREE(url);
+    return ret;
+}
+
+int
+virCHMonitorGet(virCHMonitorPtr mon, const char *endpoint)
+{
+    char *url;
+    int responseCode = 0;
+    int ret = -1;
+
+    url = g_strdup_printf("%s/%s", URL_ROOT, endpoint);
+
+    virObjectLock(mon);
+
+    /* reset all options of a libcurl session handle at first */
+    curl_easy_reset(mon->handle);
+
+    curl_easy_setopt(mon->handle, CURLOPT_UNIX_SOCKET_PATH, mon->socketpath);
+    curl_easy_setopt(mon->handle, CURLOPT_URL, url);
+
+    responseCode = virCHMonitorCurlPerform(mon->handle);
+
+    virObjectUnlock(mon);
+
+    if (responseCode == 200 || responseCode == 204)
+        ret = 0;
+
+    VIR_FREE(url);
+    return ret;
+}
+
+int
+virCHMonitorPingVMM(virCHMonitorPtr mon)
+{
+    return virCHMonitorGet(mon, URL_VMM_PING);
+}
+
+int
+virCHMonitorShutdownVMM(virCHMonitorPtr mon)
+{
+    return virCHMonitorPutNoContent(mon, URL_VMM_SHUTDOWN);
+}
+
+int
+virCHMonitorCreateVM(virCHMonitorPtr mon)
+{
+    g_autofree char *url = NULL;
+    int responseCode = 0;
+    int ret = -1;
+    g_autofree char *payload = NULL;
+    struct curl_slist *headers = NULL;
+
+    url = g_strdup_printf("%s/%s", URL_ROOT, URL_VM_CREATE);
+    headers = curl_slist_append(headers, "Accept: application/json");
+    headers = curl_slist_append(headers, "Content-Type: application/json");
+    headers = curl_slist_append(headers, "Expect:");
+
+    if (virCHMonitorBuildVMJson(mon->vm->def, &payload) != 0)
+        return -1;
+
+    virObjectLock(mon);
+
+    /* reset all options of a libcurl session handle at first */
+    curl_easy_reset(mon->handle);
+
+    curl_easy_setopt(mon->handle, CURLOPT_UNIX_SOCKET_PATH, mon->socketpath);
+    curl_easy_setopt(mon->handle, CURLOPT_URL, url);
+    curl_easy_setopt(mon->handle, CURLOPT_CUSTOMREQUEST, "PUT");
+    curl_easy_setopt(mon->handle, CURLOPT_HTTPHEADER, headers);
+    curl_easy_setopt(mon->handle, CURLOPT_POSTFIELDS, payload);
+
+    responseCode = virCHMonitorCurlPerform(mon->handle);
+
+    virObjectUnlock(mon);
+
+    if (responseCode == 200 || responseCode == 204)
+        ret = 0;
+
+    curl_slist_free_all(headers);
+    VIR_FREE(url);
+    VIR_FREE(payload);
+    return ret;
+}
+
+int
+virCHMonitorBootVM(virCHMonitorPtr mon)
+{
+    return virCHMonitorPutNoContent(mon, URL_VM_BOOT);
+}
+
+int
+virCHMonitorShutdownVM(virCHMonitorPtr mon)
+{
+    return virCHMonitorPutNoContent(mon, URL_VM_SHUTDOWN);
+}
+
+int
+virCHMonitorRebootVM(virCHMonitorPtr mon)
+{
+    return virCHMonitorPutNoContent(mon, URL_VM_REBOOT);
+}
+
+int
+virCHMonitorSuspendVM(virCHMonitorPtr mon)
+{
+    return virCHMonitorPutNoContent(mon, URL_VM_Suspend);
+}
+
+int
+virCHMonitorResumeVM(virCHMonitorPtr mon)
+{
+    return virCHMonitorPutNoContent(mon, URL_VM_RESUME);
+}
diff --git a/src/ch/ch_monitor.h b/src/ch/ch_monitor.h
new file mode 100644
index 0000000000..bd6046a50b
--- /dev/null
+++ b/src/ch/ch_monitor.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright Intel Corp. 2020
+ *
+ * ch_driver.h: header file for Cloud-Hypervisor driver functions
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <curl/curl.h>
+
+#include "virobject.h"
+#include "domain_conf.h"
+
+#define URL_ROOT "http://localhost/api/v1";
+#define URL_VMM_SHUTDOWN "vmm.shutdown"
+#define URL_VMM_PING "vmm.ping"
+#define URL_VM_CREATE "vm.create"
+#define URL_VM_DELETE "vm.delete"
+#define URL_VM_BOOT "vm.boot"
+#define URL_VM_SHUTDOWN "vm.shutdown"
+#define URL_VM_REBOOT "vm.reboot"
+#define URL_VM_Suspend "vm.pause"
+#define URL_VM_RESUME "vm.resume"
+
+typedef struct _virCHMonitor virCHMonitor;
+typedef virCHMonitor *virCHMonitorPtr;
+
+struct _virCHMonitor {
+    virObjectLockable parent;
+
+    CURL *handle;
+
+    char *socketpath;
+
+    pid_t pid;
+
+    virDomainObjPtr vm;
+};
+
+virCHMonitorPtr virCHMonitorNew(virDomainObjPtr vm, const char *socketdir);
+void virCHMonitorClose(virCHMonitorPtr mon);
+
+int virCHMonitorCreateVM(virCHMonitorPtr mon);
+int virCHMonitorBootVM(virCHMonitorPtr mon);
+int virCHMonitorShutdownVM(virCHMonitorPtr mon);
+int virCHMonitorRebootVM(virCHMonitorPtr mon);
+int virCHMonitorSuspendVM(virCHMonitorPtr mon);
+int virCHMonitorResumeVM(virCHMonitorPtr mon);
diff --git a/src/ch/ch_process.c b/src/ch/ch_process.c
new file mode 100644
index 0000000000..15f4801549
--- /dev/null
+++ b/src/ch/ch_process.c
@@ -0,0 +1,125 @@
+/*
+ * Copyright Intel Corp. 2020
+ *
+ * ch_driver.h: header file for Cloud-Hypervisor driver functions
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "ch_domain.h"
+#include "ch_monitor.h"
+#include "ch_process.h"
+#include "viralloc.h"
+#include "virerror.h"
+#include "virlog.h"
+
+#define VIR_FROM_THIS VIR_FROM_CH
+
+VIR_LOG_INIT("ch.ch_process");
+
+#define START_SOCKET_POSTFIX ": starting up socket\n"
+#define START_VM_POSTFIX ": starting up vm\n"
+
+
+
+static virCHMonitorPtr virCHProcessConnectMonitor(virCHDriverPtr driver,
+                                                  virDomainObjPtr vm)
+{
+    virCHMonitorPtr monitor = NULL;
+    virCHDriverConfigPtr cfg = virCHDriverGetConfig(driver);
+
+    monitor = virCHMonitorNew(vm, cfg->stateDir);
+
+    virObjectUnref(cfg);
+    return monitor;
+}
+
+/**
+ * virCHProcessStart:
+ * @driver: pointer to driver structure
+ * @vm: pointer to virtual machine structure
+ * @reason: reason for switching vm to running state
+ *
+ * Starts Cloud-Hypervisor listen on a local socket
+ *
+ * Returns 0 on success or -1 in case of error
+ */
+int virCHProcessStart(virCHDriverPtr driver,
+                      virDomainObjPtr vm,
+                      virDomainRunningReason reason)
+{
+    int ret = -1;
+    virCHDomainObjPrivatePtr priv = vm->privateData;
+
+    if (!priv->monitor) {
+        /* And we can get the first monitor connection now too */
+        if (!(priv->monitor = virCHProcessConnectMonitor(driver, vm))) {
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                        _("failed to create connection to CH socket"));
+            goto cleanup;
+        }
+
+        if (virCHMonitorCreateVM(priv->monitor) < 0) {
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                        _("failed to create guest VM"));
+            goto cleanup;
+        }
+    }
+
+    if (virCHMonitorBootVM(priv->monitor) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("failed to boot guest VM"));
+        goto cleanup;
+    }
+
+    vm->pid = priv->monitor->pid;
+    vm->def->id = vm->pid;
+    virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, reason);
+
+    return 0;
+
+ cleanup:
+    if (ret)
+        virCHProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED);
+
+    return ret;
+}
+
+int virCHProcessStop(virCHDriverPtr driver G_GNUC_UNUSED,
+                     virDomainObjPtr vm,
+                     virDomainShutoffReason reason)
+{
+    virCHDomainObjPrivatePtr priv = vm->privateData;
+
+    VIR_DEBUG("Stopping VM name=%s pid=%d reason=%d",
+              vm->def->name, (int)vm->pid, (int)reason);
+
+    if (priv->monitor) {
+        virCHMonitorClose(priv->monitor);
+        priv->monitor = NULL;
+    }
+
+    vm->pid = -1;
+    vm->def->id = -1;
+
+    virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason);
+
+    return 0;
+}
diff --git a/src/ch/ch_process.h b/src/ch/ch_process.h
new file mode 100644
index 0000000000..22f3c39618
--- /dev/null
+++ b/src/ch/ch_process.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright Intel Corp. 2020
+ *
+ * ch_driver.h: header file for Cloud-Hypervisor driver functions
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "internal.h"
+
+int virCHProcessStart(virCHDriverPtr  driver,
+                      virDomainObjPtr vm,
+                      virDomainRunningReason reason);
+int virCHProcessStop(virCHDriverPtr driver,
+                     virDomainObjPtr vm,
+                     virDomainShutoffReason reason);
diff --git a/src/ch/meson.build b/src/ch/meson.build
new file mode 100644
index 0000000000..e41691bc05
--- /dev/null
+++ b/src/ch/meson.build
@@ -0,0 +1,44 @@
+ch_driver_sources = [
+  'ch_conf.c',
+  'ch_conf.h',
+  'ch_domain.c',
+  'ch_domain.h',
+  'ch_driver.c',
+  'ch_driver.h',
+  'ch_monitor.c',
+  'ch_monitor.h',
+  'ch_process.c',
+  'ch_process.h',
+]
+
+driver_source_files += files(ch_driver_sources)
+
+stateful_driver_source_files += files(ch_driver_sources)
+
+if conf.has('WITH_CH')
+  ch_driver_impl = static_library(
+    'virt_driver_ch_impl',
+    [
+      ch_driver_sources,
+    ],
+    dependencies: [
+      access_dep,
+      curl_dep,
+      log_dep,
+      src_dep,
+    ],
+    include_directories: [
+      conf_inc_dir,
+    ],
+  )
+
+  virt_modules += {
+    'name': 'virt_driver_ch',
+    'link_whole': [
+      ch_driver_impl,
+    ],
+    'link_args': [
+      libvirt_no_undefined,
+    ],
+  }
+endif
diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index 5d3ae8bb28..11b183ad2c 100644
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -130,6 +130,7 @@ VIR_ENUM_IMPL(virDomainVirt,
               "parallels",
               "bhyve",
               "vz",
+              "ch",
 );
 
 VIR_ENUM_IMPL(virDomainOS,
diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h
index 8a0f26f5c0..4dba588728 100644
--- a/src/conf/domain_conf.h
+++ b/src/conf/domain_conf.h
@@ -139,6 +139,7 @@ typedef enum {
     VIR_DOMAIN_VIRT_PARALLELS,
     VIR_DOMAIN_VIRT_BHYVE,
     VIR_DOMAIN_VIRT_VZ,
+    VIR_DOMAIN_VIRT_CH,
 
     VIR_DOMAIN_VIRT_LAST
 } virDomainVirtType;
diff --git a/src/meson.build b/src/meson.build
index 5d8deaf548..90fbee39e5 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -272,6 +272,7 @@ subdir('esx')
 subdir('hyperv')
 subdir('libxl')
 subdir('lxc')
+subdir('ch')
 subdir('openvz')
 subdir('qemu')
 subdir('test')
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index 6798febf8d..819b381e21 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -6820,6 +6820,7 @@ qemuBuildMachineCommandLine(virCommandPtr cmd,
     case VIR_DOMAIN_VIRT_PARALLELS:
     case VIR_DOMAIN_VIRT_BHYVE:
     case VIR_DOMAIN_VIRT_VZ:
+    case VIR_DOMAIN_VIRT_CH:
     case VIR_DOMAIN_VIRT_NONE:
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                        _("the QEMU binary does not support %s"),
diff --git a/src/remote/remote_daemon.c b/src/remote/remote_daemon.c
index 1aa9bfc0d2..f8df8de095 100644
--- a/src/remote/remote_daemon.c
+++ b/src/remote/remote_daemon.c
@@ -169,6 +169,10 @@ static int daemonInitialize(void)
     if (virDriverLoadModule("qemu", "qemuRegister", false) < 0)
         return -1;
 # endif
+# ifdef WITH_CH
+    if (virDriverLoadModule("ch", "chRegister", false) < 0)
+        return -1;
+# endif
 # ifdef WITH_LXC
     if (virDriverLoadModule("lxc", "lxcRegister", false) < 0)
         return -1;
diff --git a/src/util/virerror.c b/src/util/virerror.c
index 507a29f50f..9446c908bf 100644
--- a/src/util/virerror.c
+++ b/src/util/virerror.c
@@ -144,6 +144,7 @@ VIR_ENUM_IMPL(virErrorDomain,
 
               "TPM", /* 70 */
               "BPF",
+              "Cloud-Hypervisor Driver",
 );
 
 
diff --git a/tools/virsh.c b/tools/virsh.c
index 06ff5e8336..9555ea3374 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -510,6 +510,9 @@ virshShowVersion(vshControl *ctl G_GNUC_UNUSED)
 #ifdef WITH_OPENVZ
     vshPrint(ctl, " OpenVZ");
 #endif
+#ifdef WITH_CH
+    vshPrint(ctl, " Cloud-Hypervisor");
+#endif
 #ifdef WITH_VZ
     vshPrint(ctl, " Virtuozzo");
 #endif
-- 
2.26.2


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