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

[GSoC PATCH 2/9] Jailhouse driver: Implementation of ConnectOpen




---
 include/libvirt/virterror.h         |   1 +
 po/POTFILES.in                      |   2 +
 src/jailhouse/Makefile.inc.am       |  34 ++-
 src/jailhouse/jailhouse.conf        |  10 +
 src/jailhouse/jailhouse_api.c       | 372 ++++++++++++++++++++++++++++
 src/jailhouse/jailhouse_api.h       |  74 ++++++
 src/jailhouse/jailhouse_driver.c    | 302 +++++++++++++++++-----
 src/jailhouse/jailhouse_driver.h    |  51 ++++
 src/jailhouse/meson.build           |   1 +
 src/libvirt.c                       |  10 -
 src/remote/remote_daemon.c          |   4 +
 src/remote/remote_daemon_dispatch.c |   3 +-
 12 files changed, 783 insertions(+), 81 deletions(-)
 create mode 100644 src/jailhouse/jailhouse.conf
 create mode 100644 src/jailhouse/jailhouse_api.c
 create mode 100644 src/jailhouse/jailhouse_api.h

diff --git a/include/libvirt/virterror.h b/include/libvirt/virterror.h
index 97f2ac16d8..9f1bca2684 100644
--- a/include/libvirt/virterror.h
+++ b/include/libvirt/virterror.h
@@ -137,6 +137,7 @@ typedef enum {
     VIR_FROM_TPM = 70,          /* Error from TPM */
     VIR_FROM_BPF = 71,          /* Error from BPF code */
     VIR_FROM_JAILHOUSE = 72,    /* Error from Jailhouse driver */
+
 # ifdef VIR_ENUM_SENTINELS
     VIR_ERR_DOMAIN_LAST
 # endif
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 3d6c20c55f..a94285817f 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -85,6 +85,8 @@
  SRCDIR@src/interface/interface_backend_netcf.c
  SRCDIR@src/interface/interface_backend_udev.c
  SRCDIR@src/internal.h
+ SRCDIR@src/jailhouse/jailhouse_api.c
+ SRCDIR@src/jailhouse/jailhouse_driver.c
  SRCDIR@src/libvirt-domain-checkpoint.c
  SRCDIR@src/libvirt-domain-snapshot.c
  SRCDIR@src/libvirt-domain.c
diff --git a/src/jailhouse/Makefile.inc.am b/src/jailhouse/Makefile.inc.am
index 02822b2ea1..324c3b1b16 100644
--- a/src/jailhouse/Makefile.inc.am
+++ b/src/jailhouse/Makefile.inc.am
@@ -1,8 +1,11 @@
 # vim: filetype=automake

+
 JAILHOUSE_DRIVER_SOURCES = \
        jailhouse/jailhouse_driver.c \
        jailhouse/jailhouse_driver.h \
+       jailhouse/jailhouse_api.c \
+       jailhouse/jailhouse_api.h \
        $(NULL)


@@ -11,11 +14,34 @@ DRIVER_SOURCE_FILES += $(addprefix $(srcdir)/,$(JAILHOUSE_DRIVER_SOURCES))
 EXTRA_DIST += $(JAILHOUSE_DRIVER_SOURCES)

 if WITH_JAILHOUSE
-noinst_LTLIBRARIES += libvirt_driver_jailhouse.la
-libvirt_la_BUILT_LIBADD += libvirt_driver_jailhouse.la
-libvirt_driver_jailhouse_la_CFLAGS = \
+
+noinst_LTLIBRARIES += libvirt_driver_jailhouse_impl.la
+libvirt_driver_jailhouse_la_SOURCES =
+libvirt_driver_jailhouse_la_LIBADD = \
+       libvirt_driver_jailhouse_impl.la \
+       libvirt.la \
+       $(GLIB_LIBS) \
+       $(NULL)
+mod_LTLIBRARIES += libvirt_driver_jailhouse.la
+libvirt_driver_jailhouse_la_LDFLAGS = $(AM_LDFLAGS_MOD_NOUNDEF)
+
+libvirt_driver_jailhouse_impl_la_CFLAGS = \
        -I$(srcdir)/conf \
        $(AM_CFLAGS) \
        $(NULL)
-libvirt_driver_jailhouse_la_SOURCES = $(JAILHOUSE_DRIVER_SOURCES)
+libvirt_driver_jailhouse_impl_la_SOURCES = \
+       $(JAILHOUSE_DRIVER_SOURCES)
+
+sbin_PROGRAMS += virtjailhoused
+
+virtjailhoused_SOURCES = $(REMOTE_DAEMON_SOURCES)
+nodist_virtjailhoused_SOURCES = $(REMOTE_DAEMON_GENERATED)
+virtjailhoused_CFLAGS = \
+       $(REMOTE_DAEMON_CFLAGS) \
+       -DDAEMON_NAME="\"virtjailhoused\"" \
+       -DMODULE_NAME="\"jailhouse\"" \
+       $(NULL)
+virtjailhoused_LDFLAGS = $(REMOTE_DAEMON_LD_FLAGS)
+virtjailhoused_LDADD = $(REMOTE_DAEMON_LD_ADD)
+
 endif WITH_JAILHOUSE
diff --git a/src/jailhouse/jailhouse.conf b/src/jailhouse/jailhouse.conf
new file mode 100644
index 0000000000..587068b9d0
--- /dev/null
+++ b/src/jailhouse/jailhouse.conf
@@ -0,0 +1,10 @@
+# Configuration for the Jailhouse driver.
+
+# Jailhouse system configuration file to enable the Jailhouse hypervisor on the
+# system. This is a required configuration parameter for the driver.
+#system_config = "/etc/libvirt/jailhouse/qemu-x86.cell"
+
+# Specify a directory which contains all the non-root cell configurations which
+# should be created by the driver at the startup. This is optional. Default
+# value of "/etc/libvirt/jailhouse/cells/" will be used if left empty.
+#non_root_cells_dir = "/etc/libvirt/jailhouse/cells/"
diff --git a/src/jailhouse/jailhouse_api.c b/src/jailhouse/jailhouse_api.c
new file mode 100644
index 0000000000..cda00b50e7
--- /dev/null
+++ b/src/jailhouse/jailhouse_api.c
@@ -0,0 +1,372 @@
+/*
+ * jailhouse_api.c: Jailhouse API
+ *
+ * Copyright (C) 2020 Prakhar Bansal
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <linux/types.h>
+
+#include "viralloc.h"
+#include "virerror.h"
+#include "virfile.h"
+#include "virlog.h"
+#include "virstring.h"
+#include "jailhouse_api.h"
+
+#define JAILHOUSE_DEVICE                        "/dev/jailhouse"
+#define JAILHOUSE_CELLS                         "/sys/devices/jailhouse/cells"
+#define MAX_JAILHOUSE_SYS_CONFIG_FILE_SIZE      1024*1024
+#define MAX_JAILHOUSE_CELL_CONFIG_FILE_SIZE     1024
+
+
+#define JAILHOUSE_ENABLE               _IOW(0, 0, void *)
+#define JAILHOUSE_DISABLE              _IO(0, 1)
+#define JAILHOUSE_CELL_CREATE          _IOW(0, 2, virJailhouseCellCreate)
+#define JAILHOUSE_CELL_DESTROY         _IOW(0, 5, virJailhouseCellId)
+
+#define VIR_FROM_THIS VIR_FROM_JAILHOUSE
+
+VIR_LOG_INIT("jailhouse.jailhouse_api");
+
+#define JAILHOUSE_CELL_FILE_EXTENSION ".cell"
+
+/* Forward declarations */
+
+/* Open the Jailhouse device for ioctl APIs */
+int openDev(void);
+
+/* Reads cell's property given by 'entry' using sysfs API */
+char *readSysfsCellString(const unsigned int id, const char *entry);
+
+int cell_match(const struct dirent *dirent);
+
+int createCell(const char *conf_file);
+
+int destroyCell(virJailhouseCellId cell_id);
+
+int getCellInfo(const unsigned int id,
+                virJailhouseCellInfoPtr * cell_info);
+
+int
+jailhouseEnable(const char *sys_conf_file_path)
+{
+    int err = -1, len;
+    g_autofree char *buffer = NULL;
+    VIR_AUTOCLOSE fd = -1;
+
+    if (!virFileExists(sys_conf_file_path))
+        return 0;
+
+    len = virFileReadAll(sys_conf_file_path, MAX_JAILHOUSE_SYS_CONFIG_FILE_SIZE, &buffer);
+    if (len < 0 || !buffer) {
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                      "%s", _("Failed to read the system configuration file"));
+        return -1;
+    }
+
+    fd = openDev();
+
+    err = ioctl(fd, JAILHOUSE_ENABLE, buffer);
+    if (err) {
+        virReportSystemError(errno, "%s", _("Failed to enable jailhouse"));
+        return err;
+    }
+
+    VIR_DEBUG("Jailhouse hypervisor is enabled");
+
+    return 1;
+}
+
+int
+jailhouseDisable(void)
+{
+    int err = -1;
+    VIR_AUTOCLOSE fd = -1;
+
+    fd = openDev();
+
+    err = ioctl(fd, JAILHOUSE_DISABLE);
+    if (err)
+        virReportSystemError(errno,
+                             "%s",
+                             _("Failed to disable jailhouse: %s"));
+
+    VIR_DEBUG("Jailhouse hypervisor is disabled");
+
+    return err;
+}
+
+int
+cell_match(const struct dirent *dirent)
+{
+    char *ext = strrchr(dirent->d_name, '.');
+
+    return dirent->d_name[0] != '.'
+        && (STREQ(ext, JAILHOUSE_CELL_FILE_EXTENSION) == 0);
+}
+
+int
+createJailhouseCells(const char *dir_path)
+{
+
+    struct dirent **namelist;
+    int num_entries, ret = -1;
+    size_t i;
+
+    if (strlen(dir_path) == 0)
+        return ret;
+
+    num_entries = scandir(dir_path, &namelist, cell_match, alphasort);
+    if (num_entries == -1) {
+        if (errno == ENOENT) {
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("No cells found in %s, scandir failed."),
+                           dir_path);
+            goto fail;
+        }
+
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("Error reading cell configurations in %s."),
+                       dir_path);
+        goto fail;
+    }
+
+
+    for (i = 0; i < num_entries; i++) {
+        g_autofree char *file_path = g_strdup_printf("%s/%s", dir_path, namelist[i]->d_name);
+
+        if (createCell(file_path) != 0) {
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                           _("Cell creation failed with conf found in  %s."),
+                           namelist[i]->d_name);
+            goto fail;
+        }
+    }
+
+    ret = 0;
+
+ fail:
+    VIR_FREE(namelist);
+    return ret;
+}
+
+int
+openDev(void)
+{
+    int fd;
+
+    fd = open(JAILHOUSE_DEVICE, O_RDWR);
+    if (fd < 0) {
+        virReportSystemError(errno,
+                             _("Error opening jailhouse device %s"),
+                             JAILHOUSE_DEVICE);
+    }
+    return fd;
+}
+
+int
+createCell(const char *conf_file)
+{
+    virJailhouseCellCreate cell_create;
+    int err = -1, len;
+    g_autofree char *buffer = NULL;
+    VIR_AUTOCLOSE fd = -1;
+
+    if (strlen(conf_file) == 0)
+        return err;
+
+    len = virFileReadAll(conf_file, MAX_JAILHOUSE_CELL_CONFIG_FILE_SIZE, &buffer);
+    if (len < 0 || !buffer) {
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                      "%s", _("Failed to read the system configuration file"));
+        return err;
+    }
+
+    cell_create.config_address = (unsigned long) buffer;
+    cell_create.config_size = len;
+
+    fd = openDev();
+
+    err = ioctl(fd, JAILHOUSE_CELL_CREATE, &cell_create);
+    if (err)
+        virReportSystemError(errno,
+                             "%s",
+                             _("Cell creation failed: %s"));
+
+    return err;
+}
+
+void
+cellInfoFree(virJailhouseCellInfoPtr cell_info)
+{
+    VIR_FREE(cell_info->state);
+    VIR_FREE(cell_info->cpus_assigned_list);
+    VIR_FREE(cell_info->cpus_failed_list);
+    VIR_FREE(cell_info);
+}
+
+char *
+readSysfsCellString(const unsigned int id, const char *entry)
+{
+    g_autofree char *buffer = NULL;
+    g_autofree char *file_path = NULL;
+    int len = -1;
+
+    file_path = g_strdup_printf(JAILHOUSE_CELLS "%u/%s", id, entry);
+
+    len = virFileReadAll(file_path, 1024, &buffer);
+    if (len < 0 || !buffer) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Error reading cell(%u) %s from %s failed"),
+                       id, entry, file_path);
+        return NULL;
+    }
+
+    virTrimSpaces(buffer, NULL);
+
+    return buffer;
+}
+
+int
+getCellInfo(const unsigned int id, virJailhouseCellInfoPtr * cell_info_ptr)
+{
+    char *tmp;
+
+    if (VIR_ALLOC(*cell_info_ptr) < 0)
+        return -1;
+
+    virJailhouseCellInfoPtr cell_info = *cell_info_ptr;
+
+    /* set cell id */
+    cell_info->id.id = id;
+
+    /* get cell name */
+    tmp = readSysfsCellString(id, "name");
+    if (virStrncpy(cell_info->id.name, tmp, JAILHOUSE_CELL_ID_NAMELEN, JAILHOUSE_CELL_ID_NAMELEN) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Cell ID %s too long to be copied to the cell info"),
+                       tmp);
+        return -1;
+    }
+
+    cell_info->id.name[JAILHOUSE_CELL_ID_NAMELEN] = 0;
+    VIR_FREE(tmp);
+
+    /* get cell state */
+    cell_info->state = readSysfsCellString(id, "state");
+
+    /* get assigned cpu list */
+    cell_info->cpus_assigned_list =
+        readSysfsCellString(id, "cpus_assigned_list");
+
+    /* get failed cpu list */
+    cell_info->cpus_failed_list =
+        readSysfsCellString(id, "cpus_failed_list");
+
+    return 0;
+}
+
+virJailhouseCellInfoPtr *
+getJailhouseCellsInfo(void)
+{
+    struct dirent **namelist;
+    virJailhouseCellInfoPtr *cell_info_list;
+    unsigned int id;
+    int num_entries;
+    size_t i;
+
+    num_entries =
+        scandir(JAILHOUSE_CELLS, &namelist, cell_match, alphasort);
+    if (num_entries == -1) {
+        if (errno == ENOENT) {
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("No cells found in %s, scandir failed."),
+                           JAILHOUSE_CELLS);
+            return NULL;
+        }
+
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Error reading cell IDs in %s."),
+                       JAILHOUSE_CELLS);
+        return NULL;
+    }
+
+    /* Allocate memory for 1 more than num_entries and make the last entry NULL. */
+    if (VIR_ALLOC_N(cell_info_list, num_entries + 1) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s",
+                       _("Insufficient memory for cells info list"));
+    }
+
+    /* Set the last entry to NULL. */
+    cell_info_list[num_entries] = NULL;
+
+    for (i = 0; i < num_entries; i++) {
+        if (virStrToLong_ui(namelist[i]->d_name, NULL, 10, &id) < 0) {
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Cell ID %s could not be converted to a long"),
+                           namelist[i]->d_name);
+            continue;
+        }
+
+        /* get the cell's information(name, state etc.) using sysfs */
+        getCellInfo(id, &cell_info_list[i]);
+        VIR_FREE(namelist[i]);
+    }
+
+    VIR_FREE(namelist);
+    return cell_info_list;
+}
+
+int
+destroyCell(virJailhouseCellId cell_id)
+{
+    int err = -1;
+    VIR_AUTOCLOSE fd = -1;
+
+    fd = openDev();
+
+    err = ioctl(fd, JAILHOUSE_CELL_DESTROY, &cell_id);
+    if (err)
+        virReportSystemError(errno,
+                             _("Destroying cell %d failed"),
+                             cell_id.id);
+
+    return err;
+}
+
+int
+destroyJailhouseCells(virJailhouseCellInfoPtr *cell_info_list G_GNUC_UNUSED)
+{
+
+    /* Iterate over all cells in cell_info_list and destroy each cell */
+    // TODO: Not implemented yet.
+
+    return 0;
+}
diff --git a/src/jailhouse/jailhouse_api.h b/src/jailhouse/jailhouse_api.h
new file mode 100644
index 0000000000..8362cb3d0f
--- /dev/null
+++ b/src/jailhouse/jailhouse_api.h
@@ -0,0 +1,74 @@
+/*
+ * jailhouse_api.h: Jailhouse hypervisor API implementation
+ *
+ * Copyright (C) 2020 Prakhar Bansal
+ *
+ * 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
+
+#define JAILHOUSE_CELL_ID_NAMELEN       31
+
+typedef struct _virJailhouseCellId virJailhouseCellId;
+
+struct _virJailhouseCellId {
+    __s32 id;
+    __u32 padding;
+    char name[JAILHOUSE_CELL_ID_NAMELEN + 1];
+};
+
+typedef struct _virJailhouseCellInfo virJailhouseCellInfo;
+typedef virJailhouseCellInfo *virJailhouseCellInfoPtr;
+
+struct _virJailhouseCellInfo {
+    struct _virJailhouseCellId id;
+    char *state;
+    char *cpus_assigned_list;
+    char *cpus_failed_list;
+};
+
+typedef struct _virJailhouseCellCreate virJailhouseCellCreate;
+
+struct _virJailhouseCellCreate {
+    __u64 config_address;
+    __u32 config_size;
+    __u32 padding;
+};
+
+// Enables the Jailhouse hypervisor by reading the hypervisor system
+// configuration from the given file and calls the ioctl API to
+// enable the hypervisor.
+int jailhouseEnable(const char *sys_conf_file_path);
+
+// Disables the Jailhouse hypervisor.
+int jailhouseDisable(void);
+
+/* Cell API methods */
+
+// Creates Jailhouse cells using the cells configurations
+// provided in the dir_name.
+int createJailhouseCells(const char *dir_path);
+
+// Destroys Jailhouse cells using the cell IDs provided in
+// the cell_info_list.
+int destroyJailhouseCells(virJailhouseCellInfoPtr *cell_info_list);
+
+// Returns cell's information in a null-terminated array of
+// virJailhouseCellInfoPtr for all the Jailhouse cells.
+virJailhouseCellInfoPtr *getJailhouseCellsInfo(void);
+
+// Free the cell info object.
+void cellInfoFree(virJailhouseCellInfoPtr cell_info);
diff --git a/src/jailhouse/jailhouse_driver.c b/src/jailhouse/jailhouse_driver.c
index 0175ba771b..ac9da4c85d 100644
--- a/src/jailhouse/jailhouse_driver.c
+++ b/src/jailhouse/jailhouse_driver.c
@@ -16,43 +16,228 @@
  * 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 <string.h>

