Commit 6d7c06c2 authored by Anthony PERARD's avatar Anthony PERARD
Browse files

Remove broken Xen PV domain builder 

It is broken since Xen 4.9 [1] and it will not build in Xen 4.12. Also,
it is not built by default since QEMU 2.6.

[1] https://lists.xenproject.org/archives/html/xen-devel/2018-09/msg00313.html



Signed-off-by: default avatarAnthony PERARD <anthony.perard@citrix.com>
Acked-by: default avatarStefano Stabellini <sstabellini@kernel.org>
parent 19f87870

configure

+0 −17
Original line number Diff line number Diff line
@@ -357,7 +357,6 @@ vnc_png="" 
xkbcommon=""

xen=""

xen_ctrl_version=""

xen_pv_domain_build="no"

xen_pci_passthrough=""

linux_aio=""

cap_ng=""
@@ -1119,10 +1118,6 @@ for opt do 
  ;;

  --enable-xen-pci-passthrough) xen_pci_passthrough="yes"

  ;;

  --disable-xen-pv-domain-build) xen_pv_domain_build="no"

  ;;

  --enable-xen-pv-domain-build) xen_pv_domain_build="yes"

  ;;

  --disable-brlapi) brlapi="no"

  ;;

  --enable-brlapi) brlapi="yes"
@@ -1685,8 +1680,6 @@ Advanced options (experts only): 
  --tls-priority           default TLS protocol/cipher priority string

  --enable-gprof           QEMU profiling with gprof

  --enable-profiler        profiler support

  --enable-xen-pv-domain-build

                           xen pv domain builder

  --enable-debug-stack-usage

                           track the maximum stack usage of stacks created by qemu_alloc_stack
@@ -2678,12 +2671,6 @@ if test "$xen_pci_passthrough" != "no"; then 
  fi

fi



if test "$xen_pv_domain_build" = "yes" &&

   test "$xen" != "yes"; then

    error_exit "User requested Xen PV domain builder support" \

	       "which requires Xen support."

fi



##########################################

# Windows Hypervisor Platform accelerator (WHPX) check

if test "$whpx" != "no" ; then
@@ -6069,7 +6056,6 @@ fi 
echo "xen support       $xen"

if test "$xen" = "yes" ; then

  echo "xen ctrl version  $xen_ctrl_version"

  echo "pv dom build      $xen_pv_domain_build"

fi

echo "brlapi support    $brlapi"

echo "bluez  support    $bluez"
@@ -6539,9 +6525,6 @@ fi 
if test "$xen" = "yes" ; then

  echo "CONFIG_XEN_BACKEND=y" >> $config_host_mak

  echo "CONFIG_XEN_CTRL_INTERFACE_VERSION=$xen_ctrl_version" >> $config_host_mak

  if test "$xen_pv_domain_build" = "yes" ; then

    echo "CONFIG_XEN_PV_DOMAIN_BUILD=y" >> $config_host_mak

  fi

fi

if test "$linux_aio" = "yes" ; then

  echo "CONFIG_LINUX_AIO=y" >> $config_host_mak

hw/xenpv/Makefile.objs

+0 −2
Original line number Diff line number Diff line 
# Xen PV machine support

obj-$(CONFIG_XEN) += xen_machine_pv.o
 
# Xen PV machine builder support

obj-$(CONFIG_XEN_PV_DOMAIN_BUILD) += xen_domainbuild.o

hw/xenpv/xen_domainbuild.c

deleted100644 → 0
+0 −299
Original line number Diff line number Diff line 
#include "qemu/osdep.h"

#include "qemu/units.h"

#include "hw/xen/xen-legacy-backend.h"

#include "xen_domainbuild.h"

#include "qemu/timer.h"

#include "qemu/log.h"



#include <xenguest.h>



static int xenstore_domain_mkdir(char *path)

{

    struct xs_permissions perms_ro[] = {{

            .id    = 0, /* set owner: dom0 */

        },{

            .id    = xen_domid,

            .perms = XS_PERM_READ,

        }};

    struct xs_permissions perms_rw[] = {{

            .id    = 0, /* set owner: dom0 */

        },{

            .id    = xen_domid,

            .perms = XS_PERM_READ | XS_PERM_WRITE,

        }};

    const char *writable[] = { "device", "control", "error", NULL };

    char subpath[256];

    int i;



    if (!xs_mkdir(xenstore, 0, path)) {

        fprintf(stderr, "%s: xs_mkdir %s: failed\n", __func__, path);

        return -1;

    }

    if (!xs_set_permissions(xenstore, 0, path, perms_ro, 2)) {

        fprintf(stderr, "%s: xs_set_permissions failed\n", __func__);

        return -1;

    }



    for (i = 0; writable[i]; i++) {

        snprintf(subpath, sizeof(subpath), "%s/%s", path, writable[i]);

        if (!xs_mkdir(xenstore, 0, subpath)) {

            fprintf(stderr, "%s: xs_mkdir %s: failed\n", __func__, subpath);

            return -1;

        }

        if (!xs_set_permissions(xenstore, 0, subpath, perms_rw, 2)) {

            fprintf(stderr, "%s: xs_set_permissions failed\n", __func__);

            return -1;

        }

    }

    return 0;

}



