From: "Richard W.M. Jones" <rjones(a)redhat.com&gt; Instead of adding the snapshot=on option via <qemu:arg>, create qcow2 overlays for any read-only drives and the appliance using 'qemu-img create' + a temporary file. This is a workaround for missing support for <transient/> in libvirt's qemu driver. Also for the unpredictable way that libvirtd handles $TMPDIR: we want to control where the temporary disk is created. Currently it is also much slower, because qemu-img is slow. However we hope to fix qemu upstream. --- src/launch-libvirt.c | 298 +++++++++++++++++++++++++++++++++++++------------- 1 file changed, 219 insertions(+), 79 deletions(-) diff --git a/src/launch-libvirt.c b/src/launch-libvirt.c index 7ae37e3..d33693e 100644 --- a/src/launch-libvirt.c +++ b/src/launch-libvirt.c @@ -28,6 +28,7 @@ #include <sys/types.h> #include <sys/stat.h> #include <sys/wait.h> +#include <assert.h> #ifdef HAVE_LIBVIRT #include <libvirt/libvirt.h> @@ -92,12 +93,26 @@ xmlBufferDetach (xmlBufferPtr buf) } #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, const char *console_sock, int disable_svirt); +/* Pointed to by 'struct drive *' -> priv field. */ +struct drive_libvirt { + /* This is either the original path, made absolute. Or for readonly + * drives, it is an (absolute path to) the overlay file that we + * create. This is always non-NULL. + */ + char *path; + /* The format of priv->path. */ + char *format; +}; + +static xmlChar *construct_libvirt_xml (guestfs_h *g, const char *capabilities_xml, const char *kernel, const char *initrd, const char *appliance_overlay, const char *guestfsd_sock, const char *console_sock, int disable_svirt); static void libvirt_error (guestfs_h *g, const char *fs, ...); static int is_custom_qemu (guestfs_h *g); static int is_blk (const char *path); static int random_chars (char *ret, size_t len); static void ignore_errors (void *ignore, virErrorPtr ignore2); +static char *make_qcow2_overlay (guestfs_h *g, const char *path, const char *format); +static int make_qcow2_overlay_for_drive (guestfs_h *g, struct drive *drv); +static void drive_free_priv (void *); static int launch_libvirt (guestfs_h *g, const char *libvirt_uri) @@ -109,6 +124,7 @@ launch_libvirt (guestfs_h *g, const char *libvirt_uri) char *capabilities = NULL; xmlChar *xml = NULL; char *kernel = NULL, *initrd = NULL, *appliance = NULL; + char *appliance_overlay = NULL; char guestfsd_sock[256]; char console_sock[256]; struct sockaddr_un addr; @@ -116,6 +132,8 @@ launch_libvirt (guestfs_h *g, const char *libvirt_uri) uint32_t size; void *buf = NULL; int disable_svirt = is_custom_qemu (g); + struct drive *drv; + size_t i; /* At present you must add drives before starting the appliance. In * future when we enable hotplugging you won't need to do this. @@ -182,6 +200,20 @@ launch_libvirt (guestfs_h *g, const char *libvirt_uri) guestfs___launch_send_progress (g, 3); TRACE0 (launch_build_libvirt_appliance_end); + /* Create overlays for read-only drives and the appliance. This + * works around lack of support for <transient/> disks in libvirt. + */ + appliance_overlay = make_qcow2_overlay (g, appliance, "raw"); + if (!appliance_overlay) + goto cleanup; + + ITER_DRIVES (g, i, drv) { + if (make_qcow2_overlay_for_drive (g, drv) == -1) + goto cleanup; + } + + TRACE0 (launch_build_libvirt_qcow2_overlay_end); + /* Using virtio-serial, we need to create a local Unix domain socket * for qemu to connect to. */ @@ -278,7 +310,7 @@ launch_libvirt (guestfs_h *g, const char *libvirt_uri) guestfs___print_timestamped_message (g, "create libvirt XML"); xml = construct_libvirt_xml (g, capabilities, - kernel, initrd, appliance, + kernel, initrd, appliance_overlay, guestfsd_sock, console_sock, disable_svirt); if (!xml) @@ -381,6 +413,7 @@ launch_libvirt (guestfs_h *g, const char *libvirt_uri) free (kernel); free (initrd); free (appliance); + free (appliance_overlay); free (xml); free (capabilities); @@ -412,6 +445,7 @@ launch_libvirt (guestfs_h *g, const char *libvirt_uri) free (kernel); free (initrd); free (appliance); + free (appliance_overlay); free (capabilities); free (xml); @@ -431,10 +465,10 @@ 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_seclabel (guestfs_h *g, xmlTextWriterPtr xo); static int construct_libvirt_xml_lifecycle (guestfs_h *g, xmlTextWriterPtr xo); -static int construct_libvirt_xml_devices (guestfs_h *g, xmlTextWriterPtr xo, const char *appliance, size_t appliance_index, const char *guestfsd_sock, const char *console_sock); +static int construct_libvirt_xml_devices (guestfs_h *g, xmlTextWriterPtr xo, const char *appliance_overlay, size_t appliance_index, const char *guestfsd_sock, const char *console_sock); static int construct_libvirt_xml_qemu_cmdline (guestfs_h *g, xmlTextWriterPtr xo); 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); +static int construct_libvirt_xml_appliance (guestfs_h *g, xmlTextWriterPtr xo, const char *appliance_overlay, size_t appliance_index); #define XMLERROR(code,e) do { \ if ((e) == (code)) { \ @@ -447,7 +481,7 @@ static int construct_libvirt_xml_appliance (guestfs_h *g, xmlTextWriterPtr xo, c static xmlChar * construct_libvirt_xml (guestfs_h *g, const char *capabilities_xml, const char *kernel, const char *initrd, - const char *appliance, + const char *appliance_overlay, const char *guestfsd_sock, const char *console_sock, int disable_svirt) { @@ -490,7 +524,7 @@ construct_libvirt_xml (guestfs_h *g, const char *capabilities_xml, goto err; if (construct_libvirt_xml_lifecycle (g, xo) == -1) goto err; - if (construct_libvirt_xml_devices (g, xo, appliance, appliance_index, + if (construct_libvirt_xml_devices (g, xo, appliance_overlay, appliance_index, guestfsd_sock, console_sock) == -1) goto err; if (construct_libvirt_xml_qemu_cmdline (g, xo) == -1) @@ -675,7 +709,8 @@ construct_libvirt_xml_lifecycle (guestfs_h *g, xmlTextWriterPtr xo) /* Devices. */ static int construct_libvirt_xml_devices (guestfs_h *g, xmlTextWriterPtr xo, - const char *appliance, size_t appliance_index, + const char *appliance_overlay, + size_t appliance_index, const char *guestfsd_sock, const char *console_sock) { @@ -713,7 +748,8 @@ construct_libvirt_xml_devices (guestfs_h *g, xmlTextWriterPtr xo, } /* Appliance disk. */ - if (construct_libvirt_xml_appliance (g, xo, appliance, appliance_index) == -1) + if (construct_libvirt_xml_appliance (g, xo, appliance_overlay, + appliance_index) == -1) goto err; /* Console. */ @@ -773,7 +809,7 @@ construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo, { char drive_name[64] = "sd"; char scsi_target[64]; - char *path = NULL; + struct drive_libvirt *drv_priv; char *format = NULL; int is_host_device; @@ -786,6 +822,8 @@ construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo, guestfs___drive_name (drv_index, &drive_name[2]); snprintf (scsi_target, sizeof scsi_target, "%zu", drv_index); + drv_priv = (struct drive_libvirt *) drv->priv; + /* Change the libvirt XML according to whether the host path is * a device or a file. For devices, use: * <disk type=block device=disk> @@ -794,15 +832,7 @@ construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo, * <disk type=file device=disk> * <source file=[path]> */ - is_host_device = is_blk (drv->path); - - /* 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; - } + is_host_device = is_blk (drv_priv->path); XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "disk")); XMLERROR (-1, @@ -815,7 +845,8 @@ construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo, XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "source")); XMLERROR (-1, - xmlTextWriterWriteAttribute (xo, BAD_CAST "file", BAD_CAST path)); + xmlTextWriterWriteAttribute (xo, BAD_CAST "file", + BAD_CAST drv_priv->path)); XMLERROR (-1, xmlTextWriterEndElement (xo)); } else { @@ -825,7 +856,8 @@ construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo, XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "source")); XMLERROR (-1, - xmlTextWriterWriteAttribute (xo, BAD_CAST "dev", BAD_CAST path)); + xmlTextWriterWriteAttribute (xo, BAD_CAST "dev", + BAD_CAST drv_priv->path)); XMLERROR (-1, xmlTextWriterEndElement (xo)); } @@ -842,10 +874,10 @@ construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo, XMLERROR (-1, xmlTextWriterWriteAttribute (xo, BAD_CAST "name", BAD_CAST "qemu")); - if (drv->format) { + if (drv_priv->format) { XMLERROR (-1, xmlTextWriterWriteAttribute (xo, BAD_CAST "type", - BAD_CAST drv->format)); + BAD_CAST drv_priv->format)); } else { /* libvirt has disabled the feature of detecting the disk format, @@ -858,7 +890,7 @@ construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo, * the users pass the format to libguestfs which will faithfully pass * that to libvirt and this function won't be used. */ - format = guestfs_disk_format (g, path); + format = guestfs_disk_format (g, drv_priv->path); if (!format) goto err; @@ -866,7 +898,7 @@ construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo, error (g, _("could not auto-detect the format of '%s'\n" "If the format is known, pass the format to libguestfs, eg. using the\n" "'--format' option, or via the optional 'format' argument to 'add-drive'."), - path); + drv->path); goto err; } @@ -899,30 +931,20 @@ construct_libvirt_xml_disk (guestfs_h *g, xmlTextWriterPtr xo, 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. - * - * if (drv->readonly) { - * XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "transient")); - * XMLERROR (-1, xmlTextWriterEndElement (xo)); - * } - */ - XMLERROR (-1, xmlTextWriterEndElement (xo)); - free (path); free (format); return 0; err: - free (path); free (format); return -1; } static int construct_libvirt_xml_appliance (guestfs_h *g, xmlTextWriterPtr xo, - const char *appliance, size_t drv_index) + const char *appliance_overlay, + size_t drv_index) { char drive_name[64] = "sd"; char scsi_target[64]; @@ -941,7 +963,7 @@ construct_libvirt_xml_appliance (guestfs_h *g, xmlTextWriterPtr xo, XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "source")); XMLERROR (-1, xmlTextWriterWriteAttribute (xo, BAD_CAST "file", - BAD_CAST appliance)); + BAD_CAST appliance_overlay)); XMLERROR (-1, xmlTextWriterEndElement (xo)); XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "target")); @@ -959,7 +981,7 @@ construct_libvirt_xml_appliance (guestfs_h *g, xmlTextWriterPtr xo, BAD_CAST "qemu")); XMLERROR (-1, xmlTextWriterWriteAttribute (xo, BAD_CAST "type", - BAD_CAST "raw")); + BAD_CAST "qcow2")); XMLERROR (-1, xmlTextWriterWriteAttribute (xo, BAD_CAST "cache", BAD_CAST "unsafe")); @@ -1004,52 +1026,11 @@ construct_libvirt_xml_appliance (guestfs_h *g, xmlTextWriterPtr xo, static int construct_libvirt_xml_qemu_cmdline (guestfs_h *g, xmlTextWriterPtr xo) { - struct drive *drv; - size_t i; - char attr[256]; struct qemu_param *qp; char *p; XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "qemu:commandline")); - /* 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 - */ - ITER_DRIVES (g, i, drv) { - if (drv->readonly) { - snprintf (attr, sizeof attr, - "drive.drive-scsi0-0-%zu-0.snapshot=on", i); - - 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)); - } - } - - snprintf (attr, sizeof attr, - "drive.drive-scsi0-0-%zu-0.snapshot=on", g->nr_drives); - - 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)); - /* We need to ensure the snapshots are created in $TMPDIR (RHBZ#856619). */ p = getenv ("TMPDIR"); if (p) { @@ -1162,6 +1143,165 @@ ignore_errors (void *ignore, virErrorPtr ignore2) /* empty */ } +/* Create a temporary qcow2 overlay on top of 'path'. */ +static char * +make_qcow2_overlay (guestfs_h *g, const char *path, const char *format) +{ + char *tmpfile = NULL; + int fd[2] = { -1, -1 }; + pid_t pid = -1; + FILE *fp = NULL; + char *line = NULL; + size_t len; + int r; + + /* Path must be absolute. */ + assert (path); + assert (path[0] == '/'); + + tmpfile = safe_asprintf (g, "%s/snapshot%d", g->tmpdir, ++g->unique); + + /* Because 'qemu-img create' spews junk to stdout and stderr, pass + * all output from it up through the event system. + * XXX Like libvirt, we should create a generic library for running + * commands. + */ + if (pipe2 (fd, O_CLOEXEC) == -1) { + perrorf (g, "pipe2"); + goto error; + } + + pid = fork (); + if (pid == -1) { + perrorf (g, "fork"); + goto error; + } + + if (pid == 0) { /* child: qemu-img create command */ + /* Capture stdout and stderr. */ + close (fd[0]); + dup2 (fd[1], 1); + dup2 (fd[1], 2); + close (fd[1]); + + setenv ("LC_ALL", "C", 1); + + if (!format) + execlp ("qemu-img", "qemu-img", "create", "-f", "qcow2", + "-b", path, tmpfile, NULL); + else { + size_t len = strlen (format); + char backing_fmt[len+64]; + + snprintf (backing_fmt, len+64, "backing_fmt=%s", format); + + execlp ("qemu-img", "qemu-img", "create", "-f", "qcow2", + "-b", path, "-o", backing_fmt, tmpfile, NULL); + } + + perror ("could not execute 'qemu-img create' command"); + _exit (EXIT_FAILURE); + } + + close (fd[1]); + fd[1] = -1; + + fp = fdopen (fd[0], "r"); + if (fp == NULL) { + perrorf (g, "fdopen: qemu-img create"); + goto error; + } + fd[0] = -1; + + while (getline (&line, &len, fp) != -1) { + guestfs___call_callbacks_message (g, GUESTFS_EVENT_LIBRARY, line, len); + } + + if (fclose (fp) == -1) { /* also closes fd[0] */ + perrorf (g, "fclose"); + fp = NULL; + goto error; + } + fp = NULL; + + free (line); + line = NULL; + + if (waitpid (pid, &r, 0) == -1) { + perrorf (g, "waitpid"); + pid = 0; + goto error; + } + pid = 0; + + if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) { + error (g, _("qemu-img create: could not create snapshot over %s"), path); + goto error; + } + + return tmpfile; /* caller frees */ + + error: + if (fd[0] >= 0) + close (fd[0]); + if (fd[1] >= 0) + close (fd[1]); + if (fp != NULL) + fclose (fp); + if (pid > 0) + waitpid (pid, NULL, 0); + + free (tmpfile); + free (line); + + return NULL; +} + +static int +make_qcow2_overlay_for_drive (guestfs_h *g, struct drive *drv) +{ + char *path; + struct drive_libvirt *drv_priv; + + if (drv->priv && drv->free_priv) + drv->free_priv (drv->priv); + + drv->priv = drv_priv = safe_calloc (g, 1, sizeof (struct drive_libvirt)); + drv->free_priv = drive_free_priv; + + /* Even for non-readonly paths, we need to make the paths absolute here. */ + path = realpath (drv->path, NULL); + if (path == NULL) { + perrorf (g, _("realpath: could not convert '%s' to absolute path"), + drv->path); + return -1; + } + + if (!drv->readonly) { + drv_priv->path = path; + drv_priv->format = drv->format ? safe_strdup (g, drv->format) : NULL; + } + else { + drv_priv->path = make_qcow2_overlay (g, path, drv->format); + free (path); + if (!drv_priv->path) + return -1; + drv_priv->format = safe_strdup (g, "qcow2"); + } + + return 0; +} + +static void +drive_free_priv (void *priv) +{ + struct drive_libvirt *drv_priv = priv; + + free (drv_priv->path); + free (drv_priv->format); + free (drv_priv); +} + static int shutdown_libvirt (guestfs_h *g, int check_for_errors) { -- 1.7.10.4

