[PATCH v2 17/27] tools/libxl: Support converting a legacy stream to a v2 stream

[Andrew Cooper <andrew.cooper3@citrix.com>]

When a legacy stream is found, it needs to be converted to a v2 stream for the
reading logic.  This is done by exec()ing the python conversion utility.

One complication is that the caller of this interface needs to assume
ownership of the output fd, to prevent it being closed while still in use in a
datacopier.

Signed-off-by: Andrew Cooper <andrew.cooper3@citrix.com>
CC: Ian Campbell <Ian.Campbell@citrix.com>
CC: Ian Jackson <Ian.Jackson@eu.citrix.com>
CC: Wei Liu <wei.liu2@citrix.com>

---
No major differences since v1.  It has gained a new ao_abrt as a result
of rebasing over the AO ABORT series, and has been made x86-specific.
---
 tools/libxl/Makefile                |    1 +
 tools/libxl/libxl_convert_callout.c |  172 +++++++++++++++++++++++++++++++++++
 tools/libxl/libxl_internal.h        |   48 ++++++++++
 3 files changed, 221 insertions(+)
 create mode 100644 tools/libxl/libxl_convert_callout.c

diff --git a/tools/libxl/Makefile b/tools/libxl/Makefile
index c71c5fe..0ebc35a 100644
--- a/tools/libxl/Makefile
+++ b/tools/libxl/Makefile
@@ -59,6 +59,7 @@ endif
 LIBXL_OBJS-y += libxl_remus_device.o libxl_remus_disk_drbd.o
 
 LIBXL_OBJS-$(CONFIG_X86) += libxl_cpuid.o libxl_x86.o libxl_psr.o
+LIBXL_OBJS-$(CONFIG_X86) += libxl_convert_callout.o
 LIBXL_OBJS-$(CONFIG_ARM) += libxl_nocpuid.o libxl_arm.o libxl_libfdt_compat.o
 
 ifeq ($(CONFIG_NetBSD),y)
diff --git a/tools/libxl/libxl_convert_callout.c b/tools/libxl/libxl_convert_callout.c
new file mode 100644
index 0000000..02f3b82
--- /dev/null
+++ b/tools/libxl/libxl_convert_callout.c
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2014      Citrix Ltd.
+ *
+ * This program 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; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * 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 Lesser General Public License for more details.
+ */
+
+#include "libxl_osdeps.h"
+
+#include "libxl_internal.h"
+
+/*
+ * Infrastructure for converting a legacy migration stream into a libxl v2
+ * stream.
+ *
+ * This is done by fork()ing the python conversion script, which takes in a
+ * legacy stream, and puts out a suitably-formatted v2 stream.
+ */
+
+static void helper_failed(libxl__egc *egc,
+                          libxl__conversion_helper_state *chs, int rc);
+static void helper_stop(libxl__egc *egc, libxl__ao_abortable*, int rc);
+static void helper_exited(libxl__egc *egc, libxl__ev_child *ch,
+                          pid_t pid, int status);
+static void helper_done(libxl__egc *egc,
+                        libxl__conversion_helper_state *chs);
+
+void libxl__conversion_helper_init(libxl__conversion_helper_state *chs)
+{
+    libxl__ao_abortable_init(&chs->abrt);
+    libxl__ev_child_init(&chs->child);
+}
+
+void libxl__convert_legacy_stream(libxl__egc *egc,
+                                  libxl__conversion_helper_state *chs)
+{
+    STATE_AO_GC(chs->ao);
+    libxl__carefd *child_in = NULL, *child_out = NULL;
+    int ret = 0;
+
+    chs->rc = 0;
+    libxl__conversion_helper_init(chs);
+
+    chs->abrt.ao = chs->ao;
+    chs->abrt.callback = helper_stop;
+    ret = libxl__ao_abortable_register(&chs->abrt);
+    if (ret) goto err;
+
+    libxl__carefd_begin();
+    int fds[2];
+    if (libxl_pipe(CTX, fds)) {
+        ret = ERROR_FAIL;
+        libxl__carefd_unlock();
+        goto err;
+    }
+    child_out = libxl__carefd_record(CTX, fds[0]);
+    child_in  = libxl__carefd_record(CTX, fds[1]);
+    libxl__carefd_unlock();
+
+    pid_t pid = libxl__ev_child_fork(gc, &chs->child, helper_exited);
+    if (!pid) {
+        char * const args[] =
+        {
+            getenv("LIBXL_CONVERT_HELPER") ?:
+                LIBEXEC_BIN "/convert-legacy-stream",
+            "--in",     GCSPRINTF("%d", chs->legacy_fd),
+            "--out",    GCSPRINTF("%d", fds[1]),
+            "--width",
+#ifdef __i386__
+            "32",
+#else
+            "64",
+#endif
+            "--guest",  chs->hvm ? "hvm" : "pv",
+            "--format", "libxl",
+            /* "--verbose", */
+            NULL,
+        };
+
+        libxl_fd_set_cloexec(CTX, chs->legacy_fd, 0);
+        libxl_fd_set_cloexec(CTX, libxl__carefd_fd(child_in), 0);
+
+        libxl__exec(gc,
+                    -1, -1, -1,
+                    args[0], args, NULL);
+    }
+
+    libxl__carefd_close(child_in);
+    chs->v2_carefd = child_out;
+
+    assert(!ret);
+    return;
+
+ err:
+    assert(ret);
+    helper_failed(egc, chs, ret);
+}
+
+void libxl__convert_legacy_stream_abort(libxl__egc *egc,
+                                        libxl__conversion_helper_state *chs,
+                                        int rc)
+{
+    helper_stop(egc, &chs->abrt, rc);
+}
+
+static void helper_failed(libxl__egc *egc,
+                          libxl__conversion_helper_state *chs, int rc)
+{
+    STATE_AO_GC(chs->ao);
+
+    if (!chs->rc)
+        chs->rc = rc;
+
+    if (!libxl__ev_child_inuse(&chs->child)) {
+        helper_done(egc, chs);
+        return;
+    }
+
+    libxl__kill(gc, chs->child.pid, SIGKILL, "conversion helper");
+}
+
+static void helper_stop(libxl__egc *egc, libxl__ao_abortable *abrt, int rc)
+{
+    libxl__conversion_helper_state *chs = CONTAINER_OF(abrt, *chs, abrt);
+    STATE_AO_GC(chs->ao);
+
+    if (!chs->rc)
+        chs->rc = rc;
+
+    if (!libxl__ev_child_inuse(&chs->child)) {
+        helper_done(egc, chs);
+        return;
+    }
+
+    libxl__kill(gc, chs->child.pid, SIGTERM, "conversion helper");
+}
+
+static void helper_exited(libxl__egc *egc, libxl__ev_child *ch,
+                          pid_t pid, int status)
+{
+    libxl__conversion_helper_state *chs = CONTAINER_OF(ch, *chs, child);
+    STATE_AO_GC(chs->ao);
+
+    if (status) {
+        libxl_report_child_exitstatus(CTX, XTL_ERROR, "conversion helper",
+                                      pid, status);
+        chs->rc = ERROR_FAIL;
+    }
+    else
+        chs->rc = 0;
+
+    helper_done(egc, chs);
+}
+
+static void helper_done(libxl__egc *egc,
+                        libxl__conversion_helper_state *chs)
+{
+    STATE_AO_GC(chs->ao);
+
+    assert(!libxl__ev_child_inuse(&chs->child));
+
+    libxl__ao_abortable_deregister(&chs->abrt);
+
+    chs->completion_callback(egc, chs, chs->rc);
+}
diff --git a/tools/libxl/libxl_internal.h b/tools/libxl/libxl_internal.h
index 0f17e7c..68e7f02 100644
--- a/tools/libxl/libxl_internal.h
+++ b/tools/libxl/libxl_internal.h
@@ -2917,6 +2917,53 @@ _hidden void libxl__remus_devices_commit(libxl__egc *egc,
                                          libxl__remus_devices_state *rds);
 _hidden int libxl__netbuffer_enabled(libxl__gc *gc);
 