int xenstore_domain_init1(const char *kernel, const char *ramdisk,

                          const char *cmdline)

{

    char *dom, uuid_string[42], vm[256], path[256];

    int i;



    qemu_uuid_unparse(&qemu_uuid, uuid_string);

    dom = xs_get_domain_path(xenstore, xen_domid);

    snprintf(vm,  sizeof(vm),  "/vm/%s", uuid_string);



    xenstore_domain_mkdir(dom);



    xenstore_write_str(vm, "image/ostype",  "linux");

    if (kernel)

        xenstore_write_str(vm, "image/kernel",  kernel);

    if (ramdisk)

        xenstore_write_str(vm, "image/ramdisk", ramdisk);

    if (cmdline)

        xenstore_write_str(vm, "image/cmdline", cmdline);



    /* name + id */

    xenstore_write_str(vm,  "name",   qemu_name ? qemu_name : "no-name");

    xenstore_write_str(vm,  "uuid",   uuid_string);

    xenstore_write_str(dom, "name",   qemu_name ? qemu_name : "no-name");

    xenstore_write_int(dom, "domid",  xen_domid);

    xenstore_write_str(dom, "vm",     vm);



    /* memory */

    xenstore_write_int(dom, "memory/target", ram_size / KiB);

    xenstore_write_int(vm, "memory",         ram_size / MiB);

    xenstore_write_int(vm, "maxmem",         ram_size / MiB);



    /* cpus */

    for (i = 0; i < smp_cpus; i++) {

        snprintf(path, sizeof(path), "cpu/%d/availability",i);

        xenstore_write_str(dom, path, "online");

    }

    xenstore_write_int(vm, "vcpu_avail",  smp_cpus);

    xenstore_write_int(vm, "vcpus",       smp_cpus);



    /* vnc password */

    xenstore_write_str(vm, "vncpassword", "" /* FIXME */);



    free(dom);

    return 0;

}



int xenstore_domain_init2(int xenstore_port, int xenstore_mfn,

                          int console_port, int console_mfn)

{

    char *dom;



    dom = xs_get_domain_path(xenstore, xen_domid);



    /* signal new domain */

    xs_introduce_domain(xenstore,

                        xen_domid,

                        xenstore_mfn,

                        xenstore_port);



    /* xenstore */

    xenstore_write_int(dom, "store/ring-ref",   xenstore_mfn);

    xenstore_write_int(dom, "store/port",       xenstore_port);



    /* console */

    xenstore_write_str(dom, "console/type",     "ioemu");

    xenstore_write_int(dom, "console/limit",    128 * KiB);

    xenstore_write_int(dom, "console/ring-ref", console_mfn);

    xenstore_write_int(dom, "console/port",     console_port);

    xen_config_dev_console(0);



    free(dom);

    return 0;

}



/* ------------------------------------------------------------- */



static QEMUTimer *xen_poll;



/* check domain state once per second */

static void xen_domain_poll(void *opaque)

{

    struct xc_dominfo info;

    int rc;



    rc = xc_domain_getinfo(xen_xc, xen_domid, 1, &info);

    if ((rc != 1) || (info.domid != xen_domid)) {

        qemu_log("xen: domain %d is gone\n", xen_domid);

        goto quit;

    }

    if (info.dying) {

        qemu_log("xen: domain %d is dying (%s%s)\n", xen_domid,

                 info.crashed  ? "crashed"  : "",

                 info.shutdown ? "shutdown" : "");

        goto quit;

    }



    timer_mod(xen_poll, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);

    return;



quit:

    qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);

}



static int xen_domain_watcher(void)

{

    int qemu_running = 1;

    int fd[2], i, n, rc;

    char byte;



    if (pipe(fd) != 0) {

        qemu_log("%s: Huh? pipe error: %s\n", __func__, strerror(errno));

        return -1;

    }

    if (fork() != 0)

        return 0; /* not child */



    /* close all file handles, except stdio/out/err,

     * our watch pipe and the xen interface handle */

    n = getdtablesize();

    for (i = 3; i < n; i++) {

        if (i == fd[0])

            continue;

        close(i);

    }



    /*

     * Reopen xc interface, since the original is unsafe after fork

     * and was closed above.

     */

    xen_xc = xc_interface_open(0, 0, 0);



    /* ignore term signals */

    signal(SIGINT,  SIG_IGN);

    signal(SIGTERM, SIG_IGN);



    /* wait for qemu exiting */

    while (qemu_running) {

        rc = read(fd[0], &byte, 1);

        switch (rc) {

        case -1:

            if (errno == EINTR)

                continue;

            qemu_log("%s: Huh? read error: %s\n", __func__, strerror(errno));

            qemu_running = 0;

            break;

        case 0:

            /* EOF -> qemu exited */

            qemu_running = 0;

            break;

        default:

            qemu_log("%s: Huh? data on the watch pipe?\n", __func__);

            break;

        }

    }



    /* cleanup */

    qemu_log("%s: destroy domain %d\n", __func__, xen_domid);

    xc_domain_destroy(xen_xc, xen_domid);

    _exit(0);

}