From: "Richard W.M. Jones" <rjones(a)redhat.com&gt; When libvirt is used, we can allow disks to be hotplugged. guestfs_add_drive can be called after launch to hot-add a disk. When a disk is hot-added, we first ask libvirt to add the disk to the appliance, then we make an internal call into the appliance to get it to wait for the disk to appear (ie. udev_settle ()). Hot-added disks are tracked in the g->drives array. This also adds a test. --- Makefile.am | 1 + configure.ac | 1 + daemon/Makefile.am | 1 + daemon/hotplug.c | 67 ++++++++++++++++++++++++++++ fish/alloc.c | 5 --- generator/actions.ml | 24 ++++++++-- po/POTFILES | 1 + src/MAX_PROC_NR | 2 +- src/guestfs-internal.h | 3 ++ src/guestfs.pod | 38 ++++++++++++++-- src/launch-libvirt.c | 99 +++++++++++++++++++++++++++++++++++++---- src/launch.c | 80 ++++++++++++++++++++++++++++++--- tests/hotplug/Makefile.am | 26 +++++++++++ tests/hotplug/test-hot-add.pl | 66 +++++++++++++++++++++++++++ 14 files changed, 386 insertions(+), 28 deletions(-) create mode 100644 daemon/hotplug.c create mode 100644 tests/hotplug/Makefile.am create mode 100755 tests/hotplug/test-hot-add.pl diff --git a/Makefile.am b/Makefile.am index 4e476ea..50bfb32 100644 --- a/Makefile.am +++ b/Makefile.am @@ -52,6 +52,7 @@ SUBDIRS += tests/9p SUBDIRS += tests/rsync SUBDIRS += tests/bigdirs SUBDIRS += tests/disk-labels +SUBDIRS += tests/hotplug SUBDIRS += tests/regressions endif diff --git a/configure.ac b/configure.ac index 0422bcb..b4720bc 100644 --- a/configure.ac +++ b/configure.ac @@ -1379,6 +1379,7 @@ AC_CONFIG_FILES([Makefile tests/disk-labels/Makefile tests/extra/Makefile tests/guests/Makefile + tests/hotplug/Makefile tests/luks/Makefile tests/lvm/Makefile tests/md/Makefile diff --git a/daemon/Makefile.am b/daemon/Makefile.am index 2a25c69..9ffff15 100644 --- a/daemon/Makefile.am +++ b/daemon/Makefile.am @@ -125,6 +125,7 @@ guestfsd_SOURCES = \ guestfsd.c \ headtail.c \ hexdump.c \ + hotplug.c \ hivex.c \ htonl.c \ initrd.c \ diff --git a/daemon/hotplug.c b/daemon/hotplug.c new file mode 100644 index 0000000..aae638e --- /dev/null +++ b/daemon/hotplug.c @@ -0,0 +1,67 @@ +/* libguestfs - the guestfsd daemon + * Copyright (C) 2012 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <errno.h> +#include <time.h> + +#include "guestfs_protocol.h" +#include "daemon.h" +#include "actions.h" + +#define HOT_ADD_TIMEOUT 30 /* seconds */ + +/* Wait for /dev/disk/guestfs/<label> to appear. Timeout (and error) + * if it doesn't appear after a reasonable length of time. + */ +int +do_internal_hot_add_drive (const char *label) +{ + time_t start_t, now_t; + size_t len = strlen (label); + char path[len+64]; + int r; + + snprintf (path, len+64, "/dev/disk/guestfs/%s", label); + + time (&start_t); + + while (time (&now_t) - start_t <= HOT_ADD_TIMEOUT) { + udev_settle (); + + r = access (path, F_OK); + if (r == -1 && errno != ENOENT) { + reply_with_perror ("%s", path); + return -1; + } + if (r == 0) + return 0; + + sleep (1); + } + + reply_with_error ("hot-add drive: '%s' did not appear after %d seconds: " + "this could mean that virtio-scsi (in qemu or kernel) " + "or udev is not working", + path, HOT_ADD_TIMEOUT); + return -1; +} diff --git a/fish/alloc.c b/fish/alloc.c index f6e5b8f..7454fb7 100644 --- a/fish/alloc.c +++ b/fish/alloc.c @@ -72,11 +72,6 @@ alloc_disk (const char *filename, const char *size_str, int add, int sparse) if (parse_size (size_str, &size) == -1) return -1; - if (!guestfs_is_config (g)) { - fprintf (stderr, _("can't allocate or add disks after launching\n")); - return -1; - } - fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_TRUNC|O_CLOEXEC, 0666); if (fd == -1) { perror (filename); diff --git a/generator/actions.ml b/generator/actions.ml index 25d2809..39c71ab 100644 --- a/generator/actions.ml +++ b/generator/actions.ml @@ -1186,14 +1186,22 @@ not all belong to a single logical operating system name = "add_drive"; style = RErr, [String "filename"], [OBool "readonly"; OString "format"; OString "iface"; OString "name"; OString "label"]; once_had_no_optargs = true; - fish_alias = ["add"]; config_only = true; + fish_alias = ["add"]; shortdesc = "add an image to examine or modify"; longdesc = "\ This function adds a disk image called C<filename> to the handle. C<filename> may be a regular host file or a host device. -The first time you call this function, the disk appears as -C</dev/sda>, the second time as C</dev/sdb>, and so on. +When this function is called before C<guestfs_launch> (the +usual case) then the first time you call this function, +the disk appears in the API as C</dev/sda>, the second time +as C</dev/sdb>, and so on. + +In libguestfs E<ge> 1.20 you can also call this function +after launch (with some restrictions). This is called +\"hotplugging\". When hotplugging, you must specify a +C<label> so that the new disk gets a predictable name. +For more information see L<guestfs(3)/HOTPLUGGING>. You don't necessarily need to be root when using libguestfs. However you obviously do need sufficient permissions to access the filename @@ -9951,6 +9959,16 @@ This returns a hashtable, where keys are the disk labels are the full raw block device and partition names (eg. C</dev/sda> and C</dev/sda1>)." }; + { defaults with + name = "internal_hot_add_drive"; + style = RErr, [String "label"], []; + proc_nr = Some 370; + in_fish = false; in_docs = false; + tests = []; + shortdesc = "internal hotplugging operation"; + longdesc = "\ +This function is used internally when hotplugging drives." }; + ] (* Non-API meta-commands available only in guestfish. diff --git a/po/POTFILES b/po/POTFILES index 548156c..22cd148 100644 --- a/po/POTFILES +++ b/po/POTFILES @@ -42,6 +42,7 @@ daemon/guestfsd.c daemon/headtail.c daemon/hexdump.c daemon/hivex.c +daemon/hotplug.c daemon/htonl.c daemon/initrd.c daemon/inotify.c diff --git a/src/MAX_PROC_NR b/src/MAX_PROC_NR index 446dfcc..5b0cffb 100644 --- a/src/MAX_PROC_NR +++ b/src/MAX_PROC_NR @@ -1 +1 @@ -369 +370 diff --git a/src/guestfs-internal.h b/src/guestfs-internal.h index ed9ada4..db9818c 100644 --- a/src/guestfs-internal.h +++ b/src/guestfs-internal.h @@ -166,6 +166,9 @@ struct attach_ops { int (*get_pid) (guestfs_h *g); /* get-pid API. */ int (*max_disks) (guestfs_h *g); /* max-disks API. */ + + /* Hotplugging drives. */ + int (*hot_add_drive) (guestfs_h *g, struct drive *drv, size_t drv_index); }; extern struct attach_ops attach_ops_appliance; extern struct attach_ops attach_ops_libvirt; diff --git a/src/guestfs.pod b/src/guestfs.pod index 48d810b..624e743 100644 --- a/src/guestfs.pod +++ b/src/guestfs.pod @@ -143,8 +143,11 @@ one you added), etc. Once L</guestfs_launch> has been called you cannot add any more images. You can call L</guestfs_list_devices> to get a list of the device -names, in the order that you added them. See also L</BLOCK DEVICE -NAMING> below. +names, in the order that you added them. +See also L</BLOCK DEVICE NAMING> below. + +There are slightly different rules when hotplugging disks (in +libguestfs E<ge> 1.20). See L</HOTPLUGGING> below. =head2 MOUNTING @@ -601,6 +604,35 @@ Libguestfs on top of FUSE performs quite poorly. For best performance do not use it. Use ordinary libguestfs filesystem calls, upload, download etc. instead. +=head2 HOTPLUGGING + +In libguestfs E<ge> 1.20, you may add drives after calling +L</guestfs_launch>. There are some restrictions, see below. +This is called I<hotplugging>. + +Only a subset of the attach-method backends support hotplugging +(currently only the libvirt attach-method has support). It also +requires that you use libvirt E<ge> 0.10.3 and qemu E<ge> 1.2. + +To hot-add a disk, simply call L</guestfs_add_drive_opts> after +L</guestfs_launch>. It is mandatory to specify the C<label> parameter +so that the newly added disk has a predictable name. For example: + + if (guestfs_launch (g) == -1) + error ("launch failed"); + + if (guestfs_add_drive_opts (g, filename, + GUESTFS_ADD_DRIVE_OPTS_LABEL, "newdisk", + -1) == -1) + error ("hot-add of disk failed"); + + if (guestfs_part_disk ("/dev/disk/guestfs/newdisk", "mbr") == -1) + error ("partitioning of hot-added disk failed"); + +Backends that support hotplugging do not require that you add +E<ge> 1 disk before calling launch. When hotplugging is supported +you don't need to add any disks. + =head2 INSPECTION Libguestfs has APIs for inspecting an unknown disk image to find out @@ -2639,7 +2671,7 @@ The guest may be killed by L</guestfs_kill_subprocess>, or may die asynchronously at any time (eg. due to some internal error), and that causes the state to transition back to CONFIG. -Configuration commands for qemu such as L</guestfs_add_drive> can only +Configuration commands for qemu such as L</guestfs_set_path> can only be issued when in the CONFIG state. The API offers one call that goes from CONFIG through LAUNCHING to diff --git a/src/launch-libvirt.c b/src/launch-libvirt.c index aa1c39f..3eab567 100644 --- a/src/launch-libvirt.c +++ b/src/launch-libvirt.c @@ -135,14 +135,6 @@ launch_libvirt (guestfs_h *g, const char *libvirt_uri) struct drive *drv; size_t i; - /* 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->nr_drives) { - error (g, _("you must call guestfs_add_drive before guestfs_launch")); - return -1; - } - /* XXX: It should be possible to make this work. */ if (g->direct) { error (g, _("direct mode flag is not supported yet for libvirt attach method")); @@ -1376,6 +1368,89 @@ max_disks_libvirt (guestfs_h *g) return 255; } +static xmlChar *construct_libvirt_xml_hot_add_disk (guestfs_h *g, struct drive *drv, size_t drv_index); + +/* Hot-add a drive. Note the appliance is up when this is called. */ +static int +hot_add_drive_libvirt (guestfs_h *g, struct drive *drv, size_t drv_index) +{ + virConnectPtr conn = g->virt.connv; + virDomainPtr dom = g->virt.domv; + xmlChar *xml = NULL; + + if (!conn || !dom) { + /* This is essentially an internal error if it happens. */ + error (g, "%s: conn == NULL or dom == NULL", __func__); + return -1; + } + + /* Create overlay for read-only drive. This works around lack of + * support for <transient/> disks in libvirt. + */ + if (make_qcow2_overlay_for_drive (g, drv) == -1) + return -1; + + /* Create the XML for the new disk. */ + xml = construct_libvirt_xml_hot_add_disk (g, drv, drv_index); + if (xml == NULL) + return -1; + + /* Attach it. */ + if (virDomainAttachDeviceFlags (dom, (char *) xml, + VIR_DOMAIN_DEVICE_MODIFY_LIVE) == -1) { + libvirt_error (g, _("could not attach disk to libvirt domain")); + goto error; + } + + free (xml); + return 0; + + error: + free (xml); + return -1; +} + +static xmlChar * +construct_libvirt_xml_hot_add_disk (guestfs_h *g, struct drive *drv, + size_t drv_index) +{ + xmlChar *ret = NULL; + xmlBufferPtr xb = NULL; + xmlOutputBufferPtr ob; + xmlTextWriterPtr xo = NULL; + + 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)); + + if (construct_libvirt_xml_disk (g, xo, drv, drv_index) == -1) + goto err; + + XMLERROR (-1, xmlTextWriterEndDocument (xo)); + XMLERROR (NULL, ret = xmlBufferDetach (xb)); /* caller frees ret */ + + debug (g, "hot-add disk XML:\n%s", ret); + + err: + if (xo) + xmlFreeTextWriter (xo); /* frees 'ob' too */ + if (xb) + xmlBufferFree (xb); + + return ret; +} + +struct attach_ops attach_ops_libvirt = { + .launch = launch_libvirt, + .shutdown = shutdown_libvirt, + .max_disks = max_disks_libvirt, + .hot_add_drive = hot_add_drive_libvirt, +}; + #else /* no libvirt or libxml2 at compile time */ #define NOT_IMPL(r) \ @@ -1403,10 +1478,16 @@ max_disks_libvirt (guestfs_h *g) NOT_IMPL (-1); } -#endif /* no libvirt or libxml2 at compile time */ +static int +hot_add_drive_libvirt (guestfs_h *g, struct drive *drv, size_t drv_index) +{ + NOT_IMPL (-1); +} struct attach_ops attach_ops_libvirt = { .launch = launch_libvirt, .shutdown = shutdown_libvirt, .max_disks = max_disks_libvirt, }; + +#endif /* no libvirt or libxml2 at compile time */ diff --git a/src/launch.c b/src/launch.c index 1b6cf4b..a4e10fe 100644 --- a/src/launch.c +++ b/src/launch.c @@ -29,6 +29,7 @@ #include <sys/types.h> #include <sys/wait.h> #include <errno.h> +#include <assert.h> #include "c-ctype.h" @@ -57,14 +58,29 @@ guestfs___rollback_drives (guestfs_h *g, size_t old_i) g->nr_drives = old_i; } +/* Add struct drive to the g->drives vector at the given index. */ +static void +add_drive_to_handle_at (guestfs_h *g, struct drive *d, size_t drv_index) +{ + if (drv_index >= g->nr_drives) { + g->drives = safe_realloc (g, g->drives, + sizeof (struct drive *) * (drv_index + 1)); + while (g->nr_drives <= drv_index) { + g->drives[g->nr_drives] = NULL; + g->nr_drives++; + } + } + + assert (g->drives[drv_index] == NULL); + + g->drives[drv_index] = d; +} + /* Add struct drive to the end of the g->drives vector in the handle. */ static void add_drive_to_handle (guestfs_h *g, struct drive *d) { - g->nr_drives++; - g->drives = safe_realloc (g, g->drives, - sizeof (struct drive *) * g->nr_drives); - g->drives[g->nr_drives-1] = d; + add_drive_to_handle_at (g, d, g->nr_drives); } static struct drive * @@ -207,6 +223,48 @@ valid_disk_label (const char *str) return 1; } +/* The low-level function that adds a drive. */ +static int +add_drive (guestfs_h *g, struct drive *drv) +{ + size_t i, drv_index; + + if (g->state == CONFIG) { + /* Not hotplugging, so just add it to the handle. */ + add_drive_to_handle (g, drv); + return 0; + } + + /* ... else, hotplugging case. */ + if (!g->attach_ops || !g->attach_ops->hot_add_drive) { + error (g, _("the current attach-method does not support hotplugging drives")); + return -1; + } + + if (!drv->disk_label) { + error (g, _("'label' is required when hotplugging drives")); + return -1; + } + + /* Get the first free index, or add it at the end. */ + drv_index = g->nr_drives; + for (i = 0; i < g->nr_drives; ++i) + if (g->drives[i] == NULL) + drv_index = i; + + /* Hot-add the drive. */ + if (g->attach_ops->hot_add_drive (g, drv, drv_index) == -1) + return -1; + + add_drive_to_handle_at (g, drv, drv_index); + + /* Call into the appliance to wait for the new drive to appear. */ + if (guestfs_internal_hot_add_drive (g, drv->disk_label) == -1) + return -1; + + return 0; +} + /* Traditionally you have been able to use /dev/null as a filename, as * many times as you like. Ancient KVM (RHEL 5) cannot handle adding * /dev/null readonly. qemu 1.2 + virtio-scsi segfaults when you use @@ -220,7 +278,7 @@ add_null_drive (guestfs_h *g, int readonly, const char *format, const char *iface, const char *name, const char *disk_label) { char *tmpfile = NULL; - int fd = -1; + int fd = -1, r; struct drive *drv; if (format && STRNEQ (format, "raw")) { @@ -252,8 +310,12 @@ add_null_drive (guestfs_h *g, int readonly, const char *format, } drv = create_drive_struct (g, tmpfile, readonly, format, iface, name, disk_label, 0); - add_drive_to_handle (g, drv); + r = add_drive (g, drv); free (tmpfile); + if (r == -1) { + free_drive_struct (drv); + return -1; + } return 0; @@ -328,7 +390,11 @@ guestfs__add_drive_opts (guestfs_h *g, const char *filename, drv = create_drive_struct (g, filename, readonly, format, iface, name, disk_label, use_cache_none); - add_drive_to_handle (g, drv); + if (add_drive (g, drv) == -1) { + free_drive_struct (drv); + return -1; + } + return 0; } diff --git a/tests/hotplug/Makefile.am b/tests/hotplug/Makefile.am new file mode 100644 index 0000000..6644930 --- /dev/null +++ b/tests/hotplug/Makefile.am @@ -0,0 +1,26 @@ +# libguestfs +# Copyright (C) 2012 Red Hat Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program 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 General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +include $(top_srcdir)/subdir-rules.mk + +TESTS = \ + test-hot-add.pl + +TESTS_ENVIRONMENT = $(top_builddir)/run --test + +EXTRA_DIST = \ + $(TESTS) diff --git a/tests/hotplug/test-hot-add.pl b/tests/hotplug/test-hot-add.pl new file mode 100755 index 0000000..b1322e8 --- /dev/null +++ b/tests/hotplug/test-hot-add.pl @@ -0,0 +1,66 @@ +#!/usr/bin/perl +# Copyright (C) 2012 Red Hat Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program 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 General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +# Test hot-adding disks. + +use strict; +use warnings; + +use Sys::Guestfs; + +my $g = Sys::Guestfs->new (); + +# Skip the test if the default attach-method isn't libvirt, since only +# the libvirt backend supports hotplugging. +my $attach_method = $g->get_attach_method (); +unless ($attach_method eq "libvirt" || $attach_method =~ /^libvirt:/) { + print "$0: test skipped because attach-method ($attach_method) is not libvirt\n"; + exit 77 +} + +# We don't need to add disks before launch. +$g->launch (); + +# Create some temporary disks. +open FILE, ">test1.img" or die "test1.img: $!"; +truncate FILE, 512 * 1024 * 1024 or die "test1.img: truncate: $!"; +close FILE; + +open FILE, ">test2.img" or die "test2.img: $!"; +truncate FILE, 512 * 1024 * 1024 or die "test2.img: truncate: $!"; +close FILE; + +die unless system ("qemu-img create -f qcow2 test3.img 1G") == 0; + +# Hot-add them. Labels are required. +$g->add_drive ("test1.img", label => "a"); # autodetect format +$g->add_drive ("test2.img", label => "b", format => "raw", readonly => 1); +$g->add_drive ("test3.img", label => "c", format => "qcow2"); + +# Check we can use the disks immediately. +$g->part_disk ("/dev/disk/guestfs/a", "mbr"); +$g->mkfs ("ext2", "/dev/disk/guestfs/c"); +$g->mkfs ("ext2", "/dev/disk/guestfs/a1"); + +$g->shutdown (); +$g->close (); + +unlink "test1.img"; +unlink "test2.img"; +unlink "test3.img"; + +exit 0 -- 1.7.10.4