+#include "configmake.h"
+#include "datatypes.h"
+#include "domain_conf.h"
 #include "jailhouse_driver.h"
 #include "virtypedparam.h"
 #include "virerror.h"
 #include "virstring.h"
 #include "viralloc.h"
-#include "domain_conf.h"
 #include "virfile.h"
-#include "datatypes.h"
+#include "virlog.h"
 #include "vircommand.h"
-#include <string.h>
+#include "virpidfile.h"

-#define UNUSED(x) (void)(x)
+#define VIR_FROM_THIS VIR_FROM_JAILHOUSE
+
+VIR_LOG_INIT("jailhouse.jailhouse_driver");
+
+static virClassPtr virJailhouseDriverConfigClass;
+static void virJailhouseDriverConfigDispose(void *obj);
+
+static virJailhouseDriverPtr jailhouse_driver;
+
+static int virJailhouseConfigOnceInit(void)
+{
+    if (!VIR_CLASS_NEW(virJailhouseDriverConfig, virClassForObject()))
+        return -1;
+
+    return 0;
+}
+
+VIR_ONCE_GLOBAL_INIT(virJailhouseConfig);
+
+
+static virJailhouseDriverConfigPtr
+virJailhouseDriverConfigNew(void)
+{
+    virJailhouseDriverConfigPtr cfg;
+
+    // TODO: Check if the following has to be uncommented.
+    if (virJailhouseConfigInitialize() < 0)
+        return NULL;
+
+    if (!(cfg = virObjectNew(virJailhouseDriverConfigClass)))
+        return NULL;
+
+    cfg->stateDir = g_strdup(JAILHOUSE_STATE_DIR);
+
+    cfg->sys_config_file_path = g_strdup(DATADIR "/jailhouse/system.cell");
+
+    cfg->cell_config_dir = g_strdup(DATADIR "/jailhouse/cells");
+
+    return cfg;
+}
+
+static void virJailhouseDriverConfigDispose(void *obj)
+{
+
+    virJailhouseDriverConfigPtr cfg = obj;
+
+    VIR_FREE(cfg->stateDir);
+    VIR_FREE(cfg->sys_config_file_path);
+    VIR_FREE(cfg->cell_config_dir);
+}
+
+static int
+jailhouseLoadConf(virJailhouseDriverConfigPtr config)
+{
+    g_autoptr(virConf) conf = NULL;
+
+    if (!virFileExists(JAILHOUSE_CONFIG_FILE))
+        return 0;
+
+    if (!(conf = virConfReadFile(JAILHOUSE_CONFIG_FILE, 0)))
+        return -1;
+
+    if (virConfGetValueString(conf, "system_config",
+                              &config->sys_config_file_path) < 0)
+        return -1;
+
+    if (virConfGetValueString(conf, "non_root_cells_dir",
+                              &config->cell_config_dir) < 0)
+        return -1;
+
+    return 1;
+}
+
+static int
+jailhouseCreateAndLoadCells(virJailhouseDriverPtr driver)
+{
+    if (!driver->config ||
+        !driver->config->cell_config_dir ||
+        strlen(driver->config->cell_config_dir) == 0)
+        return -1;
+
+    // Create all cells in the hypervisor.
+    if (createJailhouseCells(driver->config->cell_config_dir) < 0)
+        return -1;
+
+    // Get all cells created above.
+    driver->cell_info_list = getJailhouseCellsInfo();
+
+    return 0;
+}
+
+static void
+jailhouseFreeDriver(virJailhouseDriverPtr driver)
+{
+    if (!driver)
+        return;
+
+    virMutexDestroy(&driver->lock);
+    virObjectUnref(driver->config);
+    VIR_FREE(driver);
+}

 static virDrvOpenStatus
 jailhouseConnectOpen(virConnectPtr conn,
-                     virConnectAuthPtr auth,
-                     virConfPtr conf,
-                     unsigned int flags)
+                     virConnectAuthPtr auth G_GNUC_UNUSED,
+                     virConfPtr conf G_GNUC_UNUSED, unsigned int flags)
 {
-    UNUSED(conn);
-    UNUSED(auth);
-    UNUSED(conf);
-    UNUSED(flags);
-    return 0;
+    uid_t uid = geteuid();
+
+    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
+
+    if (!virConnectValidateURIPath(conn->uri->path, "jailhouse", uid == 0))
+        return VIR_DRV_OPEN_ERROR;
+
+    if (!jailhouse_driver) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("Jailhouse driver state is not initialized."));
+        return VIR_DRV_OPEN_ERROR;
+    }
+
+    conn->privateData = jailhouse_driver;
+
+    return VIR_DRV_OPEN_SUCCESS;
 }

