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

[libvirt] [PATCH libguestfs 4/4] launch: Add libvirt backend.



From: "Richard W.M. Jones" <rjones redhat com>

Complete the attach-method libvirt backend.

This backend uses libvirt to create a transient KVM domain to run the
appliance.

Note that this still will only work with local libvirt URIs since the
<kernel>, <initrd> and appliance links in the libvirt XML refer to
local files, and virtio serial only works locally (limitation of
libvirt).  Remote support will be added later.
---
 configure.ac           |    4 +
 po/POTFILES            |    1 +
 src/Makefile.am        |    1 +
 src/guestfs-internal.h |    6 +
 src/launch-libvirt.c   |  868 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/launch.c           |    4 +-
 6 files changed, 882 insertions(+), 2 deletions(-)
 create mode 100644 src/launch-libvirt.c

diff --git a/configure.ac b/configure.ac
index a79a992..e4207c5 100644
--- a/configure.ac
+++ b/configure.ac
@@ -678,6 +678,10 @@ PKG_CHECK_MODULES([LIBXML2], [libxml-2.0],
         [AC_SUBST([LIBXML2_CFLAGS])
          AC_SUBST([LIBXML2_LIBS])
          AC_DEFINE([HAVE_LIBXML2],[1],[libxml2 found at compile time.])
+         old_LIBS="$LIBS"
+         LIBS="$LIBS $LIBREADLINE"
+         AC_CHECK_FUNCS([xmlBufferDetach])
+         LIBS="$old_LIBS"
         ],
         [AC_MSG_WARN([libxml2 not found, some core features will be disabled])])
 AM_CONDITIONAL([HAVE_LIBXML2],[test "x$LIBXML2_LIBS" != "x"])
diff --git a/po/POTFILES b/po/POTFILES
index 60f8d95..ad00cd4 100644
--- a/po/POTFILES
+++ b/po/POTFILES
@@ -209,6 +209,7 @@ src/inspect-fs.c
 src/inspect-icon.c
 src/inspect.c
 src/launch-appliance.c
+src/launch-libvirt.c
 src/launch-unix.c
 src/launch.c
 src/libvirtdomain.c
diff --git a/src/Makefile.am b/src/Makefile.am
index 25daaea..95042f8 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -138,6 +138,7 @@ libguestfs_la_SOURCES = \
 	inspect-icon.c \
 	launch.c \
 	launch-appliance.c \
+	launch-libvirt.c \
 	launch-unix.c \
 	libvirtdomain.c \
 	listfs.c \
diff --git a/src/guestfs-internal.h b/src/guestfs-internal.h
index 8fbe2ec..fe275f0 100644
--- a/src/guestfs-internal.h
+++ b/src/guestfs-internal.h
@@ -167,6 +167,7 @@ struct attach_ops {
   int (*shutdown) (guestfs_h *g); /* Shutdown and cleanup. */
 };
 extern struct attach_ops attach_ops_appliance;
+extern struct attach_ops attach_ops_libvirt;
 extern struct attach_ops attach_ops_unix;
 
 struct guestfs_h
@@ -272,6 +273,11 @@ struct guestfs_h
 
     bool virtio_scsi;     /* See function qemu_supports_virtio_scsi */
   } app;
+
+  struct {                      /* Used only by src/launch-libvirt.c. */
+    void *connv;                /* libvirt connection (really virConnectPtr) */
+    void *domv;                 /* libvirt domain (really virDomainPtr) */
+  } virt;
 };
 
 /* Per-filesystem data stored for inspect_os. */
