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

[libvirt] [PATCH] hypervisor driver for Jailhouse



>From README:
The jailhouse hypervisor driver for the libvirt project aims to provide
rudimentary support for managing jailhouse with the libvirt library. The
main advantage of this is the possibility to use virt-manager as a GUI
to manage Jailhouse cells. Thus the driver is mainly built around the
API calls that virt-manager uses and needs.
Due to the concept of Jailhouse a lot of libvirt functions can't be
realized, so this driver isn't as full-featured as upstream drivers of
the libvirt project.
Currently the driver relies on the Jailhouse binary, which has to be
passed when connecting a libvirt client to it(e.g. virt-manager -c
jailhouse:///path/to/jailhouse/tools/jailhouse). This has the advantage
that remote support can be easily done by not passing the original
Jailhouse binary, but an executable that redirects its parameters
through ssh to the real Jailhouse binary and outputs that output. Be
aware though that the driver doesn't store any information about cells,
so most API calls use "jailhouse cell list" every time they're called to
get the current state.

I would like to get Jailhouse support upstream, any feedback is greatly
appreciated.
--
Christian Loehle


diff --git a/configure.ac b/configure.ac
index f481c50..8b68828 100644
--- a/configure.ac
+++ b/configure.ac
@@ -563,6 +563,10 @@ AC_ARG_WITH([hyperv],
   [AS_HELP_STRING([--with-hyperv],
     [add Hyper-V support @<:@default=check@:>@])])
 m4_divert_text([DEFAULTS], [with_hyperv=check])
+AC_ARG_WITH([jailhouse],
+  [AS_HELP_STRING([--with-jailhouse],
+    [add Jailhouse support @<:@default=yes@:>@])])
+m4_divert_text([DEFAULTS], [with_jailhouse=yes])
 AC_ARG_WITH([test],
   [AS_HELP_STRING([--with-test],
     [add test driver support @<:@default=yes@:>@])])
@@ -722,6 +726,16 @@ AM_CONDITIONAL([WITH_VMWARE], [test "$with_vmware"
= "yes"])
 
 
 dnl
+dnl Checks for the Jailhouse driver
+dnl
+
+if test "$with_jailhouse" = "yes"; then
+    AC_DEFINE_UNQUOTED([WITH_JAILHOUSE], 1, [whether Jailhouse driver
is enabled])
+fi
+AM_CONDITIONAL([WITH_JAILHOUSE], [test "$with_jailhouse" = "yes"])
+
+
+dnl
 dnl check for XDR
 dnl
 
@@ -1087,6 +1101,12 @@ dnl
 LIBVIRT_DRIVER_CHECK_BHYVE
 
 dnl
+dnl Checks for Jailhouse driver
+dnl
+
+AM_CONDITIONAL([WITH_JAILHOUSE], [test "$with_jailhouse" = "yes"])
+
+dnl
 dnl check for shell that understands <> redirection without truncation,
 dnl needed by src/qemu/qemu_monitor_{text,json}.c.
 dnl
@@ -2830,6 +2850,7 @@ AC_MSG_NOTICE([      ESX: $with_esx])
 AC_MSG_NOTICE([  Hyper-V: $with_hyperv])
 LIBVIRT_DRIVER_RESULT_VZ
 LIBVIRT_DRIVER_RESULT_BHYVE
+AC_MSG_NOTICE([Jailhouse: $with_jailhouse])
 AC_MSG_NOTICE([     Test: $with_test])
 AC_MSG_NOTICE([   Remote: $with_remote])
 AC_MSG_NOTICE([  Network: $with_network])
diff --git a/include/libvirt/virterror.h b/include/libvirt/virterror.h
index f716cb9..c8fe2d3 100644
--- a/include/libvirt/virterror.h
+++ b/include/libvirt/virterror.h
@@ -127,6 +127,7 @@ typedef enum {
     VIR_FROM_POLKIT = 60,       /* Error from polkit code */
     VIR_FROM_THREAD = 61,       /* Error from thread utils */
     VIR_FROM_ADMIN = 62,        /* Error from admin backend */
+    VIR_FROM_JAILHOUSE = 63,    /* Error from Jailhouse driver */
 
 # ifdef VIR_ENUM_SENTINELS
     VIR_ERR_DOMAIN_LAST
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 0cc5b99..2b144bf 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -59,6 +59,7 @@ src/hyperv/hyperv_wmi.c
 src/interface/interface_backend_netcf.c
 src/interface/interface_backend_udev.c
 src/internal.h
+src/jailhouse/jailhouse_driver.c
 src/libvirt.c
 src/libvirt-admin.c
 src/libvirt-domain.c
diff --git a/src/Makefile.am b/src/Makefile.am
index 99b4993..10d59de 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -578,6 +578,7 @@ DRIVER_SOURCE_FILES = \
     $(VMWARE_DRIVER_SOURCES) \
     $(XEN_DRIVER_SOURCES) \
     $(XENAPI_DRIVER_SOURCES) \
+    $(JAILHOUSE_DRIVER_SOURCES) \
     $(NULL)
 
 STATEFUL_DRIVER_SOURCE_FILES = \
@@ -860,6 +861,11 @@ BHYVE_DRIVER_SOURCES =                        \
         bhyve/bhyve_utils.h                \
         $(NULL)
 
+JAILHOUSE_DRIVER_SOURCES =                    \
+        jailhouse/jailhouse_driver.c            \
+        jailhouse/jailhouse_driver.h            \
+        $(NULL)
+
 NETWORK_DRIVER_SOURCES =                    \
         network/bridge_driver.h network/bridge_driver.c \
         network/bridge_driver_platform.h         \
@@ -1436,6 +1442,14 @@ libvirt_driver_vz_la_LIBADD =
$(PARALLELS_SDK_LIBS) $(LIBNL_LIBS)
 libvirt_driver_vz_la_SOURCES = $(VZ_DRIVER_SOURCES)
 endif WITH_VZ
 
+if WITH_JAILHOUSE
+noinst_LTLIBRARIES += libvirt_driver_jailhouse.la
+libvirt_la_BUILT_LIBADD += libvirt_driver_jailhouse.la
+libvirt_driver_jailhouse_la_CFLAGS = \
+        -I$(srcdir)/conf $(AM_CFLAGS)
+libvirt_driver_jailhouse_la_SOURCES = $(JAILHOUSE_DRIVER_SOURCES)
+endif WITH_JAILHOUSE
+
 if WITH_BHYVE
 noinst_LTLIBRARIES += libvirt_driver_bhyve_impl.la
 libvirt_driver_bhyve_la_SOURCES =
@@ -1801,6 +1815,7 @@ EXTRA_DIST +=                            \
         $(HYPERV_DRIVER_EXTRA_DIST)            \
         $(VZ_DRIVER_SOURCES)                \
         $(BHYVE_DRIVER_SOURCES)                \
+        $(JAILHOUSE_DRIVER_SOURCES)            \
         $(NETWORK_DRIVER_SOURCES)            \
         $(INTERFACE_DRIVER_SOURCES)            \
         $(STORAGE_DRIVER_SOURCES)            \
diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index 2edf123..00d17e9 100644
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -121,7 +121,8 @@ VIR_ENUM_IMPL(virDomainVirt, VIR_DOMAIN_VIRT_LAST,
               "phyp",
               "parallels",
               "bhyve",
-              "vz")
+              "vz",
+              "jailhouse")
 
 VIR_ENUM_IMPL(virDomainOS, VIR_DOMAIN_OSTYPE_LAST,
               "hvm",
diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h
index f10b534..27beef0 100644
--- a/src/conf/domain_conf.h
+++ b/src/conf/domain_conf.h
@@ -225,6 +225,7 @@ typedef enum {
     VIR_DOMAIN_VIRT_PARALLELS,
     VIR_DOMAIN_VIRT_BHYVE,
     VIR_DOMAIN_VIRT_VZ,
+    VIR_DOMAIN_VIRT_JAILHOUSE,
 
     VIR_DOMAIN_VIRT_LAST
 } virDomainVirtType;
diff --git a/src/jailhouse/README b/src/jailhouse/README
new file mode 100644
index 0000000..564cfbd
--- /dev/null
+++ b/src/jailhouse/README
@@ -0,0 +1,3 @@
+The jailhouse hypervisor driver for the libvirt project aims to provide
rudimentary support for managing jailhouse with the libvirt library. The
main advantage of this is the possibility to use virt-manager as a GUI
to manage Jailhouse cells. Thus the driver is mainly built around the
API calls that virt-manager uses and needs.
+Due to the concept of Jailhouse a lot of libvirt functions can't be
realized, so this driver isn't as full-featured as upstream drivers of
the libvirt project.
+Currently the driver relies on the Jailhouse binary, which has to be
passed when connecting a libvirt client to it(e.g. virt-manager -c
jailhouse:///path/to/jailhouse/tools/jailhouse). This has the advantage
that remote support can be easily done by not passing the original
Jailhouse binary, but an executable that redirects its parameters
through ssh to the real Jailhouse binary and outputs that output. Be
aware though that the driver doesn't store any information about cells,
so most API calls use "jailhouse cell list" every time they're called to
get the current state.
diff --git a/src/jailhouse/jailhouse_driver.c
b/src/jailhouse/jailhouse_driver.c
new file mode 100644
index 0000000..21acbba
--- /dev/null
+++ b/src/jailhouse/jailhouse_driver.c
@@ -0,0 +1,614 @@
+/*
+ * jailhouse_driver.c: hypervisor driver for managing Jailhouse cells
+ *
+ * Copyright (C) 2015 Linutronix GmbH
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Author: Christian Loehle
+ */
+
+#include <config.h>
+#include <string.h>
+#include "jailhouse_driver.h"
+#include "datatypes.h"
+#include "virerror.h"
+#include "viralloc.h"
+#include "virlog.h"
+#include "vircommand.h"
+#include "virxml.h"
+#include "configmake.h"
+#include "virfile.h"
+#include "virtypedparam.h"
+#include "virstring.h"
+#include "nodeinfo.h"
+
+#define VIR_FROM_THIS VIR_FROM_JAILHOUSE
+
+#define IDLENGTH 8
+#define NAMELENGTH 24
+#define STATELENGTH 16
+#define CPULENGTH 24
+#define STATERUNNING 0
+#define STATERUNNINGSTRING          "running         "
+#define STATERUNNINGLOCKED 1
+#define STATERUNNINGLOCKEDSTRING    "running/locked  "
+#define STATESHUTDOWN 2
+#define STATESHUTDOWNSTRING         "shut down       "
+#define STATEFAILED 3
+#define STATEFAILEDSTRING           "failed          "
+#define JAILHOUSEVERSIONOUTPUT      "Jailhouse management tool"
+
+/*
+ *  The driver requeries the cells on most calls, it stores the result
of the last query, so it can copy the UUIDs in the new query if the cell
is the same(otherwise it just generates a new one)
+ *  not preserving the UUID results in a lot of bugs in libvirts clients.
+ */
+struct jailhouse_driver {
+    char *binary;
+    size_t lastQueryCellsCount;
+    struct jailhouse_cell* lastQueryCells;
+};
+
+/*
+ *  CPUs are currently unused but this might change
+ */
+struct jailhouse_cell {
+    int id;
+    char name[NAMELENGTH+1];
+    int state;
+    int *assignedCPUs; //Don't use cpumask because remote system might
have different # of cpus
+    int assignedCPUsLength;
+    int *failedCPUs;
+    int failedCPUsLength;
+    unsigned char uuid[VIR_UUID_BUFLEN];
+};
+
+/*
+ *  helper function that returns the number as an integer and sets i to
be the first char after the number
+ */
+static int
+charsToInt(char* chars, size_t *i)
+{
+    int result = 0;
+    while (chars[*i] != ',' && chars[*i] != '-' && chars[*i] != ' ') {
+        result *= 10;
+        result += chars[*i] - '0';
+        (*i)++;
+    }
+    return result;
+}
+
+/*
+ *  Takes a string in the format of "jailhouse cell list" as input,
+ *  allocates an int array in which every CPU is explicitly listed and
saves a pointer in cpusptr
+ */
+static size_t
+parseCPUs(char* output, int **cpusptr)
+{
+    size_t i;
+    size_t count = 1;
+    int number;
+    int* cpus;
+    if (output[0] == ' ') {
+        *cpusptr = NULL;
+        return 0;
+    }
+    for (i = 0; i<CPULENGTH; i++) {
+        number = charsToInt(output, &i);
+        if (output[i] == ',') {
+            count++;
+        } else if (output[i] == '-') {
+            i++;
+            count += charsToInt(output, &i) - number;
+       }
+    }
+    if (VIR_ALLOC_N(cpus, count)) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                    _("Failed to allocate CPUs array of size %zu"), count);
+        return 0;
+    }
+    size_t j = 0;
+    i = 0;
+    while (output[i] != ' ') {
+        number = charsToInt(output, &i);
+        if (output[i] == ',' || output[i] == ' ') {
+            cpus[j++] = number;
+        } else if (output[i] == '-') {
+            i++;
+            int nextNumber = charsToInt(output, &i);
+            for (; number <= nextNumber; number++) cpus[j++] = number;
+        }
+        i++;
+    }
+    *cpusptr = cpus;
+    return count;
+}
+
+/*
+ *  calls "jailhouse cell list" and parses the output in an array of
jailhouse_cell
+ */
+static size_t
+parseListOutput(virConnectPtr conn, struct jailhouse_cell **parsedOutput)
+{
+    virCommandPtr cmd = virCommandNew(((struct jailhouse_driver
*)conn->privateData)->binary);
+    virCommandAddArg(cmd, "cell");
+    virCommandAddArg(cmd, "list");
+    virCommandAddEnvPassCommon(cmd);
+    char *output;
+    virCommandSetOutputBuffer(cmd, &output);
+    size_t count = -1; //  Don't count table header line
+    size_t i = 0;
+    if (virCommandRun(cmd, NULL) < 0)
+        goto error;
+    while (output[i] != '\0') {
+        if (output[i] == '\n') count++;
+        i++;
+    }
+    if (VIR_ALLOC_N(*parsedOutput, count)) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                  _("Failed to allocate jailhouse_cell array of size
%zu"), count);
+        goto error;
+    }
+    if (*parsedOutput == NULL)
+        goto error;
+    i = 0;
+    size_t j;
+    while (output[i++] != '\n'); //  Skip table header line
+    for (j = 0; j < count; j++) {
+        size_t k;
+        for (k = 0; k <= IDLENGTH; k++) // char after number needs to
be NUL for virStrToLong
+            if (output[i+k] == ' ') {
+                output[i+k] = '\0';
+                break;
+            }
+        char c = output[i+IDLENGTH];
+        output[i+IDLENGTH] = '\0'; //   in case ID is 8 chars long, so
beginning of name won't get parsed
+        if (virStrToLong_i(output+i, NULL, 0, &(*parsedOutput)[j].id))
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                    _("Failed to parse id to long: %s"), output+i);
+        output[i+IDLENGTH] = c;
+        i += IDLENGTH;
+        if (virStrncpy((*parsedOutput)[j].name, output+i, NAMELENGTH,
NAMELENGTH+1) == NULL)
+            // should never happen
+            goto error;
+        (*parsedOutput)[j].name[NAMELENGTH] = '\0';
+        for (k = 0; k < NAMELENGTH; k++)
+            if ((*parsedOutput)[j].name[k] == ' ')
+                    break;
+        (*parsedOutput)[j].name[k] = '\0';
+        i += NAMELENGTH;
+        if (STREQLEN(output+i, STATERUNNINGSTRING, STATELENGTH))
(*parsedOutput)[j].state = STATERUNNING;
+        else if (STREQLEN(output+i, STATESHUTDOWNSTRING, STATELENGTH))
(*parsedOutput)[j].state = STATESHUTDOWN;
+        else if (STREQLEN(output+i, STATEFAILEDSTRING, STATELENGTH))
(*parsedOutput)[j].state = STATEFAILED;
+        else if (STREQLEN(output+i, STATERUNNINGLOCKEDSTRING,
STATELENGTH)) (*parsedOutput)[j].state = STATERUNNINGLOCKED;
+        i += STATELENGTH;
+        (*parsedOutput)[j].assignedCPUsLength = parseCPUs(output+i,
&((*parsedOutput)[j].assignedCPUs));
+        i += CPULENGTH;
+        (*parsedOutput)[j].failedCPUsLength = parseCPUs(output+i,
&((*parsedOutput)[j].failedCPUs));
+        i += CPULENGTH;
+        i++; // skip \n
+    }
+    VIR_FREE(output);
+    return count;
+    error:
+    for (i = 0; i < count; i++) {
+        VIR_FREE((*parsedOutput)[i].assignedCPUs);
+        VIR_FREE((*parsedOutput)[i].failedCPUs);
+    }
+    VIR_FREE(*parsedOutput);
+    *parsedOutput = NULL;
+    VIR_FREE(output);
+    output = NULL;
+    return -1;
+}
+
+/*
+ *  Returns the libvirts equivalent of the cell state passed to it
+ */
+static virDomainState
+cellToVirDomainState(struct jailhouse_cell *cell)
+{
+    switch (cell->state) {
+        case STATERUNNING: return VIR_DOMAIN_RUNNING;
+        case STATERUNNINGLOCKED: return VIR_DOMAIN_RUNNING;
+        case STATESHUTDOWN: return VIR_DOMAIN_SHUTOFF;
+        case STATEFAILED: return VIR_DOMAIN_CRASHED;
+        default: return VIR_DOMAIN_NOSTATE;
+    }
+}
+
+/*
+ *  Returns a new virDomainPtr filled with the data of the jailhouse_cell
+ */
+static virDomainPtr
+cellToVirDomainPtr(virConnectPtr conn, struct jailhouse_cell *cell)
+{
+    virDomainPtr dom = virGetDomain(conn, cell->name, cell->uuid);
+    dom->id = cell->id;
+    return dom;
+}
+
+/*
+ *  Check cells for cell and copies UUID if found, otherwise generates
a new one, this is to preserve UUID in libvirt
+ */
+static void setUUID(struct jailhouse_cell *cells, size_t count, struct
jailhouse_cell* cell) {
+    size_t i;
+    for (i = 0; i < count; i++) {
+        if (strncmp(cells[i].name, cell->name, NAMELENGTH+1))
+            continue;
+        memcpy(cell->uuid, cells[i].uuid, VIR_UUID_BUFLEN);
+        return;
+    }
+    virUUIDGenerate(cell->uuid);
+}
+
+/*
+ *  Frees the old list of cells, gets the new one and preserves UUID if
cells were present in the old
+ */
+static void
+getCurrentCellList(virConnectPtr conn)
+{
+    size_t lastCount = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCellsCount;
+    struct jailhouse_cell *lastCells = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCells;
+    struct jailhouse_cell *cells = NULL;
+    size_t i;
+    size_t count = parseListOutput(conn, &cells);
+    for (i = 0; i < count; i++)
+        setUUID(lastCells, lastCount, cells+i);
+    for (i = 0; i < lastCount; i++) {
+        VIR_FREE(lastCells[i].assignedCPUs);
+        VIR_FREE(lastCells[i].failedCPUs);
+    }
+    VIR_FREE(lastCells);
+    ((struct jailhouse_driver *)conn->privateData)->lastQueryCells = cells;
+    ((struct jailhouse_driver *)conn->privateData)->lastQueryCellsCount
= count;
+}
+
+/*
+ *  Converts libvirts virDomainPtr to the internal jailhouse_cell by
parsing the "jailhouse cell list" output
+ *  and looking up the name of the virDomainPtr, returns NULL if cell
is no longer present
+ */
+static struct jailhouse_cell *
+virDomainPtrToCell(virDomainPtr dom)
+{
+    getCurrentCellList(dom->conn);
+    size_t cellsCount = ((struct jailhouse_driver
*)dom->conn->privateData)->lastQueryCellsCount;
+    struct jailhouse_cell *cells = ((struct jailhouse_driver
*)dom->conn->privateData)->lastQueryCells;
+    size_t i;
+    for (i = 0; i < cellsCount; i++)
+        if (dom->id == cells[i].id)
+                return cells+i;
+    return NULL;
+}
+
+static virDrvOpenStatus
+jailhouseConnectOpen(virConnectPtr conn, virConnectAuthPtr auth
ATTRIBUTE_UNUSED, unsigned int flags)
+{
+    virCheckFlags(0, VIR_DRV_OPEN_ERROR);
+    if (conn->uri->scheme == NULL ||
+            STRNEQ(conn->uri->scheme, "jailhouse"))
+            return VIR_DRV_OPEN_DECLINED;
+    char* binary;
+    if (conn->uri->path == NULL) {
+        if (VIR_STRDUP(binary, "jailhouse") != 1)
+            return VIR_DRV_OPEN_ERROR;
+    } else {
+        if (!virFileIsExecutable(conn->uri->path)) {
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Path '%s', is not a valid executable file."),
+                           conn->uri->path);
+            return VIR_DRV_OPEN_ERROR;
+        }
+        if (VIR_STRDUP(binary, conn->uri->path) != 1)
+            return VIR_DRV_OPEN_ERROR;
+    }
+    virCommandPtr cmd = virCommandNew(binary);
+    virCommandAddArg(cmd, "--version");
+    virCommandAddEnvPassCommon(cmd);
+    char *output;
+    virCommandSetOutputBuffer(cmd, &output);
+    if (virCommandRun(cmd, NULL) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Executing '%s --version' failed."),
+                       conn->uri->path);
+        VIR_FREE(output);
+        return VIR_DRV_OPEN_ERROR;
+    }
+    if (STRNEQLEN(JAILHOUSEVERSIONOUTPUT, output,
strlen(JAILHOUSEVERSIONOUTPUT))) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("%s doesn't seem to be a correct Jailhouse
binary."),
+                       conn->uri->path);
+        VIR_FREE(output);
+        return VIR_DRV_OPEN_ERROR;
+    }
+    VIR_FREE(output);
+    struct jailhouse_driver *driver;
+    if (VIR_ALLOC(driver))
+        return VIR_DRV_OPEN_ERROR;
+    driver->binary = binary;
+    driver->lastQueryCells = NULL;
+    driver->lastQueryCellsCount = 0;
+    conn->privateData = driver;
+    return VIR_DRV_OPEN_SUCCESS;
+}
+
+static int
+jailhouseConnectClose(virConnectPtr conn)
+{
+    size_t i;
+    size_t cellsCount = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCellsCount;
+    struct jailhouse_cell *cells = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCells;
+    for (i = 0; i < cellsCount; i++) {
+        VIR_FREE(cells[i].assignedCPUs);
+        VIR_FREE(cells[i].failedCPUs);
+    }
+    VIR_FREE(cells);
+    VIR_FREE(((struct jailhouse_driver *)conn->privateData)->binary);
+    VIR_FREE(conn->privateData);
+    conn->privateData = NULL;
+    return 0;
+}
+
+static int
+jailhouseConnectNumOfDomains(virConnectPtr conn)
+{
+    getCurrentCellList(conn);
+    return ((struct jailhouse_driver
*)conn->privateData)->lastQueryCellsCount;
+}
+
+static int
+jailhouseConnectListDomains(virConnectPtr conn, int * ids, int maxids)
+{
+    getCurrentCellList(conn);
+    size_t cellsCount = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCellsCount;
+    struct jailhouse_cell *cells = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCells;
+    size_t i;
+    for (i = 0; i < maxids && i < cellsCount; i++)
+        ids[i] = cells[i].id;
+    return i;
+}
+
+static int
+jailhouseConnectListAllDomains(virConnectPtr conn, virDomainPtr **
domains, unsigned int flags)
+{
+    virCheckFlags(VIR_CONNECT_LIST_DOMAINS_ACTIVE, 0);
+    getCurrentCellList(conn);
+    size_t cellsCount = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCellsCount;
+    struct jailhouse_cell *cells = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCells;
+    if (cellsCount == -1)
+        goto error;
+    if (VIR_ALLOC_N(*domains, cellsCount+1)) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                    _("Failed to allocate virDomainPtr array of size
%zu"), cellsCount+1);
+        goto error;
+    }
+    size_t i;
+    for (i = 0; i < cellsCount; i++)
+        (*domains)[i] = cellToVirDomainPtr(conn, cells+i);
+    (*domains)[cellsCount] = NULL;
+    return cellsCount;
+    error:
+    *domains = NULL;
+    return -1;
+}
+
+static virDomainPtr
+jailhouseDomainLookupByID(virConnectPtr conn, int id)
+{
+    getCurrentCellList(conn);
+    size_t cellsCount = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCellsCount;
+    if (cellsCount == -1)
+        return NULL;
+    struct jailhouse_cell *cells = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCells;
+    size_t i;
+    for (i = 0; i < cellsCount; i++)
+        if (cells[i].id == id)
+            return cellToVirDomainPtr(conn, cells+i);
+    virReportError(VIR_ERR_NO_DOMAIN, NULL);
+    return NULL;
+}
+
+static virDomainPtr
+jailhouseDomainLookupByName(virConnectPtr conn, const char *lookupName)
+{
+    getCurrentCellList(conn);
+    size_t cellsCount = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCellsCount;
+    if (cellsCount == -1)
+        return NULL;
+    struct jailhouse_cell *cells = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCells;
+    size_t i;
+    for (i = 0; i < cellsCount; i++)
+        if (STREQ(cells[i].name, lookupName))
+            return cellToVirDomainPtr(conn, cells+i);
+    virReportError(VIR_ERR_NO_DOMAIN, NULL);
+    return NULL;
+}
+
+static virDomainPtr
+jailhouseDomainLookupByUUID(virConnectPtr conn, const unsigned char * uuid)
+{
+    getCurrentCellList(conn);
+    size_t cellsCount = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCellsCount;
+    if (cellsCount == -1)
+        return NULL;
+    struct jailhouse_cell *cells = ((struct jailhouse_driver
*)conn->privateData)->lastQueryCells;
+    size_t i;
+    for (i = 0; i < cellsCount; i++)
+        if (memcmp(cells[i].uuid, (const char*)uuid, VIR_UUID_BUFLEN) == 0)
+            return cellToVirDomainPtr(conn, cells+i);
+    virReportError(VIR_ERR_NO_DOMAIN, NULL);
+    return NULL;
+}
+
+/*
+ *  There currently is no straightforward way for the driver to
retrieve those,
+ *  so maxMem, memory and cpuTime have dummy values
+ */
+static int
+jailhouseDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
+{
+    struct jailhouse_cell *cell = virDomainPtrToCell(domain);
+    if (cell == NULL)
+        return -1;
+    info->state = cellToVirDomainState(cell);
+    info->maxMem = 1;
+    info->memory = 1;
+    info->nrVirtCpu = cell->assignedCPUsLength;
+    info->cpuTime = 1;
+    return 0;
+}
+
+static int
+jailhouseDomainGetState(virDomainPtr domain, int *state,
+                        int *reason ATTRIBUTE_UNUSED, unsigned int flags)
+{
+    virCheckFlags(0, 0);
+    struct jailhouse_cell *cell = virDomainPtrToCell(domain);
+    if (cell == NULL)
+        return -1;
+    *state = cellToVirDomainState(cell);
+    return 0;
+}
+
+static int
+jailhouseDomainShutdown(virDomainPtr domain)
+{
+    virCommandPtr cmd = virCommandNew(((struct jailhouse_driver
*)domain->conn->privateData)->binary);
+    virCommandAddArg(cmd, "cell");
+    virCommandAddArg(cmd, "shutdown");
+    char buf[IDLENGTH+1];
+    snprintf(buf, IDLENGTH+1, "%d", domain->id);
+    virCommandAddArg(cmd, buf);
+    virCommandAddEnvPassCommon(cmd);
+    int resultcode = virCommandRun(cmd, NULL);
+    if (resultcode < 0)
+        return -1;
+    return 0;
+}
+
+/*
+ *  CAREFUL, this is the Jailhouse destroy, not the libvirt destroy,
cell will be deleted and would need to be created and loaded again.
+ *  This is implemented anyway, so libvirt clients have an option to
use jailhouse destroy too.
+ */
+static int
+jailhouseDomainDestroy(virDomainPtr domain)
+{
+    virCommandPtr cmd = virCommandNew(((struct jailhouse_driver
*)domain->conn->privateData)->binary);
+    virCommandAddArg(cmd, "cell");
+    virCommandAddArg(cmd, "destroy");
+    char buf[IDLENGTH+1];
+    snprintf(buf, IDLENGTH+1, "%d", domain->id);
+    virCommandAddArg(cmd, buf);
+    virCommandAddEnvPassCommon(cmd);
+    int resultcode = virCommandRun(cmd, NULL);
+    if (resultcode < 0)
+        return -1;
+    return 0;
+}
+
+static int
+jailhouseDomainCreate(virDomainPtr domain)
+{
+    virCommandPtr cmd = virCommandNew(((struct jailhouse_driver
*)domain->conn->privateData)->binary);
+    virCommandAddArg(cmd, "cell");
+    virCommandAddArg(cmd, "start");
+    char buf[IDLENGTH+1];
+    snprintf(buf, IDLENGTH+1, "%d", domain->id);
+    virCommandAddArg(cmd, buf);
+    virCommandAddEnvPassCommon(cmd);
+    int resultcode = virCommandRun(cmd, NULL);
+    if (resultcode < 0)
+        return -1;
+    return 0;
+}
+
+/*
+ * There currently is no reason why it shouldn't be
+ */
+static int
+jailhouseConnectIsAlive(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    return 1;
+}
+
+static int
+jailhouseNodeGetInfo(virConnectPtr conn ATTRIBUTE_UNUSED,
virNodeInfoPtr info)
+{
+    return nodeGetInfo(NULL, info);
+}
+
+/*
+ *  Returns a dummy capabilities XML for virt-manager
+ */
+static char *
+jailhouseConnectGetCapabilities(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    char* caps;
+    if (VIR_STRDUP(caps, "<capabilities></capabilities>") != 1)
+        return NULL;
+    return caps;
+}
+
+/*
+ *  Returns a dummy XML for virt-manager
+ */
+static char *
+jailhouseDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
+{
+    virCheckFlags(0, NULL);
+    char buf[200];
+    char uuid[VIR_UUID_STRING_BUFLEN];
+    virDomainGetUUIDString(domain, uuid);
+    snprintf(buf, 200, "<domain type =\"jailhouse\">\n\
+            <name>%s</name>\n\
+            <uuid>%s</uuid>\n\
+            </domain>", domain->name, uuid);
+    char* result;
+    if (VIR_STRDUP(result, buf) != 1)
+        return NULL;
+    return result;
+}
+
+static virHypervisorDriver jailhouseHypervisorDriver = {
+    .name = "jailhouse",
+    .connectOpen = jailhouseConnectOpen, /* 1.2.22 */
+    .connectClose = jailhouseConnectClose, /* 1.2.22 */
+    .connectGetCapabilities = jailhouseConnectGetCapabilities, /* 1.2.22 */
+    .connectNumOfDomains = jailhouseConnectNumOfDomains, /* 1.2.22 */
+    .connectListDomains = jailhouseConnectListDomains, /* 1.2.22 */
+    .connectIsAlive = jailhouseConnectIsAlive, /* 1.2.22 */
+    .connectListAllDomains = jailhouseConnectListAllDomains, /* 1.2.22 */
+    .domainLookupByID = jailhouseDomainLookupByID, /* 1.2.22 */
+    .domainLookupByName = jailhouseDomainLookupByName, /* 1.2.22 */
+    .domainLookupByUUID = jailhouseDomainLookupByUUID, /* 1.2.22 */
+    .domainGetInfo = jailhouseDomainGetInfo,  /* 1.2.22 */
+    .domainGetState = jailhouseDomainGetState, /* 1.2.22 */
+    .domainGetXMLDesc = jailhouseDomainGetXMLDesc, /* 1.2.22 */
+    .domainShutdown = jailhouseDomainShutdown, /* 1.2.22 */
+    .domainDestroy = jailhouseDomainDestroy, /* 1.2.22 */
+    .domainCreate = jailhouseDomainCreate,    /* 1.2.22 */
+    .nodeGetInfo = jailhouseNodeGetInfo /* 1.2.22 */
+};
+
+static virConnectDriver jailhouseConnectDriver = {
+    .hypervisorDriver = &jailhouseHypervisorDriver,
+};
+
+int
+jailhouseRegister(void)
+{
+    return virRegisterConnectDriver(&jailhouseConnectDriver,
+                                    false);
+}
diff --git a/src/jailhouse/jailhouse_driver.h
b/src/jailhouse/jailhouse_driver.h
new file mode 100644
index 0000000..47c17e7
--- /dev/null
+++ b/src/jailhouse/jailhouse_driver.h
@@ -0,0 +1,28 @@
+/*
+ * jailhouse_driver.h: hypervisor driver for managing Jailhouse cells
+ *
+ * Copyright (C) 2015 Linutronix GmbH
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Author: Christian Loehle
+ */
+
+#ifndef JAILHOUSE_DRIVER_H
+# define JAILHOUSE_DRIVER_H
+
+int jailhouseRegister(void);
+
+#endif
diff --git a/src/libvirt.c b/src/libvirt.c
index 25a0040..7626353 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -98,6 +98,9 @@
 #ifdef WITH_BHYVE
 # include "bhyve/bhyve_driver.h"
 #endif
+#ifdef WITH_JAILHOUSE
+# include "jailhouse/jailhouse_driver.h"
+#endif
 
 #define VIR_FROM_THIS VIR_FROM_NONE
 
@@ -437,12 +440,17 @@ virGlobalInit(void)
     if (vzRegister() == -1)
         goto error;
 # endif
+#ifdef WITH_JAILHOUSE
+    if (jailhouseRegister() == -1)
+    goto error;
+#endif
 #endif
 #ifdef WITH_REMOTE
     if (remoteRegister() == -1)
         goto error;
 #endif
 
+
     return;
 
  error:
@@ -1167,6 +1175,9 @@ do_open(const char *name,
 #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,
                                  __FILE__, __FUNCTION__, __LINE__,
diff --git a/src/util/virerror.c b/src/util/virerror.c
index 6dc05f4..0d480c0 100644
--- a/src/util/virerror.c
+++ b/src/util/virerror.c
@@ -134,6 +134,7 @@ VIR_ENUM_IMPL(virErrorDomain, VIR_ERR_DOMAIN_LAST,
               "Polkit", /* 60 */
               "Thread jobs",
               "Admin Interface",
+              "Jailhouse Driver",
     )
 
 


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