+#define UNUSED(x) (void)(x)
+
 static int
 jailhouseConnectClose(virConnectPtr conn)
 {
-    UNUSED(conn);
+   conn->privateData = NULL;
+
+   return 0;
+}
+
+static int
+jailhouseStateCleanup(void)
+{
+    if (!jailhouse_driver)
+       return -1;
+
+    if (jailhouse_driver->lockFD != -1)
+        virPidFileRelease(jailhouse_driver->config->stateDir,
+                          "driver", jailhouse_driver->lockFD);
+
+    virMutexDestroy(&jailhouse_driver->lock);
+
+    jailhouseFreeDriver(jailhouse_driver);
     return 0;
 }

+static int
+jailhouseStateInitialize(bool privileged G_GNUC_UNUSED,
+                         const char *root G_GNUC_UNUSED,
+                         virStateInhibitCallback callback G_GNUC_UNUSED,
+                         void *opaque G_GNUC_UNUSED)
+{
+    virJailhouseDriverConfigPtr cfg = NULL;
+    int rc;
+
+    jailhouse_driver = g_new0(virJailhouseDriver, 1);
+    jailhouse_driver->lockFD = -1;
+
+    if (virMutexInit(&jailhouse_driver->lock) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("cannot initialize mutex"));
+        VIR_FREE(jailhouse_driver);
+        return VIR_DRV_STATE_INIT_ERROR;
+    }
+
+    if (!(cfg = virJailhouseDriverConfigNew()))
+        goto error;
+
+    jailhouse_driver->config = cfg;
+
+    if (jailhouseLoadConf(cfg) < 0)
+        goto error;
+
+    if (virFileMakePath(cfg->stateDir) < 0) {
+        virReportSystemError(errno, _("Failed to create state dir %s"),
+                             cfg->stateDir);
+        goto error;
+    }
+
+    if ((jailhouse_driver->lockFD = virPidFileAcquire(cfg->stateDir,
+                                                      "driver", false, getpid())) < 0)
+        goto error;
+
+    if ((rc = jailhouseEnable(cfg->sys_config_file_path)) < 0)
+        goto error;
+    else if (rc == 0)
+        return VIR_DRV_STATE_INIT_SKIPPED;
+
+    if (jailhouseCreateAndLoadCells(jailhouse_driver) < 0)
+        goto error;
+
+    return VIR_DRV_STATE_INIT_COMPLETE;
+
+ error:
+    jailhouseStateCleanup();
+    return VIR_DRV_STATE_INIT_ERROR;
+
+}
 static const char *
 jailhouseConnectGetType(virConnectPtr conn)
 {
@@ -69,36 +254,16 @@ jailhouseConnectGetHostname(virConnectPtr conn)
 }

 static int