diff --git a/src/launch-libvirt.c b/src/launch-libvirt.c
new file mode 100644
index 0000000..3b735b5
--- /dev/null
+++ b/src/launch-libvirt.c
@@ -0,0 +1,868 @@
+/* libguestfs
+ * Copyright (C) 2009-2012 Red Hat Inc.
+ *
+ * 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 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* To do (XXX):
+ *
+ * - Need to query libvirt to find out if virtio-scsi is supported.
+ *   This code assumes it.
+ *
+ * - Console, so we can see appliance messages and debugging.
+ *
+ * - Network.
+ *
+ * - Remote support.
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <assert.h>
+
+#ifdef HAVE_LIBVIRT
+#include <libvirt/libvirt.h>
+#include <libvirt/virterror.h>
+#endif
+
+#ifdef HAVE_LIBXML2
+#include <libxml/xmlIO.h>
+#include <libxml/xmlwriter.h>
+#include <libxml/xpath.h>
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/xmlsave.h>
+#endif
+
+#include "glthread/lock.h"
+
+#include "guestfs.h"
+#include "guestfs-internal.h"
+#include "guestfs-internal-actions.h"
+#include "guestfs_protocol.h"
+
+#if defined(HAVE_LIBVIRT) && defined(HAVE_LIBXML2)
+
+#ifndef HAVE_XMLBUFFERDETACH
+/* Added in libxml2 2.8.0.  This is mostly a copy of the function from
+ * upstream libxml2, which is under a more permissive license.
+ */
+static xmlChar *
+xmlBufferDetach (xmlBufferPtr buf)
+{
+  xmlChar *ret;
+
+  if (buf == NULL)
+    return NULL;
+  if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
+    return NULL;
+
+  ret = buf->content;
+  buf->content = NULL;
+  buf->size = 0;
+  buf->use = 0;
+
+  return ret;
+}
+#endif
+
+static xmlChar *construct_libvirt_xml (guestfs_h *g, const char *capabilities_xml, const char *kernel, const char *initrd, const char *appliance, const char *guestfsd_sock);
+
+static void libvirt_error (guestfs_h *g, const char *fs, ...);
+
+static int
+launch_libvirt (guestfs_h *g, const char *libvirt_uri)
+{
+  virConnectPtr conn = NULL;
+  virDomainPtr dom = NULL;
+  char *capabilities = NULL;
+  xmlChar *xml = NULL;
+  char *kernel = NULL, *initrd = NULL, *appliance = NULL;
+  char guestfsd_sock[256];
+  struct sockaddr_un addr;
+  int r;
+
+  /* At present you must add drives before starting the appliance.  In
+   * future when we enable hotplugging you won't need to do this.
+   */
+  if (!g->drives) {
+    error (g, _("you must call guestfs_add_drive before guestfs_launch"));
+    return -1;
+  }
+
+  guestfs___launch_send_progress (g, 0);
+  TRACE0 (launch_libvirt_start);
+
+  if (g->verbose)
+    guestfs___print_timestamped_message (g, "connect to libvirt");
+
+  /* Connect to libvirt, get capabilities. */
+  /* XXX Support libvirt authentication in the future. */
+  conn = virConnectOpen (libvirt_uri);
+  if (!conn) {
+    error (g, _("could not connect to libvirt: URI: %s"),
+           libvirt_uri ? : "NULL");
+    goto cleanup;
+  }
+
+  if (g->verbose)
+    guestfs___print_timestamped_message (g, "get libvirt capabilities");
+
+  capabilities = virConnectGetCapabilities (conn);
+  if (!capabilities) {
+    libvirt_error (g, _("could not get libvirt capabilities"));
+    goto cleanup;
+  }
+
+  /* Locate and/or build the appliance. */
+  TRACE0 (launch_build_libvirt_appliance_start);
+
+  if (g->verbose)
+    guestfs___print_timestamped_message (g, "build appliance");
+
+  if (guestfs___build_appliance (g, &kernel, &initrd, &appliance) == -1)
+    goto cleanup;
+
+  guestfs___launch_send_progress (g, 3);
+  TRACE0 (launch_build_libvirt_appliance_end);
+
+  /* Using virtio-serial, we need to create a local Unix domain socket
+   * for qemu to connect to.
+   */
+  snprintf (guestfsd_sock, sizeof guestfsd_sock, "%s/guestfsd.sock", g->tmpdir);
+  unlink (guestfsd_sock);
+
+  g->sock = socket (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
+  if (g->sock == -1) {
+    perrorf (g, "socket");
+    goto cleanup;
+  }
+
+  if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) {
+    perrorf (g, "fcntl");
+    goto cleanup;
+  }
+
+  addr.sun_family = AF_UNIX;
+  strncpy (addr.sun_path, guestfsd_sock, UNIX_PATH_MAX);
+  addr.sun_path[UNIX_PATH_MAX-1] = '\0';
+
+  if (bind (g->sock, &addr, sizeof addr) == -1) {
+    perrorf (g, "bind");
+    goto cleanup;
+  }
+
+  if (listen (g->sock, 1) == -1) {
+    perrorf (g, "listen");
+    goto cleanup;
+  }
+
+  /* XXX CONSOLE XXX */
+
+  /* Construct the libvirt XML. */
+  if (g->verbose)
+    guestfs___print_timestamped_message (g, "create libvirt XML");
+
+  xml = construct_libvirt_xml (g, capabilities,
+                               kernel, initrd, appliance,
+                               guestfsd_sock);
+  if (!xml)
+    goto cleanup;
+
+  /* Launch the libvirt guest. */
+  if (g->verbose)
+    guestfs___print_timestamped_message (g, "launch libvirt guest");
+
+  dom = virDomainCreateXML (conn, (char *) xml, VIR_DOMAIN_START_AUTODESTROY);
+  if (!dom) {
+    libvirt_error (g, _("could not create appliance through libvirt"));
+    goto cleanup;
+  }
+
+  free (kernel);
+  kernel = NULL;
+  free (initrd);
+  initrd = NULL;
+  free (appliance);
+  appliance = NULL;
+  free (xml);
+  xml = NULL;
+  free (capabilities);
+  capabilities = NULL;
+
+  g->state = LAUNCHING;
+
+  /* Wait for libvirt domain to start and to connect back to us via
+   * virtio-serial and send the GUESTFS_LAUNCH_FLAG message.
+   */
+  r = guestfs___accept_from_daemon (g);
+  if (r == -1)
+    goto cleanup;
+
+  /* NB: We reach here just because qemu has opened the socket.  It
+   * does not mean the daemon is up until we read the
+   * GUESTFS_LAUNCH_FLAG below.  Failures in qemu startup can still
+   * happen even if we reach here, even early failures like not being
+   * able to open a drive.
+   */
+
+  /* Close the listening socket. */
+  if (close (g->sock) != 0) {
+    perrorf (g, "close: listening socket");
+    close (r);
+    g->sock = -1;
+    goto cleanup;
+  }
+  g->sock = r; /* This is the accepted data socket. */
+
+  if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) {
+    perrorf (g, "fcntl");
+    goto cleanup;
+  }
+
+  uint32_t size;
+  void *buf = NULL;
+  r = guestfs___recv_from_daemon (g, &size, &buf);
+  free (buf);
+
+  if (r == -1) {
+    error (g, _("guestfs_launch failed, see earlier error messages"));
+    goto cleanup;
+  }
+
+  if (size != GUESTFS_LAUNCH_FLAG) {
+    error (g, _("guestfs_launch failed, see earlier error messages"));
+    goto cleanup;
+  }
+
+  if (g->verbose)
+    guestfs___print_timestamped_message (g, "appliance is up");
+
+  /* This is possible in some really strange situations, such as
+   * guestfsd starts up OK but then qemu immediately exits.  Check for
+   * it because the caller is probably expecting to be able to send
+   * commands after this function returns.
+   */
+  if (g->state != READY) {
+    error (g, _("qemu launched and contacted daemon, but state != READY"));
+    goto cleanup;
+  }
+
+  TRACE0 (launch_libvirt_end);
+
+  guestfs___launch_send_progress (g, 12);
+
+  g->virt.connv = conn;
+  g->virt.domv = dom;
+
+  return 0;
+
+ cleanup:
+  if (g->sock >= 0) {
+    close (g->sock);
+    g->sock = -1;
+  }
+  g->state = CONFIG;
+  free (kernel);
+  free (initrd);
+  free (appliance);
+  free (capabilities);
+  free (xml);
+  if (dom) {
+    virDomainDestroy (dom);
+    virDomainFree (dom);
+  }
+  if (conn)
+    virConnectClose (conn);
+
+  return -1;
+}
+
+static int construct_libvirt_xml_name (guestfs_h *g, xmlTextWriterPtr xo);
+static int construct_libvirt_xml_cpu (guestfs_h *g, xmlTextWriterPtr xo);
+static int construct_libvirt_xml_boot (guestfs_h *g, xmlTextWriterPtr xo, const char *kernel, const char *initrd, size_t appliance_index);
+static int construct_libvirt_xml_devices (guestfs_h *g, xmlTextWriterPtr xo, const char *appliance, const char *guestfsd_sock, size_t appliance_index);
+static int construct_libvirt_xml_qemu_cmdline (guestfs_h *g, xmlTextWriterPtr xo, size_t appliance_index);
+static int construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo, struct drive *drv, size_t drv_index);
+static int construct_libvirt_xml_appliance (guestfs_h *g, xmlTextWriterPtr xo, const char *appliance, size_t appliance_index);
+
+#define XMLERROR(code,e) do {                                           \
+    if ((e) == (code)) {                                                \
+      perrorf (g, _("error constructing libvirt XML at \"%s\""),        \
+               #e);                                                     \
+      goto err;                                                         \
+    }                                                                   \
+  } while (0)
+
+static xmlChar *
+construct_libvirt_xml (guestfs_h *g, const char *capabilities_xml,
+                       const char *kernel, const char *initrd,
+                       const char *appliance,
+                       const char *guestfsd_sock)
+{
+  xmlChar *ret = NULL;
+  xmlBufferPtr xb = NULL;
+  xmlOutputBufferPtr ob;
+  xmlTextWriterPtr xo = NULL;
+  struct drive *drv = g->drives;
+  size_t appliance_index = 0;
+
+  /* Count the number of disks added, in order to get the offset
+   * of the appliance disk.
+   */
+  while (drv != NULL) {
+    drv = drv->next;
+    appliance_index++;
+  }
+
+  XMLERROR (NULL, xb = xmlBufferCreate ());
+  XMLERROR (NULL, ob = xmlOutputBufferCreateBuffer (xb, NULL));
+  XMLERROR (NULL, xo = xmlNewTextWriter (ob));
+
+  XMLERROR (-1, xmlTextWriterSetIndent (xo, 1));
+  XMLERROR (-1, xmlTextWriterSetIndentString (xo, BAD_CAST "  "));
+  XMLERROR (-1, xmlTextWriterStartDocument (xo, NULL, NULL, NULL));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "domain"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "type", BAD_CAST "kvm"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttributeNS (xo,
+                                           BAD_CAST "xmlns",
+                                           BAD_CAST "qemu",
+                                           NULL,
+                                           BAD_CAST "http://libvirt.org/schemas/domain/qemu/1.0";));
+
+  if (construct_libvirt_xml_name (g, xo) == -1)
+    goto err;
+  if (construct_libvirt_xml_cpu (g, xo) == -1)
+    goto err;
+  if (construct_libvirt_xml_boot (g, xo, kernel, initrd, appliance_index) == -1)
+    goto err;
+  if (construct_libvirt_xml_devices (g, xo, appliance, guestfsd_sock,
+                                     appliance_index) == -1)
+    goto err;
+  if (construct_libvirt_xml_qemu_cmdline (g, xo, appliance_index) == -1)
+    goto err;
+
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterEndDocument (xo));
+  XMLERROR (NULL, ret = xmlBufferDetach (xb)); /* caller frees ret */
+
+  debug (g, "libvirt XML:\n%s", ret);
+
+ err:
+  if (xo)
+    xmlFreeTextWriter (xo); /* frees 'ob' too */
+  if (xb)
+    xmlBufferFree (xb);
+
+  return ret;
+}
+
+/* Construct a securely random name.  We don't need to save the name
+ * because if we ever needed it, it's available from libvirt.
+ */
+#define DOMAIN_NAME_LEN 16
+
+static int
+construct_libvirt_xml_name (guestfs_h *g, xmlTextWriterPtr xo)
+{
+  int fd;
+  char name[DOMAIN_NAME_LEN+1];
+  size_t i;
+  unsigned char c;
+
+  fd = open ("/dev/urandom", O_RDONLY|O_CLOEXEC);
+  if (fd == -1) {
+    perrorf (g, "/dev/urandom: open");
+    return -1;
+  }
+
+  for (i = 0; i < DOMAIN_NAME_LEN; ++i) {
+    if (read (fd, &c, 1) != 1) {
+      perrorf (g, "/dev/urandom: read");
+      close (fd);
+      return -1;
+    }
+    name[i] = "0123456789abcdefghijklmnopqrstuvwxyz"[c % 36];
+  }
+  name[DOMAIN_NAME_LEN] = '\0';
+
+  close (fd);
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "name"));
+  XMLERROR (-1, xmlTextWriterWriteString (xo, BAD_CAST name));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  return 0;
+
+ err:
+  return -1;
+}
+
+/* CPU and memory features. */
+static int
+construct_libvirt_xml_cpu (guestfs_h *g, xmlTextWriterPtr xo)
+{
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "memory"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "unit", BAD_CAST "MiB"));
+  XMLERROR (-1, xmlTextWriterWriteFormatString (xo, "%d", g->memsize));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "currentMemory"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "unit", BAD_CAST "MiB"));
+  XMLERROR (-1, xmlTextWriterWriteFormatString (xo, "%d", g->memsize));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "vcpu"));
+  XMLERROR (-1, xmlTextWriterWriteFormatString (xo, "%d", g->smp));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "clock"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "offset",
+                                         BAD_CAST "utc"));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  return 0;
+
+ err:
+  return -1;
+}
+
+/* Boot parameters. */
+static int
+construct_libvirt_xml_boot (guestfs_h *g, xmlTextWriterPtr xo,
+                            const char *kernel, const char *initrd,
+                            size_t appliance_index)
+{
+  char buf[256];
+  char appliance_root[64] = "";
+
+  /* XXX Lots of common code shared with src/launch-appliance.c */
+#if defined(__arm__)
+#define SERIAL_CONSOLE "ttyAMA0"
+#else
+#define SERIAL_CONSOLE "ttyS0"
+#endif
+
+#define LINUX_CMDLINE							\
+    "panic=1 "         /* force kernel to panic if daemon exits */	\
+    "console=" SERIAL_CONSOLE " " /* serial console */		        \
+    "udevtimeout=600 " /* good for very slow systems (RHBZ#480319) */	\
+    "no_timer_check "  /* fix for RHBZ#502058 */                        \
+    "acpi=off "        /* we don't need ACPI, turn it off */		\
+    "printk.time=1 "   /* display timestamp before kernel messages */   \
+    "cgroup_disable=memory " /* saves us about 5 MB of RAM */
+
+  /* Linux kernel command line. */
+  guestfs___drive_name (appliance_index, appliance_root);
+
+  snprintf (buf, sizeof buf,
+            LINUX_CMDLINE
+            "root=/dev/sd%s "   /* (root) */
+            "%s "               /* (selinux) */
+            "%s "               /* (verbose) */
+            "TERM=%s "          /* (TERM environment variable) */
+            "%s",               /* (append) */
+            appliance_root,
+            g->selinux ? "selinux=1 enforcing=0" : "selinux=0",
+            g->verbose ? "guestfs_verbose=1" : "",
+            getenv ("TERM") ? : "linux",
+            g->append ? g->append : "");
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "os"));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "type"));
+  XMLERROR (-1, xmlTextWriterWriteString (xo, BAD_CAST "hvm"));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "kernel"));
+  XMLERROR (-1, xmlTextWriterWriteString (xo, BAD_CAST kernel));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "initrd"));
+  XMLERROR (-1, xmlTextWriterWriteString (xo, BAD_CAST initrd));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "cmdline"));
+  XMLERROR (-1, xmlTextWriterWriteString (xo, BAD_CAST buf));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  return 0;
+
+ err:
+  return -1;
+}
+
+/* Devices. */
+static int
+construct_libvirt_xml_devices (guestfs_h *g, xmlTextWriterPtr xo,
+                               const char *appliance, const char *guestfsd_sock,
+                               size_t appliance_index)
+{
+  struct drive *drv = g->drives;
+  size_t drv_index = 0;
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "devices"));
+
+  /* virtio-scsi controller. */
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "controller"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "type",
+                                         BAD_CAST "scsi"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "index",
+                                         BAD_CAST "0"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "model",
+                                         BAD_CAST "virtio-scsi"));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  /* Disks. */
+  while (drv != NULL) {
+    if (construct_libvirt_xml_disk (g, xo, drv, drv_index) == -1)
+      goto err;
+    drv = drv->next;
+    drv_index++;
+  }
+
+  /* Appliance disk. */
+  if (construct_libvirt_xml_appliance (g, xo, appliance, appliance_index) == -1)
+    goto err;
+
+  /* virtio-serial */
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "channel"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "type",
+                                         BAD_CAST "unix"));
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "source"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "mode",
+                                         BAD_CAST "bind"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "path",
+                                         BAD_CAST guestfsd_sock));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "target"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "type",
+                                         BAD_CAST "virtio"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "name",
+                                         BAD_CAST "org.libguestfs.channel.0"));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  return 0;
+
+ err:
+  return -1;
+}
+
+static int
+construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo,
+                            struct drive *drv, size_t drv_index)
+{
+  char drive_name[64] = "sd";
+  char scsi_target[64];
+  char *path = NULL;
+
+  guestfs___drive_name (drv_index, &drive_name[2]);
+  snprintf (scsi_target, sizeof scsi_target, "%zu", drv_index);
+
+  /* Drive path must be absolute for libvirt. */
+  path = realpath (drv->path, NULL);
+  if (path == NULL) {
+    perrorf (g, "realpath: could not convert '%s' to absolute path", drv->path);
+    goto err;
+  }
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "disk"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "type",
+                                         BAD_CAST "file"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "device",
+                                         BAD_CAST "disk"));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "source"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "file",
+                                         BAD_CAST path));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "target"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "dev",
+                                         BAD_CAST drive_name));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "bus",
+                                         BAD_CAST "scsi"));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "driver"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "name",
+                                         BAD_CAST "qemu"));
+  if (drv->format) {
+    XMLERROR (-1,
+              xmlTextWriterWriteAttribute (xo, BAD_CAST "format",
+                                           BAD_CAST drv->format));
+  }
+  if (drv->use_cache_none) {
+    XMLERROR (-1,
+              xmlTextWriterWriteAttribute (xo, BAD_CAST "cache",
+                                           BAD_CAST "none"));
+  }
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "address"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "type",
+                                         BAD_CAST "drive"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "controller",
+                                         BAD_CAST "0"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "bus",
+                                         BAD_CAST "0"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "target",
+                                         BAD_CAST scsi_target));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "unit",
+                                         BAD_CAST "0"));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  if (drv->readonly) {
+    XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "readonly"));
+    XMLERROR (-1, xmlTextWriterEndElement (xo));
+  }
+
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  free (path);
+  return 0;
+
+ err:
+  free (path);
+  return -1;
+}
+
+static int
+construct_libvirt_xml_appliance (guestfs_h *g, xmlTextWriterPtr xo,
+                                 const char *appliance, size_t drv_index)
+{
+  char drive_name[64] = "sd";
+  char scsi_target[64];
+
+  guestfs___drive_name (drv_index, &drive_name[2]);
+  snprintf (scsi_target, sizeof scsi_target, "%zu", drv_index);
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "disk"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "type",
+                                         BAD_CAST "file"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "device",
+                                         BAD_CAST "disk"));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "source"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "file",
+                                         BAD_CAST appliance));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "target"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "dev",
+                                         BAD_CAST drive_name));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "bus",
+                                         BAD_CAST "scsi"));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "driver"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "name",
+                                         BAD_CAST "qemu"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "format",
+                                         BAD_CAST "raw"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "cache",
+                                         BAD_CAST "unsafe"));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "address"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "type",
+                                         BAD_CAST "drive"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "controller",
+                                         BAD_CAST "0"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "bus",
+                                         BAD_CAST "0"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "target",
+                                         BAD_CAST scsi_target));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "unit",
+                                         BAD_CAST "0"));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  /* We'd like to do this, but it's not supported by libvirt.
+   * See construct_libvirt_xml_qemu_cmdline for the workaround.
+   *
+   * XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "transient"));
+   * XMLERROR (-1, xmlTextWriterEndElement (xo));
+   */
+
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  return 0;
+
+ err:
+  return -1;
+}
+
+/* Workaround because libvirt can't do snapshot=on yet.  Idea inspired
+ * by Stefan Hajnoczi's post here:
+ * http://blog.vmsplice.net/2011/04/how-to-pass-qemu-command-line-options.html
+ */
+static int
+construct_libvirt_xml_qemu_cmdline (guestfs_h *g, xmlTextWriterPtr xo,
+                                    size_t appliance_index)
+{
+  char attr[256];
+
+  snprintf (attr, sizeof attr,
+            "drive.drive-scsi0-0-%zu-0.snapshot=on", appliance_index);
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "qemu:commandline"));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "qemu:arg"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "value",
+                                         BAD_CAST "-set"));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "qemu:arg"));
+  XMLERROR (-1,
+            xmlTextWriterWriteAttribute (xo, BAD_CAST "value",
+                                         BAD_CAST attr));
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  XMLERROR (-1, xmlTextWriterEndElement (xo));
+
+  return 0;
+
+ err:
+  return -1;
+}
+
+static int
+shutdown_libvirt (guestfs_h *g)
+{
+  virConnectPtr conn = g->virt.connv;
+  virDomainPtr dom = g->virt.domv;
+  int ret = 0;
+
+  assert (conn != NULL);
+  assert (dom != NULL);
+
+  /* XXX Need to be graceful? */
+  if (virDomainDestroyFlags (dom, 0) == -1) {
+    libvirt_error (g, _("could not destroy libvirt domain"));
+    ret = -1;
+  }
+  virDomainFree (dom);
+  virConnectClose (conn);
+
+  g->virt.connv = g->virt.domv = NULL;
+
+  return ret;
+}
+
+/* Wrapper around error() which produces better errors for
+ * libvirt functions.
+ */
+static void
+libvirt_error (guestfs_h *g, const char *fs, ...)
+{
+  va_list args;
+  char *msg;
+  int len;
+  virErrorPtr err;
+
+  va_start (args, fs);
+  len = vasprintf (&msg, fs, args);
+  va_end (args);
+
+  if (len < 0)
+    msg = safe_asprintf (g,
+                         _("%s: internal error forming error message"),
+                         __func__);
+
+  /* In all recent libvirt, this retrieves the thread-local error. */
+  err = virGetLastError ();
+
+  error (g, "%s: %s [code=%d domain=%d]",
+         msg, err->message, err->code, err->domain);
+
+  /* NB. 'err' must not be freed! */
+  free (msg);
+}
+
+#else /* no libvirt or libxml2 at compile time */
+
+#define NOT_IMPL(r)                                                     \
+  error (g, _("libvirt attach-method is not available since this version of libguestfs was compiled without libvirt or libxml2")); \
+  return r
+
+static int
+launch_libvirt (guestfs_h *g, const char *arg)
+{
+  NOT_IMPL (-1);
+}
+
+static int
+shutdown_libvirt (guestfs_h *g)
+{
+  NOT_IMPL (-1);
+}
+
+#endif /* no libvirt or libxml2 at compile time */
+
+struct attach_ops attach_ops_libvirt = {
+  .launch = launch_libvirt,
+  .shutdown = shutdown_libvirt,
+};
diff --git a/src/launch.c b/src/launch.c
index 7c403ab..02441db 100644
--- a/src/launch.c
+++ b/src/launch.c
@@ -326,8 +326,8 @@ guestfs__launch (guestfs_h *g)
     break;
 
   case ATTACH_METHOD_LIBVIRT:
-    error (g, _("libvirt attach method is not yet supported"));
-    return -1;
+    g->attach_ops = &attach_ops_libvirt;
+    break;
 
   case ATTACH_METHOD_UNIX:
     g->attach_ops = &attach_ops_unix;
-- 
1.7.10.4


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