/* normal cleanup */

static void xen_domain_cleanup(void)

{

    char *dom;



    dom = xs_get_domain_path(xenstore, xen_domid);

    if (dom) {

        xs_rm(xenstore, 0, dom);

        free(dom);

    }

    xs_release_domain(xenstore, xen_domid);

}



int xen_domain_build_pv(const char *kernel, const char *ramdisk,

                        const char *cmdline)

{

    uint32_t ssidref = 0;

    uint32_t flags = 0;

    xen_domain_handle_t uuid;

    unsigned int xenstore_port = 0, console_port = 0;

    unsigned long xenstore_mfn = 0, console_mfn = 0;

    int rc;



    memcpy(uuid, &qemu_uuid, sizeof(uuid));

    rc = xen_domain_create(xen_xc, ssidref, uuid, flags, &xen_domid);

    if (rc < 0) {

        fprintf(stderr, "xen: xc_domain_create() failed\n");

        goto err;

    }

    qemu_log("xen: created domain %d\n", xen_domid);

    atexit(xen_domain_cleanup);

    if (xen_domain_watcher() == -1) {

        goto err;

    }



    xenstore_domain_init1(kernel, ramdisk, cmdline);



    rc = xc_domain_max_vcpus(xen_xc, xen_domid, smp_cpus);

    if (rc < 0) {

        fprintf(stderr, "xen: xc_domain_max_vcpus() failed\n");

        goto err;

    }



#if 0

    rc = xc_domain_setcpuweight(xen_xc, xen_domid, 256);

    if (rc < 0) {

        fprintf(stderr, "xen: xc_domain_setcpuweight() failed\n");

        goto err;

    }

#endif



    rc = xc_domain_setmaxmem(xen_xc, xen_domid, ram_size / KiB);

    if (rc < 0) {

        fprintf(stderr, "xen: xc_domain_setmaxmem() failed\n");

        goto err;

    }



    xenstore_port = xc_evtchn_alloc_unbound(xen_xc, xen_domid, 0);

    console_port = xc_evtchn_alloc_unbound(xen_xc, xen_domid, 0);



    rc = xc_linux_build(xen_xc, xen_domid, ram_size / MiB,

                        kernel, ramdisk, cmdline,

                        0, flags,

                        xenstore_port, &xenstore_mfn,

                        console_port, &console_mfn);

    if (rc < 0) {

        fprintf(stderr, "xen: xc_linux_build() failed\n");

        goto err;

    }



    xenstore_domain_init2(xenstore_port, xenstore_mfn,

                          console_port, console_mfn);



    qemu_log("xen: unpausing domain %d\n", xen_domid);

    rc = xc_domain_unpause(xen_xc, xen_domid);

    if (rc < 0) {

        fprintf(stderr, "xen: xc_domain_unpause() failed\n");

        goto err;

    }



    xen_poll = timer_new_ms(QEMU_CLOCK_REALTIME, xen_domain_poll, NULL);

    timer_mod(xen_poll, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);

    return 0;



err:

    return -1;

}

hw/xenpv/xen_domainbuild.h

deleted100644 → 0
+0 −13
Original line number Diff line number Diff line 
#ifndef QEMU_HW_XEN_DOMAINBUILD_H

#define QEMU_HW_XEN_DOMAINBUILD_H



#include "hw/xen/xen_common.h"



int xenstore_domain_init1(const char *kernel, const char *ramdisk,

                          const char *cmdline);

int xenstore_domain_init2(int xenstore_port, int xenstore_mfn,

                          int console_port, int console_mfn);

int xen_domain_build_pv(const char *kernel, const char *ramdisk,

                        const char *cmdline);



#endif /* QEMU_HW_XEN_DOMAINBUILD_H */

hw/xenpv/xen_machine_pv.c

+0 −14
Original line number Diff line number Diff line
@@ -28,7 +28,6 @@ 
#include "hw/boards.h"

#include "hw/xen/xen-legacy-backend.h"

#include "hw/xen/xen-bus.h"

#include "xen_domainbuild.h"

#include "sysemu/block-backend.h"



static void xen_init_pv(MachineState *machine)
@@ -46,19 +45,6 @@ static void xen_init_pv(MachineState *machine) 
    case XEN_ATTACH:

        /* nothing to do, xend handles everything */

        break;

#ifdef CONFIG_XEN_PV_DOMAIN_BUILD

    case XEN_CREATE: {

        const char *kernel_filename = machine->kernel_filename;

        const char *kernel_cmdline = machine->kernel_cmdline;

        const char *initrd_filename = machine->initrd_filename;

        if (xen_domain_build_pv(kernel_filename, initrd_filename,

                                kernel_cmdline) < 0) {

            error_report("xen pv domain creation failed");

            exit(1);

        }

        break;

    }

#endif

    case XEN_EMULATE:

        error_report("xen emulation not implemented (yet)");

        exit(1);