qapi/qobject-output-visitor.c

   1 /*
   2  * Core Definitions for QAPI/QMP Command Registry
   3  *
   4  * Copyright (C) 2012-2016 Red Hat, Inc.
   5  * Copyright IBM, Corp. 2011
   6  *
   7  * Authors:
   8  *  Anthony Liguori   <aliguori@us.ibm.com>
   9  *
  10  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
  11  * See the COPYING.LIB file in the top-level directory.
  12  *
  13  */
  14
  15 #include "qemu/osdep.h"
  16 #include "qapi/compat-policy.h"
  17 #include "qapi/qobject-output-visitor.h"
  18 #include "qapi/visitor-impl.h"
  19 #include "qemu/queue.h"
  20 #include "qapi/qmp/qbool.h"
  21 #include "qapi/qmp/qdict.h"
  22 #include "qapi/qmp/qlist.h"
  23 #include "qapi/qmp/qnull.h"
  24 #include "qapi/qmp/qnum.h"
  25 #include "qapi/qmp/qstring.h"
  26
  27 typedef struct QStackEntry {
  28     QObject *value;
  29     void *qapi; /* sanity check that caller uses same pointer */
  30     QSLIST_ENTRY(QStackEntry) node;
  31 } QStackEntry;
  32
  33 struct QObjectOutputVisitor {
  34     Visitor visitor;
  35
  36     QSLIST_HEAD(, QStackEntry) stack; /* Stack of unfinished containers */
  37     QObject *root; /* Root of the output visit */
  38     QObject **result; /* User's storage location for result */
  39 };
  40
  41 #define qobject_output_add(qov, name, value) \
  42     qobject_output_add_obj(qov, name, QOBJECT(value))
  43 #define qobject_output_push(qov, value, qapi) \
  44     qobject_output_push_obj(qov, QOBJECT(value), qapi)
  45
  46 static QObjectOutputVisitor *to_qov(Visitor *v)
  47 {
  48     return container_of(v, QObjectOutputVisitor, visitor);
  49 }
  50
  51 /* Push @value onto the stack of current QObjects being built */
  52 static void qobject_output_push_obj(QObjectOutputVisitor *qov, QObject *value,
  53                                     void *qapi)
  54 {
  55     QStackEntry *e = g_malloc0(sizeof(*e));
  56
  57     assert(qov->root);
  58     assert(value);
  59     e->value = value;
  60     e->qapi = qapi;
  61     QSLIST_INSERT_HEAD(&qov->stack, e, node);
  62 }
  63
  64 /* Pop a value off the stack of QObjects being built, and return it. */
  65 static QObject *qobject_output_pop(QObjectOutputVisitor *qov, void *qapi)
  66 {
  67     QStackEntry *e = QSLIST_FIRST(&qov->stack);
  68     QObject *value;
  69
  70     assert(e);
  71     assert(e->qapi == qapi);
  72     QSLIST_REMOVE_HEAD(&qov->stack, node);
  73     value = e->value;
  74     assert(value);
  75     g_free(e);
  76     return value;
  77 }
  78
  79 /* Add @value to the current QObject being built.
  80  * If the stack is visiting a dictionary or list, @value is now owned
  81  * by that container. Otherwise, @value is now the root.  */
  82 static void qobject_output_add_obj(QObjectOutputVisitor *qov, const char *name,
  83                                    QObject *value)
  84 {
  85     QStackEntry *e = QSLIST_FIRST(&qov->stack);
  86     QObject *cur = e ? e->value : NULL;
  87
  88     if (!cur) {
  89         /* Don't allow reuse of visitor on more than one root */
  90         assert(!qov->root);
  91         qov->root = value;
  92     } else {
  93         switch (qobject_type(cur)) {
  94         case QTYPE_QDICT:
  95             assert(name);
  96             qdict_put_obj(qobject_to(QDict, cur), name, value);
  97             break;
  98         case QTYPE_QLIST:
  99             assert(!name);
 100             qlist_append_obj(qobject_to(QList, cur), value);
 101             break;
 102         default:
 103             g_assert_not_reached();
 104         }
 105     }
 106 }
 107
 108 static bool qobject_output_start_struct(Visitor *v, const char *name,
 109                                         void **obj, size_t unused, Error **errp)
 110 {
 111     QObjectOutputVisitor *qov = to_qov(v);
 112     QDict *dict = qdict_new();
 113
 114     qobject_output_add(qov, name, dict);
 115     qobject_output_push(qov, dict, obj);
 116     return true;
 117 }
 118
 119 static void qobject_output_end_struct(Visitor *v, void **obj)
 120 {
 121     QObjectOutputVisitor *qov = to_qov(v);
 122     QObject *value = qobject_output_pop(qov, obj);
 123     assert(qobject_type(value) == QTYPE_QDICT);
 124 }
 125
 126 static bool qobject_output_start_list(Visitor *v, const char *name,
 127                                       GenericList **listp, size_t size,
 128                                       Error **errp)
 129 {
 130     QObjectOutputVisitor *qov = to_qov(v);
 131     QList *list = qlist_new();
 132
 133     qobject_output_add(qov, name, list);
 134     qobject_output_push(qov, list, listp);
 135     return true;
 136 }
 137
 138 static GenericList *qobject_output_next_list(Visitor *v, GenericList *tail,
 139                                              size_t size)
 140 {
 141     return tail->next;
 142 }
 143
 144 static void qobject_output_end_list(Visitor *v, void **obj)
 145 {
 146     QObjectOutputVisitor *qov = to_qov(v);
 147     QObject *value = qobject_output_pop(qov, obj);
 148     assert(qobject_type(value) == QTYPE_QLIST);
 149 }
 150
 151 static bool qobject_output_type_int64(Visitor *v, const char *name,
 152                                       int64_t *obj, Error **errp)
 153 {
 154     QObjectOutputVisitor *qov = to_qov(v);
 155     qobject_output_add(qov, name, qnum_from_int(*obj));
 156     return true;
 157 }
 158
 159 static bool qobject_output_type_uint64(Visitor *v, const char *name,
 160                                        uint64_t *obj, Error **errp)
 161 {
 162     QObjectOutputVisitor *qov = to_qov(v);
 163     qobject_output_add(qov, name, qnum_from_uint(*obj));
 164     return true;
 165 }
 166
 167 static bool qobject_output_type_bool(Visitor *v, const char *name, bool *obj,
 168                                      Error **errp)
 169 {
 170     QObjectOutputVisitor *qov = to_qov(v);
 171     qobject_output_add(qov, name, qbool_from_bool(*obj));
 172     return true;
 173 }
 174
 175 static bool qobject_output_type_str(Visitor *v, const char *name, char **obj,
 176                                     Error **errp)
 177 {
 178     QObjectOutputVisitor *qov = to_qov(v);
 179     if (*obj) {
 180         qobject_output_add(qov, name, qstring_from_str(*obj));
 181     } else {
 182         qobject_output_add(qov, name, qstring_from_str(""));
 183     }
 184     return true;
 185 }
 186
 187 static bool qobject_output_type_number(Visitor *v, const char *name,
 188                                        double *obj, Error **errp)
 189 {
 190     QObjectOutputVisitor *qov = to_qov(v);
 191     qobject_output_add(qov, name, qnum_from_double(*obj));
 192     return true;
 193 }
 194
 195 static bool qobject_output_type_any(Visitor *v, const char *name,
 196                                     QObject **obj, Error **errp)
 197 {
 198     QObjectOutputVisitor *qov = to_qov(v);
 199
 200     qobject_output_add_obj(qov, name, qobject_ref(*obj));
 201     return true;
 202 }
 203
 204 static bool qobject_output_type_null(Visitor *v, const char *name,
 205                                      QNull **obj, Error **errp)
 206 {
 207     QObjectOutputVisitor *qov = to_qov(v);
 208     qobject_output_add(qov, name, qnull());
 209     return true;
 210 }
 211
 212 static bool qobject_output_policy_skip(Visitor *v, const char *name,
 213                                        unsigned special_features)
 214 {
 215     return !(special_features & 1u << QAPI_DEPRECATED)
 216         || v->compat_policy.deprecated_output == COMPAT_POLICY_OUTPUT_HIDE;
 217 }
 218
 219 /* Finish building, and return the root object.
 220  * The root object is never null. The caller becomes the object's
 221  * owner, and should use qobject_unref() when done with it.  */
 222 static void qobject_output_complete(Visitor *v, void *opaque)
 223 {
 224     QObjectOutputVisitor *qov = to_qov(v);
 225
 226     /* A visit must have occurred, with each start paired with end.  */
 227     assert(qov->root && QSLIST_EMPTY(&qov->stack));
 228     assert(opaque == qov->result);
 229
 230     *qov->result = qobject_ref(qov->root);
 231     qov->result = NULL;
 232 }
 233
 234 static void qobject_output_free(Visitor *v)
 235 {
 236     QObjectOutputVisitor *qov = to_qov(v);
 237     QStackEntry *e;
 238
 239     while (!QSLIST_EMPTY(&qov->stack)) {
 240         e = QSLIST_FIRST(&qov->stack);
 241         QSLIST_REMOVE_HEAD(&qov->stack, node);
 242         g_free(e);
 243     }
 244
 245     qobject_unref(qov->root);
 246     g_free(qov);
 247 }
 248
 249 Visitor *qobject_output_visitor_new(QObject **result)
 250 {
 251     QObjectOutputVisitor *v;
 252
 253     v = g_malloc0(sizeof(*v));
 254
 255     v->visitor.type = VISITOR_OUTPUT;
 256     v->visitor.start_struct = qobject_output_start_struct;
 257     v->visitor.end_struct = qobject_output_end_struct;
 258     v->visitor.start_list = qobject_output_start_list;
 259     v->visitor.next_list = qobject_output_next_list;
 260     v->visitor.end_list = qobject_output_end_list;
 261     v->visitor.type_int64 = qobject_output_type_int64;
 262     v->visitor.type_uint64 = qobject_output_type_uint64;
 263     v->visitor.type_bool = qobject_output_type_bool;
 264     v->visitor.type_str = qobject_output_type_str;
 265     v->visitor.type_number = qobject_output_type_number;
 266     v->visitor.type_any = qobject_output_type_any;
 267     v->visitor.type_null = qobject_output_type_null;
 268     v->visitor.policy_skip = qobject_output_policy_skip;
 269     v->visitor.complete = qobject_output_complete;
 270     v->visitor.free = qobject_output_free;
 271
 272     *result = NULL;
 273     v->result = result;
 274
 275     return &v->visitor;
 276 }