+/*----- Legacy conversion helper -----*/
+typedef struct libxl__conversion_helper_state libxl__conversion_helper_state;
+
+struct libxl__conversion_helper_state {
+    /* public */
+    libxl__ao *ao;
+    int legacy_fd;
+    bool hvm;                  /* pv or hvm domain? */
+    libxl__carefd *v2_carefd;  /* Filled by successful call to
+                                * libxl__convert_legacy_stream().  Caller
+                                * assumes ownership of the fd. */
+    void (*completion_callback)(
+        libxl__egc *egc, libxl__conversion_helper_state *chs, int rc);
+    /* private */
+    int rc;
+    libxl__ao_abortable abrt;
+    libxl__ev_child child;
+};
+
+#if defined(__x86_64__) || defined(__i386__)
+_hidden void libxl__convert_legacy_stream(libxl__egc *egc,
+                                          libxl__conversion_helper_state *chs);
+
+_hidden void libxl__conversion_helper_init(
+    libxl__conversion_helper_state *chs);
+
+_hidden void libxl__convert_legacy_stream_abort(
+    libxl__egc *egc, libxl__conversion_helper_state *chs, int rc);
+
+static inline bool libxl__convert_legacy_stream_inuse(
+    libxl__conversion_helper_state *chs)
+{
+    return libxl__ev_child_inuse(&chs->child);
+}
+#else
+/* Stubs for non-x86 architecture to reduce code #ifdefary */
+static inline void libxl__conversion_helper_init(
+    libxl__conversion_helper_state *chs) { }
+
+static inline void libxl__convert_legacy_stream_abort(
+    libxl__egc *egc, libxl__conversion_helper_state *chs, int rc) {}
+
+static inline bool libxl__convert_legacy_stream_inuse(
+    libxl__conversion_helper_state *chs) { return 0; }
+#endif
+
+
 /*----- Domain suspend (save) state structure -----*/
 
 typedef struct libxl__domain_suspend_state libxl__domain_suspend_state;
@@ -3283,6 +3330,7 @@ struct libxl__domain_create_state {
          * for the non-stubdom device model. */
     libxl__stream_read_state srs;
     libxl__save_helper_state shs;
+    libxl__conversion_helper_state chs;
     /* necessary if the domain creation failed and we have to destroy it */
     libxl__domain_destroy_state dds;
     libxl__multidev multidev;
-- 
1.7.10.4