[v8,10/21] libqos: move useful qos-test funcs to qos_external

The moved functions are not specific to qos-test and might be useful
elsewhere. For example the virtual-device fuzzer makes use of them for
qos-assisted fuzz-targets.

Signed-off-by: Alexander Bulekov <alxndr@bu.edu>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
---
 tests/qtest/Makefile.include      |   1 +
 tests/qtest/libqos/qos_external.c | 168 ++++++++++++++++++++++++++++++
 tests/qtest/libqos/qos_external.h |  28 +++++
 tests/qtest/qos-test.c            | 132 +----------------------
 4 files changed, 198 insertions(+), 131 deletions(-)
 create mode 100644 tests/qtest/libqos/qos_external.c
 create mode 100644 tests/qtest/libqos/qos_external.h

On 29/01/20 06:34, Bulekov, Alexander wrote:
> The moved functions are not specific to qos-test and might be useful
> elsewhere. For example the virtual-device fuzzer makes use of them for
> qos-assisted fuzz-targets.
> 
> Signed-off-by: Alexander Bulekov <alxndr@bu.edu>
> Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
> Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
> ---
>  tests/qtest/Makefile.include      |   1 +
>  tests/qtest/libqos/qos_external.c | 168 ++++++++++++++++++++++++++++++
>  tests/qtest/libqos/qos_external.h |  28 +++++
>  tests/qtest/qos-test.c            | 132 +----------------------
>  4 files changed, 198 insertions(+), 131 deletions(-)
>  create mode 100644 tests/qtest/libqos/qos_external.c
>  create mode 100644 tests/qtest/libqos/qos_external.h
> 
> diff --git a/tests/qtest/Makefile.include b/tests/qtest/Makefile.include
> index 08a48c1252..bdc93d3866 100644
> --- a/tests/qtest/Makefile.include
> +++ b/tests/qtest/Makefile.include
> @@ -172,6 +172,7 @@ libqos-usb-obj-y = $(libqos-spapr-obj-y) $(libqos-pc-obj-y) tests/qtest/libqos/u
>  # qos devices:
>  libqos-obj-y =  $(libqgraph-obj-y)
>  libqos-obj-y += $(libqos-pc-obj-y) $(libqos-spapr-obj-y)
> +libqos-obj-y += tests/qtest/libqos/qos_external.o
>  libqos-obj-y += tests/qtest/libqos/e1000e.o
>  libqos-obj-y += tests/qtest/libqos/i2c.o
>  libqos-obj-y += tests/qtest/libqos/i2c-imx.o
> diff --git a/tests/qtest/libqos/qos_external.c b/tests/qtest/libqos/qos_external.c
> new file mode 100644
> index 0000000000..398556dde0
> --- /dev/null
> +++ b/tests/qtest/libqos/qos_external.c
> @@ -0,0 +1,168 @@
> +/*
> + * libqos driver framework
> + *
> + * Copyright (c) 2018 Emanuele Giuseppe Esposito <e.emanuelegiuseppe@gmail.com>
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License version 2 as published by the Free Software Foundation.
> + *
> + * 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/>
> + */
> +
> +#include "qemu/osdep.h"
> +#include <getopt.h>
> +#include "libqtest.h"
> +#include "qapi/qmp/qdict.h"
> +#include "qapi/qmp/qbool.h"
> +#include "qapi/qmp/qstring.h"
> +#include "qemu/module.h"
> +#include "qapi/qmp/qlist.h"
> +#include "libqos/malloc.h"
> +#include "libqos/qgraph.h"
> +#include "libqos/qgraph_internal.h"
> +#include "libqos/qos_external.h"
> +
> +
> +
> +void apply_to_node(const char *name, bool is_machine, bool is_abstract)
> +{
> +    char *machine_name = NULL;
> +    if (is_machine) {
> +        const char *arch = qtest_get_arch();
> +        machine_name = g_strconcat(arch, "/", name, NULL);
> +        name = machine_name;
> +    }
> +    qos_graph_node_set_availability(name, true);
> +    if (is_abstract) {
> +        qos_delete_cmd_line(name);
> +    }
> +    g_free(machine_name);
> +}

