- Devel - libvirt List Archives

[PATCH] Remove redundant check when storage pool is mounted
by Yi Li 23 Sep '20

23 Sep '20

virFileComparePaths just return 0 or 1 after commit 7b48bb8 so break while after virFileComparePaths return 1 Signed-off-by: Yi Li <yili(a)winhong.com> --- src/storage/storage_backend_fs.c | 8 ++------ src/util/virfile.c | 1 - 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/src/storage/storage_backend_fs.c b/src/storage/storage_backend_fs.c index 536e5cf952..30c2367df4 100644 --- a/src/storage/storage_backend_fs.c +++ b/src/storage/storage_backend_fs.c @@ -245,7 +245,6 @@ virStorageBackendFileSystemIsMounted(virStoragePoolObjPtr pool) FILE *mtab; struct mntent ent; char buf[1024]; - int rc1, rc2; g_autofree char *src = NULL; if ((mtab = fopen(_PATH_MOUNTED, "r")) == NULL) { @@ -262,11 +261,8 @@ virStorageBackendFileSystemIsMounted(virStoragePoolObjPtr pool) /* compare both mount destinations and sources to be sure the mounted * FS pool is really the one we're looking for */ - if ((rc1 = virFileComparePaths(ent.mnt_dir, def->target.path)) < 0 || - (rc2 = virFileComparePaths(ent.mnt_fsname, src)) < 0) - goto cleanup; - - if (rc1 && rc2) { + if (virFileComparePaths(ent.mnt_dir, def->target.path) && + virFileComparePaths(ent.mnt_fsname, src)) { ret = 1; goto cleanup; } diff --git a/src/util/virfile.c b/src/util/virfile.c index 61d2c16072..e120d277d0 100644 --- a/src/util/virfile.c +++ b/src/util/virfile.c @@ -3884,7 +3884,6 @@ virFileCopyACLs(const char *src, * Returns: * 1 : Equal * 0 : Non-Equal - * -1 : Error */ int virFileComparePaths(const char *p1, const char *p2) -- 2.25.3

2 1

[libvirt PATCH 0/3] esx: fix race when building tests
by Ján Tomko 23 Sep '20

23 Sep '20

This should get rid of some of the random CI fails: https://gitlab.com/libvirt/libvirt/-/jobs/726039284 Ján Tomko (3): esx: separate header and source file generation tests: esxutilstest: depend on esx_gen_headers sleep scripts/esx_vi_generator.py | 162 ++++++++++++++++++++---------------- src/esx/meson.build | 31 +++++-- tests/meson.build | 3 +- 3 files changed, 119 insertions(+), 77 deletions(-) -- 2.26.2

2 5

[PATCH v2 0/3] improve pSeries NVDIMM support
by Daniel Henrique Barboza 23 Sep '20

23 Sep '20

Hi, This is a follow up of [1] after Andrea pushed the revert patch as standalone. Changes from v1: - patch 2 (former 3): moved the auto-align code from virDomainMemoryDefParseXML() to virDomainMemoryDefPostParse() - patch 3 (former 4): updated NEWS.rst based on Andrea's changes already upstream [1] https://www.redhat.com/archives/libvir-list/2020-September/msg00864.html Daniel Henrique Barboza (3): conf, qemu: move qemuDomainNVDimmAlignSizePseries to domain_conf.c domain_conf.c: auto-align pSeries NVDIMM in virDomainMemoryDefPostParse() NEWS.rst: update NVDIMM changes entry NEWS.rst | 3 +- src/conf/domain_conf.c | 59 ++++++++++++++++++- src/conf/domain_conf.h | 3 + src/libvirt_private.syms | 1 + src/qemu/qemu_domain.c | 42 +------------ .../memory-hotplug-nvdimm-ppc64.xml | 2 +- 6 files changed, 67 insertions(+), 43 deletions(-) -- 2.26.2

2 6

[libvirt PATCH] virfirewalld: fix g_variant_get call
by Pavel Hrdina 23 Sep '20

23 Sep '20

We need to pass pointer to `array`. Reported-by: Ján Tomko <jtomko(a)redhat.com> Signed-off-by: Pavel Hrdina <phrdina(a)redhat.com> --- src/util/virfirewalld.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/util/virfirewalld.c b/src/util/virfirewalld.c index 69c8b73da0..12448f0681 100644 --- a/src/util/virfirewalld.c +++ b/src/util/virfirewalld.c @@ -215,7 +215,7 @@ virFirewallDGetZones(char ***zones, size_t *nzones) NULL) < 0) return -1; - g_variant_get(reply, "(@as)", array); + g_variant_get(reply, "(@as)", &array); *zones = g_variant_dup_strv(array, nzones); return 0; -- 2.26.2

2 2

[libvirt PATCH 0/9] [GSoC]: Libvirt driver for Jailhouse
by Daniel P. Berrangé 23 Sep '20

23 Sep '20

I'm sending this series on behalf of Prakhar Bansal who has been unable to sucessfully send the whole series. GMail is blocking sending of certain patches for unknown reasons. https://www.redhat.com/archives/libvir-list/2020-September/msg00309.html It is also available at https://github.com/pbansal2/libvirt/tree/jailhouse_driver Prakhar Bansal (9): Jailhouse driver: first commit with skeleton code Jailhouse driver: Implementation of ConnectOpen Jailhouse driver: Implementation of ConnectGetType Jailhouse driver: Implementation of DomainCreate* callbacks Jailhouse driver: Implementation of DomainInfo/State/List Jailhouse driver: Implementation of DomainLookup* callbacks Jailhouse driver: Implementation of DomainShutdown/Destroy callbacks Jailhouse driver: Fixes for creation of cells, fetching cell info, disabling jailhouse hypervisor Jailhouse driver: Add events to events queue in DomainCreate/Shutdown/Destroy include/libvirt/virterror.h | 1 + libvirt.spec.in | 7 + m4/virt-driver-jailhouse.m4 | 42 ++ meson.build | 4 + meson_options.txt | 1 + po/POTFILES.in | 2 + src/conf/domain_conf.c | 1 + src/conf/domain_conf.h | 1 + src/jailhouse/Makefile.inc.am | 47 ++ src/jailhouse/jailhouse.conf | 10 + src/jailhouse/jailhouse_api.c | 458 +++++++++++++++ src/jailhouse/jailhouse_api.h | 103 ++++ src/jailhouse/jailhouse_driver.c | 837 +++++++++++++++++++++++++++ src/jailhouse/jailhouse_driver.h | 82 +++ src/jailhouse/libvirtd_jailhouse.aug | 43 ++ src/jailhouse/meson.build | 49 ++ src/meson.build | 1 + src/qemu/qemu_command.c | 1 + src/remote/remote_daemon.c | 4 + src/remote/remote_daemon_dispatch.c | 3 +- src/util/virerror.c | 1 + 21 files changed, 1697 insertions(+), 1 deletion(-) create mode 100644 m4/virt-driver-jailhouse.m4 create mode 100644 src/jailhouse/Makefile.inc.am create mode 100644 src/jailhouse/jailhouse.conf create mode 100644 src/jailhouse/jailhouse_api.c create mode 100644 src/jailhouse/jailhouse_api.h create mode 100644 src/jailhouse/jailhouse_driver.c create mode 100644 src/jailhouse/jailhouse_driver.h create mode 100644 src/jailhouse/libvirtd_jailhouse.aug create mode 100644 src/jailhouse/meson.build -- 2.26.2

3 17

[libvirt PATCH] tests: Don't advertise VIR_TEST_EXPENSIVE to users
by Andrea Bolognani 23 Sep '20

23 Sep '20

Right now, the logic that takes care of deciding whether expensive tests should be run or not is not working correctly: more specifically, it's not possible to use something like $ VIR_TEST_EXPENSIVE=1 ninja test to override the default choice, because in meson.build we always pass an explicit value that overrides whatever is present in the environment. We could implement logic to make this work properly, but that would require some refactoring of our test infrastructure and is arguably of little value given that running $ meson build -Dexpensive_tests=enabled is very fast, so let's just stop telling users about the variable instead and call it a day. Signed-off-by: Andrea Bolognani <abologna(a)redhat.com> --- docs/advanced-tests.rst | 8 +------- meson_options.txt | 2 +- tests/test-lib.sh | 2 +- 3 files changed, 3 insertions(+), 9 deletions(-) diff --git a/docs/advanced-tests.rst b/docs/advanced-tests.rst index 772fe1dd16..f17d8b0031 100644 --- a/docs/advanced-tests.rst +++ b/docs/advanced-tests.rst @@ -26,13 +26,7 @@ Some tests are skipped by default in a development environment, based on the time they take in comparison to the likelihood that those tests will turn up problems during incremental builds. These tests default to being run when building from a -tarball or with the configure option -Dexpensive_tests=enabled; -you can also force a one-time toggle of these tests by setting -VIR_TEST_EXPENSIVE to 0 or 1 at make time, as in: - -:: - - $ VIR_TEST_EXPENSIVE=1 ninja test +tarball or with the configure option -Dexpensive_tests=enabled. If you encounter any failing tests, the VIR_TEST_DEBUG environment variable may provide extra information to debug the diff --git a/meson_options.txt b/meson_options.txt index f92c80553c..74de064384 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -3,7 +3,7 @@ option('packager', type: 'string', value: '', description: 'Extra packager name' option('packager_version', type: 'string', value: '', description: 'Extra packager version') option('system', type: 'boolean', value: false, description: 'Set install paths to system ones') option('runstatedir', type: 'string', value: '', description: 'State directory for temporary sockets, pid files, etc') -option('expensive_tests', type: 'feature', value: 'auto', description: 'set the default for enabling expensive tests (long timeouts), use VIR_TEST_EXPENSIVE to override') +option('expensive_tests', type: 'feature', value: 'auto', description: 'set the default for enabling expensive tests (long timeouts)') option('test_coverage', type: 'boolean', value: false, description: 'turn on code coverage instrumentation') option('git_werror', type: 'feature', value: 'auto', description: 'use -Werror if building from GIT') option('rpath', type: 'feature', value: 'auto', description: 'whether to include rpath information in installed binaries and libraries') diff --git a/tests/test-lib.sh b/tests/test-lib.sh index cc3924c07a..67065a9362 100644 --- a/tests/test-lib.sh +++ b/tests/test-lib.sh @@ -200,7 +200,7 @@ test_expensive() if test "$VIR_TEST_EXPENSIVE" != 1; then skip_test_ ' This test is very expensive, so it is disabled by default. -To run it anyway, rerun: VIR_TEST_EXPENSIVE=1 ninja test +To change the default, configure with: meson -Dexpensive_tests=enabled ' fi } -- 2.26.2

2 1

[libvirt PATCH] meson: Include value of expensive_tests in summary
by Andrea Bolognani 23 Sep '20

23 Sep '20

It's useful information to have available at a glance. Signed-off-by: Andrea Bolognani <abologna(a)redhat.com> --- meson.build | 1 + 1 file changed, 1 insertion(+) diff --git a/meson.build b/meson.build index 24535a403c..4d42468a51 100644 --- a/meson.build +++ b/meson.build @@ -2444,6 +2444,7 @@ win_summary = { summary(win_summary, section: 'Windows', bool_yn: true) test_summary = { + 'Expensive': use_expensive_tests, 'Coverage': coverage_flags.length() > 0, } summary(test_summary, section: 'Test suite', bool_yn: true) -- 2.26.2

2 1

[libvirt PATCH] docs: Document global_{period, quota} schedinfo fields
by Andrea Bolognani 23 Sep '20

23 Sep '20

These fields have existed for a very long time but they were never documented in virsh(1). https://bugzilla.redhat.com/show_bug.cgi?id=1354391 Signed-off-by: Andrea Bolognani <abologna(a)redhat.com> --- docs/manpages/virsh.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/manpages/virsh.rst b/docs/manpages/virsh.rst index 9fd5efed0f..bff23fc786 100644 --- a/docs/manpages/virsh.rst +++ b/docs/manpages/virsh.rst @@ -3758,7 +3758,8 @@ available for each hypervisor are: LXC (posix scheduler) : cpu_shares, vcpu_period, vcpu_quota QEMU/KVM (posix scheduler): cpu_shares, vcpu_period, vcpu_quota, -emulator_period, emulator_quota, iothread_quota, iothread_period +emulator_period, emulator_quota, global_period, global_quota, +iothread_period, iothread_quota Xen (credit scheduler): weight, cap -- 2.26.2

2 1

[libvirt PATCH 0/5] Various small fixes
by Ján Tomko 23 Sep '20

23 Sep '20

Reported by Coverity (7 months ago) or cppcheck (today). Ján Tomko (5): util: event: check return value of virInitialize qemu: firmware: check virJSONValueObjectGet return value rpc: socket: properly call virSetCloseExec virsh: do not return bool in virshNetworkPortUUIDCompleter Use (un)signed printf specifiers correctly examples/c/domain/domtop.c | 2 +- examples/c/domain/suspend.c | 2 +- src/qemu/qemu_firmware.c | 9 ++++++++- src/rpc/virnetsocket.c | 2 +- src/util/virevent.c | 3 ++- tests/qemusecuritymock.c | 2 +- tests/virhashtest.c | 4 ++-- tests/virpcimock.c | 2 +- tools/virsh-completer-network.c | 2 +- 9 files changed, 18 insertions(+), 10 deletions(-) -- 2.26.2

3 7

[RFC] Add basic driver for the Cloud-Hypervisor
by William Douglas 22 Sep '20

22 Sep '20

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(a)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

4 6