-jailhouseNodeGetInfo(virConnectPtr conn,
-                     virNodeInfoPtr info)
+jailhouseNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info)
 {
     UNUSED(conn);
     UNUSED(info);
     return -1;
 }

-static int
-jailhouseConnectListDomains(virConnectPtr conn,
-                            int *ids,
-                            int maxids)
-{
-    UNUSED(conn);
-    UNUSED(ids);
-    UNUSED(maxids);
-    return -1;
-}
-
-static int
-jailhouseConnectNumOfDomains(virConnectPtr conn)
-{
-    UNUSED(conn);
-    return -1;
-}
-
 static int
 jailhouseConnectListAllDomains(virConnectPtr conn,
-                               virDomainPtr **domain,
-                               unsigned int flags)
+                               virDomainPtr ** domain, unsigned int flags)
 {
     UNUSED(conn);
     UNUSED(domain);
@@ -107,8 +272,7 @@ jailhouseConnectListAllDomains(virConnectPtr conn,
 }

 static virDomainPtr
-jailhouseDomainLookupByID(virConnectPtr conn,
-                          int id)
+jailhouseDomainLookupByID(virConnectPtr conn, int id)
 {
     UNUSED(conn);
     UNUSED(id);
@@ -116,8 +280,7 @@ jailhouseDomainLookupByID(virConnectPtr conn,
 }

 static virDomainPtr
-jailhouseDomainLookupByName(virConnectPtr conn,
-                            const char *name)
+jailhouseDomainLookupByName(virConnectPtr conn, const char *name)
 {
     UNUSED(conn);
     UNUSED(name);
@@ -125,8 +288,7 @@ jailhouseDomainLookupByName(virConnectPtr conn,
 }

 static virDomainPtr
-jailhouseDomainLookupByUUID(virConnectPtr conn,
-                            const unsigned char *uuid)
+jailhouseDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
 {
     UNUSED(conn);
     UNUSED(uuid);
@@ -157,8 +319,7 @@ jailhouseDomainDestroy(virDomainPtr domain)
 }

 static int
-jailhouseDomainGetInfo(virDomainPtr domain,
-                       virDomainInfoPtr info)
+jailhouseDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
 {
     UNUSED(domain);
     UNUSED(info);
@@ -167,9 +328,7 @@ jailhouseDomainGetInfo(virDomainPtr domain,

 static int
 jailhouseDomainGetState(virDomainPtr domain,
-                        int *state,
-                        int *reason,
-                        unsigned int flags)
+                        int *state, int *reason, unsigned int flags)
 {
     UNUSED(domain);
     UNUSED(state);
@@ -179,8 +338,7 @@ jailhouseDomainGetState(virDomainPtr domain,
 }

 static char *
-jailhouseDomainGetXMLDesc(virDomainPtr domain,
-                          unsigned int flags)
+jailhouseDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
 {
     UNUSED(domain);
     UNUSED(flags);
@@ -189,31 +347,43 @@ jailhouseDomainGetXMLDesc(virDomainPtr domain,

 static virHypervisorDriver jailhouseHypervisorDriver = {
     .name = "JAILHOUSE",
-    .connectOpen = jailhouseConnectOpen, /* 6.3.0 */
-    .connectClose = jailhouseConnectClose, /* 6.3.0 */
-    .connectListDomains = jailhouseConnectListDomains, /* 6.3.0 */
-    .connectNumOfDomains = jailhouseConnectNumOfDomains, /* 6.3.0 */
-    .connectListAllDomains = jailhouseConnectListAllDomains, /* 6.3.0 */
-    .domainLookupByID = jailhouseDomainLookupByID, /* 6.3.0 */
-    .domainLookupByUUID = jailhouseDomainLookupByUUID, /* 6.3.0 */
-    .domainLookupByName = jailhouseDomainLookupByName, /* 6.3.0 */
-    .domainGetXMLDesc = jailhouseDomainGetXMLDesc, /* 6.3.0 */
-    .domainCreate = jailhouseDomainCreate, /* 6.3.0 */
-    .connectGetType = jailhouseConnectGetType, /* 6.3.0 */
-    .connectGetHostname = jailhouseConnectGetHostname, /* 6.3.0 */
-    .nodeGetInfo = jailhouseNodeGetInfo, /* 6.3.0 */
-    .domainShutdown = jailhouseDomainShutdown, /* 6.3.0 */
-    .domainDestroy = jailhouseDomainDestroy, /* 6.3.0 */
-    .domainGetInfo = jailhouseDomainGetInfo, /* 6.3.0 */
-    .domainGetState = jailhouseDomainGetState, /* 6.3.0 */
+    .connectOpen = jailhouseConnectOpen,        /* 6.3.0 */
+    .connectClose = jailhouseConnectClose,      /* 6.3.0 */
+    .connectListAllDomains = jailhouseConnectListAllDomains,    /* 6.3.0 */
+    .domainLookupByID = jailhouseDomainLookupByID,      /* 6.3.0 */
+    .domainLookupByUUID = jailhouseDomainLookupByUUID,  /* 6.3.0 */
+    .domainLookupByName = jailhouseDomainLookupByName,  /* 6.3.0 */
+    .domainGetXMLDesc = jailhouseDomainGetXMLDesc,      /* 6.3.0 */
+    .domainCreate = jailhouseDomainCreate,      /* 6.3.0 */
+    .connectGetType = jailhouseConnectGetType,  /* 6.3.0 */
+    .connectGetHostname = jailhouseConnectGetHostname,  /* 6.3.0 */
+    .nodeGetInfo = jailhouseNodeGetInfo,        /* 6.3.0 */
+    .domainShutdown = jailhouseDomainShutdown,  /* 6.3.0 */
+    .domainDestroy = jailhouseDomainDestroy,    /* 6.3.0 */
+    .domainGetInfo = jailhouseDomainGetInfo,    /* 6.3.0 */
+    .domainGetState = jailhouseDomainGetState,  /* 6.3.0 */
 };

+
 static virConnectDriver jailhouseConnectDriver = {
+    .localOnly = true,
+    .uriSchemes = (const char *[]){ "jailhouse", NULL },
     .hypervisorDriver = &jailhouseHypervisorDriver,
 };

+
+static virStateDriver jailhouseStateDriver = {
+    .name = "JAILHOUSE",
+    .stateInitialize = jailhouseStateInitialize,
+    .stateCleanup = jailhouseStateCleanup,
+};
+
 int
 jailhouseRegister(void)
 {
-    return virRegisterConnectDriver(&jailhouseConnectDriver, false);
+    if (virRegisterConnectDriver(&jailhouseConnectDriver, false) < 0)
+        return -1;
+    if (virRegisterStateDriver(&jailhouseStateDriver) < 0)
+        return -1;
+    return 0;
 }
diff --git a/src/jailhouse/jailhouse_driver.h b/src/jailhouse/jailhouse_driver.h
index b0dbc8d033..8a0e111676 100644
--- a/src/jailhouse/jailhouse_driver.h
+++ b/src/jailhouse/jailhouse_driver.h
@@ -20,4 +20,55 @@

 #pragma once

+#include <linux/types.h>
+
+#include "jailhouse_api.h"
+
 int jailhouseRegister(void);
+
+#define JAILHOUSE_CONFIG_FILE SYSCONFDIR "/libvirt/jailhouse/jailhouse.conf"
+#define JAILHOUSE_STATE_DIR RUNSTATEDIR "/libvirt/jailhouse"
+
+#define JAILHOUSE_DEV "/dev/jailhouse"
+
+#define JAILHOUSE_SYSFS_DEV "/sys/devices/jailhouse/"
+
+typedef struct _virJailhouseDriver virJailhouseDriver;
+typedef virJailhouseDriver *virJailhouseDriverPtr;
+
+typedef struct _virJailhouseDriverConfig virJailhouseDriverConfig;
+typedef virJailhouseDriverConfig *virJailhouseDriverConfigPtr;
+
+struct _virJailhouseDriverConfig {
+    virObject parent;
+
+    char *stateDir;
+
+    // File path of the jailhouse system configuration
+    // for jailhouse enable/disable.
+    char *sys_config_file_path;
+
+    // Config directory where all jailhouse cell configurations
+    // are stored.
+    char *cell_config_dir;
+};
+
+struct _virJailhouseDriver {
+    virMutex lock;
+
+    // Jailhouse configuration read from the jailhouse.conf
+    virJailhouseDriverConfigPtr config;
+
+    /* pid file FD, ensures two copies of the driver can't use the same root */
+    int lockFD;
+
+    // All the cells created during connect open on the hypervisor.
+    virJailhouseCellInfoPtr *cell_info_list;
+};
+
+struct _jailhouseCell {
+    __s32 id;
+    char *state;
+    char *cpus_assigned_list;
+    char *cpus_failed_list;
+};
diff --git a/src/jailhouse/meson.build b/src/jailhouse/meson.build
index 45ceeecca3..a706985169 100644
--- a/src/jailhouse/meson.build
+++ b/src/jailhouse/meson.build
@@ -1,5 +1,6 @@
 jailhouse_sources = files(
   'jailhouse_driver.c',
+  'jailhouse_api.c',
 )

 driver_source_files += jailhouse_sources
diff --git a/src/libvirt.c b/src/libvirt.c
index 59b75c6f7b..b2d0ba3d23 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -75,9 +75,6 @@
 #ifdef WITH_BHYVE
 # include "bhyve/bhyve_driver.h"
 #endif
-#ifdef WITH_JAILHOUSE
-# include "jailhouse/jailhouse_driver.h"
-#endif
 #include "access/viraccessmanager.h"

 #define VIR_FROM_THIS VIR_FROM_NONE
@@ -274,10 +271,6 @@ virGlobalInit(void)
     if (hypervRegister() == -1)
         goto error;
 #endif
-#ifdef WITH_JAILHOUSE
-    if (jailhouseRegister() == -1)
-        goto error;
-#endif
 #ifdef WITH_REMOTE
     if (remoteRegister() == -1)
         goto error;
@@ -1010,9 +1003,6 @@ virConnectOpenInternal(const char *name,
 #endif
 #ifndef WITH_VZ
              STRCASEEQ(ret->uri->scheme, "parallels") ||
-#endif
-#ifndef WITH_JAILHOUSE
-             STRCASEEQ(ret->uri->scheme, "jailhouse") ||
 #endif
              false)) {
             virReportErrorHelper(VIR_FROM_NONE, VIR_ERR_CONFIG_UNSUPPORTED,
diff --git a/src/remote/remote_daemon.c b/src/remote/remote_daemon.c
index 1aa9bfc0d2..9d1b208a38 100644
--- a/src/remote/remote_daemon.c
+++ b/src/remote/remote_daemon.c
@@ -145,6 +145,10 @@ static int daemonInitialize(void)
     if (virDriverLoadModule("interface", "interfaceRegister", false) < 0)
         return -1;
 # endif
+# ifdef WITH_JAILHOUSE
+    if (virDriverLoadModule("jailhouse", "jailhouseRegister", false) < 0)
+        return -1;
+# endif
 # ifdef WITH_SECRETS
     if (virDriverLoadModule("secret", "secretRegister", false) < 0)
         return -1;
diff --git a/src/remote/remote_daemon_dispatch.c b/src/remote/remote_daemon_dispatch.c
index 53d17a8f4a..06d8fe6098 100644
--- a/src/remote/remote_daemon_dispatch.c
+++ b/src/remote/remote_daemon_dispatch.c
@@ -2115,7 +2115,8 @@ remoteDispatchConnectOpen(virNetServerPtr server G_GNUC_UNUSED,
         STREQ(type, "VBOX") ||
         STREQ(type, "bhyve") ||
         STREQ(type, "vz") ||
-        STREQ(type, "Parallels")) {
+        STREQ(type, "Parallels") ||
+        STREQ(type, "JAILHOUSE")) {
         VIR_DEBUG("Hypervisor driver found, setting URIs for secondary drivers");
         if (getuid() == 0) {
             priv->interfaceURI = "interface:///system";
--
2.17.1


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