This can be static.

> +
> +/**
> + * apply_to_qlist(): using QMP queries QEMU for a list of
> + * machines and devices available, and sets the respective node
> + * as true. If a node is found, also all its produced and contained
> + * child are marked available.
> + *
> + * See qos_graph_node_set_availability() for more info
> + */
> +void apply_to_qlist(QList *list, bool is_machine)

I think this could be split in two functions with a nicer API, for example

void mark_machines_available(QList *list);
void mark_devices_available(QList *list);

It's okay if internally they just call apply_to_qlist(list, true/false),

only the API would be nicer.
Also feel free to move it to tests/libqos/qgraph.c and
tests/libqos/qgraph_internal.h.  It's probably a good idea to rename
qgraph.h to qgraph-object.h, and qgraph_internal.h to qgraph.h while at it.

Paolo


> +{
> +    const QListEntry *p;
> +    const char *name;
> +    bool abstract;
> +    QDict *minfo;
> +    QObject *qobj;
> +    QString *qstr;
> +    QBool *qbool;
> +
> +    for (p = qlist_first(list); p; p = qlist_next(p)) {
> +        minfo = qobject_to(QDict, qlist_entry_obj(p));
> +        qobj = qdict_get(minfo, "name");
> +        qstr = qobject_to(QString, qobj);
> +        name = qstring_get_str(qstr);
> +
> +        qobj = qdict_get(minfo, "abstract");
> +        if (qobj) {
> +            qbool = qobject_to(QBool, qobj);
> +            abstract = qbool_get_bool(qbool);
> +        } else {
> +            abstract = false;
> +        }
> +
> +        apply_to_node(name, is_machine, abstract);
> +        qobj = qdict_get(minfo, "alias");
> +        if (qobj) {
> +            qstr = qobject_to(QString, qobj);
> +            name = qstring_get_str(qstr);
> +            apply_to_node(name, is_machine, abstract);
> +        }
> +    }
> +}
> +
> +QGuestAllocator *get_machine_allocator(QOSGraphObject *obj)
> +{
> +    return obj->get_driver(obj, "memory");
> +}
> +
> +/**
> + * allocate_objects(): given an array of nodes @arg,
> + * walks the path invoking all constructors and
> + * passing the corresponding parameter in order to
> + * continue the objects allocation.
> + * Once the test is reached, return the object it consumes.
> + *
> + * Since the machine and QEDGE_CONSUMED_BY nodes allocate
> + * memory in the constructor, g_test_queue_destroy is used so
> + * that after execution they can be safely free'd.  (The test's
> + * ->before callback is also welcome to use g_test_queue_destroy).
> + *
> + * Note: as specified in walk_path() too, @arg is an array of
> + * char *, where arg[0] is a pointer to the command line
> + * string that will be used to properly start QEMU when executing
> + * the test, and the remaining elements represent the actual objects
> + * that will be allocated.
> + */
> +void *allocate_objects(QTestState *qts, char **path, QGuestAllocator **p_alloc)
> +{
> +    int current = 0;
> +    QGuestAllocator *alloc;
> +    QOSGraphObject *parent = NULL;
> +    QOSGraphEdge *edge;
> +    QOSGraphNode *node;
> +    void *edge_arg;
> +    void *obj;
> +
> +    node = qos_graph_get_node(path[current]);
> +    g_assert(node->type == QNODE_MACHINE);
> +
> +    obj = qos_machine_new(node, qts);
> +    qos_object_queue_destroy(obj);
> +
> +    alloc = get_machine_allocator(obj);
> +    if (p_alloc) {
> +        *p_alloc = alloc;
> +    }
> +
> +    for (;;) {
> +        if (node->type != QNODE_INTERFACE) {
> +            qos_object_start_hw(obj);
> +            parent = obj;
> +        }
> +
> +        /* follow edge and get object for next node constructor */
> +        current++;
> +        edge = qos_graph_get_edge(path[current - 1], path[current]);
> +        node = qos_graph_get_node(path[current]);
> +
> +        if (node->type == QNODE_TEST) {
> +            g_assert(qos_graph_edge_get_type(edge) == QEDGE_CONSUMED_BY);
> +            return obj;
> +        }
> +
> +        switch (qos_graph_edge_get_type(edge)) {
> +        case QEDGE_PRODUCES:
> +            obj = parent->get_driver(parent, path[current]);
> +            break;
> +
> +        case QEDGE_CONSUMED_BY:
> +            edge_arg = qos_graph_edge_get_arg(edge);
> +            obj = qos_driver_new(node, obj, alloc, edge_arg);
> +            qos_object_queue_destroy(obj);
> +            break;
> +
> +        case QEDGE_CONTAINS:
> +            obj = parent->get_device(parent, path[current]);
> +            break;
> +        }
> +    }
> +}
> +
> diff --git a/tests/qtest/libqos/qos_external.h b/tests/qtest/libqos/qos_external.h
> new file mode 100644
> index 0000000000..7b44930c55
> --- /dev/null
> +++ b/tests/qtest/libqos/qos_external.h
> @@ -0,0 +1,28 @@
> +/*
> + * libqos driver framework
> + *
> + * Copyright (c) 2018 Emanuele Giuseppe Esposito <e.emanuelegiuseppe@gmail.com>
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License version 2 as published by the Free Software Foundation.
> + *
> + * 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/>
> + */
> +
> +#ifndef QOS_EXTERNAL_H
> +#define QOS_EXTERNAL_H
> +#include "libqos/qgraph.h"
> +
> +void apply_to_node(const char *name, bool is_machine, bool is_abstract);
> +void apply_to_qlist(QList *list, bool is_machine);
> +QGuestAllocator *get_machine_allocator(QOSGraphObject *obj);
> +void *allocate_objects(QTestState *qts, char **path, QGuestAllocator **p_alloc);
> +
> +#endif
> diff --git a/tests/qtest/qos-test.c b/tests/qtest/qos-test.c
> index fd70d73ea5..ad193f43a5 100644
> --- a/tests/qtest/qos-test.c
> +++ b/tests/qtest/qos-test.c
> @@ -27,65 +27,11 @@
>  #include "libqos/malloc.h"
>  #include "libqos/qgraph.h"
>  #include "libqos/qgraph_internal.h"
> +#include "libqos/qos_external.h"
>  
>  static char *old_path;
>  
> -static void apply_to_node(const char *name, bool is_machine, bool is_abstract)
> -{
> -    char *machine_name = NULL;
> -    if (is_machine) {
> -        const char *arch = qtest_get_arch();
> -        machine_name = g_strconcat(arch, "/", name, NULL);
> -        name = machine_name;
> -    }
> -    qos_graph_node_set_availability(name, true);
> -    if (is_abstract) {
> -        qos_delete_cmd_line(name);
> -    }
> -    g_free(machine_name);
> -}
>  
> -/**
> - * apply_to_qlist(): using QMP queries QEMU for a list of
> - * machines and devices available, and sets the respective node
> - * as true. If a node is found, also all its produced and contained
> - * child are marked available.
> - *
> - * See qos_graph_node_set_availability() for more info
> - */
> -static void apply_to_qlist(QList *list, bool is_machine)
> -{
> -    const QListEntry *p;
> -    const char *name;
> -    bool abstract;
> -    QDict *minfo;
> -    QObject *qobj;
> -    QString *qstr;
> -    QBool *qbool;
> -
> -    for (p = qlist_first(list); p; p = qlist_next(p)) {
> -        minfo = qobject_to(QDict, qlist_entry_obj(p));
> -        qobj = qdict_get(minfo, "name");
> -        qstr = qobject_to(QString, qobj);
> -        name = qstring_get_str(qstr);
> -
> -        qobj = qdict_get(minfo, "abstract");
> -        if (qobj) {
> -            qbool = qobject_to(QBool, qobj);
> -            abstract = qbool_get_bool(qbool);
> -        } else {
> -            abstract = false;
> -        }
> -
> -        apply_to_node(name, is_machine, abstract);
> -        qobj = qdict_get(minfo, "alias");
> -        if (qobj) {
> -            qstr = qobject_to(QString, qobj);
> -            name = qstring_get_str(qstr);
> -            apply_to_node(name, is_machine, abstract);
> -        }
> -    }
> -}
>  
>  /**
>   * qos_set_machines_devices_available(): sets availability of qgraph
> @@ -129,10 +75,6 @@ static void qos_set_machines_devices_available(void)
>      qobject_unref(response);
>  }
>  
> -static QGuestAllocator *get_machine_allocator(QOSGraphObject *obj)
> -{
> -    return obj->get_driver(obj, "memory");
> -}
>  
>  static void restart_qemu_or_continue(char *path)
>  {
> @@ -159,78 +101,6 @@ void qos_invalidate_command_line(void)
>      old_path = NULL;
>  }
>  
> -/**
> - * allocate_objects(): given an array of nodes @arg,
> - * walks the path invoking all constructors and
> - * passing the corresponding parameter in order to
> - * continue the objects allocation.
> - * Once the test is reached, return the object it consumes.
> - *
> - * Since the machine and QEDGE_CONSUMED_BY nodes allocate
> - * memory in the constructor, g_test_queue_destroy is used so
> - * that after execution they can be safely free'd.  (The test's
> - * ->before callback is also welcome to use g_test_queue_destroy).
> - *
> - * Note: as specified in walk_path() too, @arg is an array of
> - * char *, where arg[0] is a pointer to the command line
> - * string that will be used to properly start QEMU when executing
> - * the test, and the remaining elements represent the actual objects
> - * that will be allocated.
> - */
> -static void *allocate_objects(QTestState *qts, char **path, QGuestAllocator **p_alloc)
> -{
> -    int current = 0;
> -    QGuestAllocator *alloc;
> -    QOSGraphObject *parent = NULL;
> -    QOSGraphEdge *edge;
> -    QOSGraphNode *node;
> -    void *edge_arg;
> -    void *obj;
> -
> -    node = qos_graph_get_node(path[current]);
> -    g_assert(node->type == QNODE_MACHINE);
> -
> -    obj = qos_machine_new(node, qts);
> -    qos_object_queue_destroy(obj);
> -
> -    alloc = get_machine_allocator(obj);
> -    if (p_alloc) {
> -        *p_alloc = alloc;
> -    }
> -
> -    for (;;) {
> -        if (node->type != QNODE_INTERFACE) {
> -            qos_object_start_hw(obj);
> -            parent = obj;
> -        }
> -
> -        /* follow edge and get object for next node constructor */
> -        current++;
> -        edge = qos_graph_get_edge(path[current - 1], path[current]);
> -        node = qos_graph_get_node(path[current]);
> -
> -        if (node->type == QNODE_TEST) {
> -            g_assert(qos_graph_edge_get_type(edge) == QEDGE_CONSUMED_BY);
> -            return obj;
> -        }
> -
> -        switch (qos_graph_edge_get_type(edge)) {
> -        case QEDGE_PRODUCES:
> -            obj = parent->get_driver(parent, path[current]);
> -            break;
> -
> -        case QEDGE_CONSUMED_BY:
> -            edge_arg = qos_graph_edge_get_arg(edge);
> -            obj = qos_driver_new(node, obj, alloc, edge_arg);
> -            qos_object_queue_destroy(obj);
> -            break;
> -
> -        case QEDGE_CONTAINS:
> -            obj = parent->get_device(parent, path[current]);
> -            break;
> -        }
> -    }
> -}
>  
>  /* The argument to run_one_test, which is the test function that is registered
>   * with GTest, is a vector of strings.  The first item is the initial command
>

On Wed, Jan 29, 2020 at 05:34:19AM +0000, Bulekov, Alexander wrote:
>The moved functions are not specific to qos-test and might be useful
>elsewhere. For example the virtual-device fuzzer makes use of them for
>qos-assisted fuzz-targets.
>
>Signed-off-by: Alexander Bulekov <alxndr@bu.edu>
>Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
>Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>

Reviewed-by: Darren Kenny <darren.kenny@oracle.com>

>---
> tests/qtest/Makefile.include      |   1 +
> tests/qtest/libqos/qos_external.c | 168 ++++++++++++++++++++++++++++++
> tests/qtest/libqos/qos_external.h |  28 +++++
> tests/qtest/qos-test.c            | 132 +----------------------
> 4 files changed, 198 insertions(+), 131 deletions(-)
> create mode 100644 tests/qtest/libqos/qos_external.c
> create mode 100644 tests/qtest/libqos/qos_external.h
>
>diff --git a/tests/qtest/Makefile.include b/tests/qtest/Makefile.include
>index 08a48c1252..bdc93d3866 100644
>--- a/tests/qtest/Makefile.include
>+++ b/tests/qtest/Makefile.include
>@@ -172,6 +172,7 @@ libqos-usb-obj-y = $(libqos-spapr-obj-y) $(libqos-pc-obj-y) tests/qtest/libqos/u
> # qos devices:
> libqos-obj-y =  $(libqgraph-obj-y)
> libqos-obj-y += $(libqos-pc-obj-y) $(libqos-spapr-obj-y)
>+libqos-obj-y += tests/qtest/libqos/qos_external.o
> libqos-obj-y += tests/qtest/libqos/e1000e.o
> libqos-obj-y += tests/qtest/libqos/i2c.o
> libqos-obj-y += tests/qtest/libqos/i2c-imx.o
>diff --git a/tests/qtest/libqos/qos_external.c b/tests/qtest/libqos/qos_external.c
>new file mode 100644
>index 0000000000..398556dde0
>--- /dev/null
>+++ b/tests/qtest/libqos/qos_external.c
>@@ -0,0 +1,168 @@
>+/*
>+ * libqos driver framework
>+ *
>+ * Copyright (c) 2018 Emanuele Giuseppe Esposito <e.emanuelegiuseppe@gmail.com>
>+ *
>+ * This library is free software; you can redistribute it and/or
>+ * modify it under the terms of the GNU Lesser General Public
>+ * License version 2 as published by the Free Software Foundation.
>+ *
>+ * 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/>
>+ */
>+
>+#include "qemu/osdep.h"
>+#include <getopt.h>
>+#include "libqtest.h"
>+#include "qapi/qmp/qdict.h"
>+#include "qapi/qmp/qbool.h"
>+#include "qapi/qmp/qstring.h"
>+#include "qemu/module.h"
>+#include "qapi/qmp/qlist.h"
>+#include "libqos/malloc.h"
>+#include "libqos/qgraph.h"
>+#include "libqos/qgraph_internal.h"
>+#include "libqos/qos_external.h"
>+
>+
>+
>+void apply_to_node(const char *name, bool is_machine, bool is_abstract)
>+{
>+    char *machine_name = NULL;
>+    if (is_machine) {
>+        const char *arch = qtest_get_arch();
>+        machine_name = g_strconcat(arch, "/", name, NULL);
>+        name = machine_name;
>+    }
>+    qos_graph_node_set_availability(name, true);
>+    if (is_abstract) {
>+        qos_delete_cmd_line(name);
>+    }
>+    g_free(machine_name);
>+}
>+
>+/**
>+ * apply_to_qlist(): using QMP queries QEMU for a list of
>+ * machines and devices available, and sets the respective node
>+ * as true. If a node is found, also all its produced and contained
>+ * child are marked available.
>+ *
>+ * See qos_graph_node_set_availability() for more info
>+ */
>+void apply_to_qlist(QList *list, bool is_machine)
>+{
>+    const QListEntry *p;
>+    const char *name;
>+    bool abstract;
>+    QDict *minfo;
>+    QObject *qobj;
>+    QString *qstr;
>+    QBool *qbool;
>+
>+    for (p = qlist_first(list); p; p = qlist_next(p)) {
>+        minfo = qobject_to(QDict, qlist_entry_obj(p));
>+        qobj = qdict_get(minfo, "name");
>+        qstr = qobject_to(QString, qobj);
>+        name = qstring_get_str(qstr);
>+
>+        qobj = qdict_get(minfo, "abstract");
>+        if (qobj) {
>+            qbool = qobject_to(QBool, qobj);
>+            abstract = qbool_get_bool(qbool);
>+        } else {
>+            abstract = false;
>+        }
>+
>+        apply_to_node(name, is_machine, abstract);
>+        qobj = qdict_get(minfo, "alias");
>+        if (qobj) {
>+            qstr = qobject_to(QString, qobj);
>+            name = qstring_get_str(qstr);
>+            apply_to_node(name, is_machine, abstract);
>+        }
>+    }
>+}
>+
>+QGuestAllocator *get_machine_allocator(QOSGraphObject *obj)
>+{
>+    return obj->get_driver(obj, "memory");
>+}
>+
>+/**
>+ * allocate_objects(): given an array of nodes @arg,
>+ * walks the path invoking all constructors and
>+ * passing the corresponding parameter in order to
>+ * continue the objects allocation.
>+ * Once the test is reached, return the object it consumes.
>+ *
>+ * Since the machine and QEDGE_CONSUMED_BY nodes allocate
>+ * memory in the constructor, g_test_queue_destroy is used so
>+ * that after execution they can be safely free'd.  (The test's
>+ * ->before callback is also welcome to use g_test_queue_destroy).
>+ *
>+ * Note: as specified in walk_path() too, @arg is an array of
>+ * char *, where arg[0] is a pointer to the command line
>+ * string that will be used to properly start QEMU when executing
>+ * the test, and the remaining elements represent the actual objects
>+ * that will be allocated.
>+ */
>+void *allocate_objects(QTestState *qts, char **path, QGuestAllocator **p_alloc)
>+{
>+    int current = 0;
>+    QGuestAllocator *alloc;
>+    QOSGraphObject *parent = NULL;
>+    QOSGraphEdge *edge;
>+    QOSGraphNode *node;
>+    void *edge_arg;
>+    void *obj;
>+
>+    node = qos_graph_get_node(path[current]);
>+    g_assert(node->type == QNODE_MACHINE);
>+
>+    obj = qos_machine_new(node, qts);
>+    qos_object_queue_destroy(obj);
>+
>+    alloc = get_machine_allocator(obj);
>+    if (p_alloc) {
>+        *p_alloc = alloc;
>+    }
>+
>+    for (;;) {
>+        if (node->type != QNODE_INTERFACE) {
>+            qos_object_start_hw(obj);
>+            parent = obj;
>+        }
>+
>+        /* follow edge and get object for next node constructor */
>+        current++;
>+        edge = qos_graph_get_edge(path[current - 1], path[current]);
>+        node = qos_graph_get_node(path[current]);
>+
>+        if (node->type == QNODE_TEST) {
>+            g_assert(qos_graph_edge_get_type(edge) == QEDGE_CONSUMED_BY);
>+            return obj;
>+        }
>+
>+        switch (qos_graph_edge_get_type(edge)) {
>+        case QEDGE_PRODUCES:
>+            obj = parent->get_driver(parent, path[current]);
>+            break;
>+
>+        case QEDGE_CONSUMED_BY:
>+            edge_arg = qos_graph_edge_get_arg(edge);
>+            obj = qos_driver_new(node, obj, alloc, edge_arg);
>+            qos_object_queue_destroy(obj);
>+            break;
>+
>+        case QEDGE_CONTAINS:
>+            obj = parent->get_device(parent, path[current]);
>+            break;
>+        }
>+    }
>+}
>+
>diff --git a/tests/qtest/libqos/qos_external.h b/tests/qtest/libqos/qos_external.h
>new file mode 100644
>index 0000000000..7b44930c55
>--- /dev/null
>+++ b/tests/qtest/libqos/qos_external.h
>@@ -0,0 +1,28 @@
>+/*
>+ * libqos driver framework
>+ *
>+ * Copyright (c) 2018 Emanuele Giuseppe Esposito <e.emanuelegiuseppe@gmail.com>
>+ *
>+ * This library is free software; you can redistribute it and/or
>+ * modify it under the terms of the GNU Lesser General Public
>+ * License version 2 as published by the Free Software Foundation.
>+ *
>+ * 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/>
>+ */
>+
>+#ifndef QOS_EXTERNAL_H
>+#define QOS_EXTERNAL_H
>+#include "libqos/qgraph.h"
>+
>+void apply_to_node(const char *name, bool is_machine, bool is_abstract);
>+void apply_to_qlist(QList *list, bool is_machine);
>+QGuestAllocator *get_machine_allocator(QOSGraphObject *obj);
>+void *allocate_objects(QTestState *qts, char **path, QGuestAllocator **p_alloc);
>+
>+#endif
>diff --git a/tests/qtest/qos-test.c b/tests/qtest/qos-test.c
>index fd70d73ea5..ad193f43a5 100644
>--- a/tests/qtest/qos-test.c
>+++ b/tests/qtest/qos-test.c
>@@ -27,65 +27,11 @@
> #include "libqos/malloc.h"
> #include "libqos/qgraph.h"
> #include "libqos/qgraph_internal.h"
>+#include "libqos/qos_external.h"
>
> static char *old_path;
>
>-static void apply_to_node(const char *name, bool is_machine, bool is_abstract)
>-{
>-    char *machine_name = NULL;
>-    if (is_machine) {
>-        const char *arch = qtest_get_arch();
>-        machine_name = g_strconcat(arch, "/", name, NULL);
>-        name = machine_name;
>-    }
>-    qos_graph_node_set_availability(name, true);
>-    if (is_abstract) {
>-        qos_delete_cmd_line(name);
>-    }
>-    g_free(machine_name);
>-}
>
>-/**
>- * apply_to_qlist(): using QMP queries QEMU for a list of
>- * machines and devices available, and sets the respective node
>- * as true. If a node is found, also all its produced and contained
>- * child are marked available.
>- *
>- * See qos_graph_node_set_availability() for more info
>- */
>-static void apply_to_qlist(QList *list, bool is_machine)
>-{
>-    const QListEntry *p;
>-    const char *name;
>-    bool abstract;
>-    QDict *minfo;
>-    QObject *qobj;
>-    QString *qstr;
>-    QBool *qbool;
>-
>-    for (p = qlist_first(list); p; p = qlist_next(p)) {
>-        minfo = qobject_to(QDict, qlist_entry_obj(p));
>-        qobj = qdict_get(minfo, "name");
>-        qstr = qobject_to(QString, qobj);
>-        name = qstring_get_str(qstr);
>-
>-        qobj = qdict_get(minfo, "abstract");
>-        if (qobj) {
>-            qbool = qobject_to(QBool, qobj);
>-            abstract = qbool_get_bool(qbool);
>-        } else {
>-            abstract = false;
>-        }
>-
>-        apply_to_node(name, is_machine, abstract);
>-        qobj = qdict_get(minfo, "alias");
>-        if (qobj) {
>-            qstr = qobject_to(QString, qobj);
>-            name = qstring_get_str(qstr);
>-            apply_to_node(name, is_machine, abstract);
>-        }
>-    }
>-}
>
> /**
>  * qos_set_machines_devices_available(): sets availability of qgraph
>@@ -129,10 +75,6 @@ static void qos_set_machines_devices_available(void)
>     qobject_unref(response);
> }
>
>-static QGuestAllocator *get_machine_allocator(QOSGraphObject *obj)
>-{
>-    return obj->get_driver(obj, "memory");
>-}
>
> static void restart_qemu_or_continue(char *path)
> {
>@@ -159,78 +101,6 @@ void qos_invalidate_command_line(void)
>     old_path = NULL;
> }
>
>-/**
>- * allocate_objects(): given an array of nodes @arg,
>- * walks the path invoking all constructors and
>- * passing the corresponding parameter in order to
>- * continue the objects allocation.
>- * Once the test is reached, return the object it consumes.
>- *
>- * Since the machine and QEDGE_CONSUMED_BY nodes allocate
>- * memory in the constructor, g_test_queue_destroy is used so
>- * that after execution they can be safely free'd.  (The test's
>- * ->before callback is also welcome to use g_test_queue_destroy).
>- *
>- * Note: as specified in walk_path() too, @arg is an array of
>- * char *, where arg[0] is a pointer to the command line
>- * string that will be used to properly start QEMU when executing
>- * the test, and the remaining elements represent the actual objects
>- * that will be allocated.
>- */
>-static void *allocate_objects(QTestState *qts, char **path, QGuestAllocator **p_alloc)
>-{
>-    int current = 0;
>-    QGuestAllocator *alloc;
>-    QOSGraphObject *parent = NULL;
>-    QOSGraphEdge *edge;
>-    QOSGraphNode *node;
>-    void *edge_arg;
>-    void *obj;
>-
>-    node = qos_graph_get_node(path[current]);
>-    g_assert(node->type == QNODE_MACHINE);
>-
>-    obj = qos_machine_new(node, qts);
>-    qos_object_queue_destroy(obj);
>-
>-    alloc = get_machine_allocator(obj);
>-    if (p_alloc) {
>-        *p_alloc = alloc;
>-    }
>-
>-    for (;;) {
>-        if (node->type != QNODE_INTERFACE) {
>-            qos_object_start_hw(obj);
>-            parent = obj;
>-        }
>-
>-        /* follow edge and get object for next node constructor */
>-        current++;
>-        edge = qos_graph_get_edge(path[current - 1], path[current]);
>-        node = qos_graph_get_node(path[current]);
>-
>-        if (node->type == QNODE_TEST) {
>-            g_assert(qos_graph_edge_get_type(edge) == QEDGE_CONSUMED_BY);
>-            return obj;
>-        }
>-
>-        switch (qos_graph_edge_get_type(edge)) {
>-        case QEDGE_PRODUCES:
>-            obj = parent->get_driver(parent, path[current]);
>-            break;
>-
>-        case QEDGE_CONSUMED_BY:
>-            edge_arg = qos_graph_edge_get_arg(edge);
>-            obj = qos_driver_new(node, obj, alloc, edge_arg);
>-            qos_object_queue_destroy(obj);
>-            break;
>-
>-        case QEDGE_CONTAINS:
>-            obj = parent->get_device(parent, path[current]);
>-            break;
>-        }
>-    }
>-}
>
> /* The argument to run_one_test, which is the test function that is registered
>  * with GTest, is a vector of strings.  The first item is the initial command
>-- 
>2.23.0
>