tests/qtest/libqos/qos_external.c

   1 /*
   2  * libqos driver framework
   3  *
   4  * Copyright (c) 2018 Emanuele Giuseppe Esposito <e.emanuelegiuseppe@gmail.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License version 2.1 as published by the Free Software Foundation.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, see <http://www.gnu.org/licenses/>
  17  */
  18
  19 #include "qemu/osdep.h"
  20 #include <getopt.h>
  21 #include "libqtest.h"
  22 #include "qapi/qmp/qdict.h"
  23 #include "qapi/qmp/qbool.h"
  24 #include "qapi/qmp/qstring.h"
  25 #include "qemu/module.h"
  26 #include "qapi/qmp/qlist.h"
  27 #include "malloc.h"
  28 #include "qgraph.h"
  29 #include "qgraph_internal.h"
  30 #include "qos_external.h"
  31
  32 static void machine_apply_to_node(const char *name)
  33 {
  34     char *machine_name = g_strconcat(qtest_get_arch(), "/", name, NULL);
  35
  36     qos_graph_node_set_availability(machine_name, true);
  37     g_free(machine_name);
  38 }
  39
  40 void machines_apply_to_node(MachineInfoList *mach_info)
  41 {
  42     MachineInfoList *tail;
  43
  44     for (tail = mach_info; tail; tail = tail->next) {
  45         machine_apply_to_node(tail->value->name);
  46         if (tail->value->alias) {
  47             machine_apply_to_node(tail->value->alias);
  48         }
  49     }
  50 }
  51
  52 static void type_apply_to_node(const char *name, bool is_abstract)
  53 {
  54     qos_graph_node_set_availability(name, true);
  55     if (is_abstract) {
  56         qos_delete_cmd_line(name);
  57     }
  58 }
  59
  60 void types_apply_to_node(ObjectTypeInfoList *type_info)
  61 {
  62     ObjectTypeInfoList *tail;
  63
  64     for (tail = type_info; tail; tail = tail->next) {
  65         type_apply_to_node(tail->value->name, tail->value->abstract);
  66     }
  67 }
  68
  69 static QGuestAllocator *get_machine_allocator(QOSGraphObject *obj)
  70 {
  71     return obj->get_driver(obj, "memory");
  72 }
  73
  74 /**
  75  * allocate_objects(): given an array of nodes @arg,
  76  * walks the path invoking all constructors and
  77  * passing the corresponding parameter in order to
  78  * continue the objects allocation.
  79  * Once the test is reached, return the object it consumes.
  80  *
  81  * Since the machine and QEDGE_CONSUMED_BY nodes allocate
  82  * memory in the constructor, g_test_queue_destroy is used so
  83  * that after execution they can be safely free'd.  (The test's
  84  * ->before callback is also welcome to use g_test_queue_destroy).
  85  *
  86  * Note: as specified in walk_path() too, @arg is an array of
  87  * char *, where arg[0] is a pointer to the command line
  88  * string that will be used to properly start QEMU when executing
  89  * the test, and the remaining elements represent the actual objects
  90  * that will be allocated.
  91  */
  92 void *allocate_objects(QTestState *qts, char **path, QGuestAllocator **p_alloc)
  93 {
  94     int current = 0;
  95     QGuestAllocator *alloc;
  96     QOSGraphObject *parent = NULL;
  97     QOSGraphEdge *edge;
  98     QOSGraphNode *node;
  99     void *edge_arg;
 100     void *obj;
 101
 102     node = qos_graph_get_node(path[current]);
 103     g_assert(node->type == QNODE_MACHINE);
 104
 105     obj = qos_machine_new(node, qts);
 106     qos_object_queue_destroy(obj);
 107
 108     alloc = get_machine_allocator(obj);
 109     if (p_alloc) {
 110         *p_alloc = alloc;
 111     }
 112
 113     for (;;) {
 114         if (node->type != QNODE_INTERFACE) {
 115             qos_object_start_hw(obj);
 116             parent = obj;
 117         }
 118
 119         /* follow edge and get object for next node constructor */
 120         current++;
 121         edge = qos_graph_get_edge(path[current - 1], path[current]);
 122         node = qos_graph_get_node(path[current]);
 123
 124         if (node->type == QNODE_TEST) {
 125             g_assert(qos_graph_edge_get_type(edge) == QEDGE_CONSUMED_BY);
 126             return obj;
 127         }
 128
 129         switch (qos_graph_edge_get_type(edge)) {
 130         case QEDGE_PRODUCES:
 131             obj = parent->get_driver(parent, path[current]);
 132             break;
 133
 134         case QEDGE_CONSUMED_BY:
 135             edge_arg = qos_graph_edge_get_arg(edge);
 136             obj = qos_driver_new(node, obj, alloc, edge_arg);
 137             qos_object_queue_destroy(obj);
 138             break;
 139
 140         case QEDGE_CONTAINS:
 141             obj = parent->get_device(parent, path[current]);
 142             break;
 143         }
 144     }
 145 }
 146