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/qobject-output-visitor.h" 17 #include "qapi/visitor-impl.h" 18 #include "qemu/queue.h" 19 #include "qemu-common.h" 20 #include "qapi/qmp/types.h" 21 22 typedef struct QStackEntry { 23 QObject *value; 24 void *qapi; /* sanity check that caller uses same pointer */ 25 QSLIST_ENTRY(QStackEntry) node; 26 } QStackEntry; 27 28 struct QObjectOutputVisitor { 29 Visitor visitor; 30 QSLIST_HEAD(, QStackEntry) stack; /* Stack of unfinished containers */ 31 QObject *root; /* Root of the output visit */ 32 QObject **result; /* User's storage location for result */ 33 }; 34 35 #define qobject_output_add(qov, name, value) \ 36 qobject_output_add_obj(qov, name, QOBJECT(value)) 37 #define qobject_output_push(qov, value, qapi) \ 38 qobject_output_push_obj(qov, QOBJECT(value), qapi) 39 40 static QObjectOutputVisitor *to_qov(Visitor *v) 41 { 42 return container_of(v, QObjectOutputVisitor, visitor); 43 } 44 45 /* Push @value onto the stack of current QObjects being built */ 46 static void qobject_output_push_obj(QObjectOutputVisitor *qov, QObject *value, 47 void *qapi) 48 { 49 QStackEntry *e = g_malloc0(sizeof(*e)); 50 51 assert(qov->root); 52 assert(value); 53 e->value = value; 54 e->qapi = qapi; 55 QSLIST_INSERT_HEAD(&qov->stack, e, node); 56 } 57 58 /* Pop a value off the stack of QObjects being built, and return it. */ 59 static QObject *qobject_output_pop(QObjectOutputVisitor *qov, void *qapi) 60 { 61 QStackEntry *e = QSLIST_FIRST(&qov->stack); 62 QObject *value; 63 64 assert(e); 65 assert(e->qapi == qapi); 66 QSLIST_REMOVE_HEAD(&qov->stack, node); 67 value = e->value; 68 assert(value); 69 g_free(e); 70 return value; 71 } 72 73 /* Add @value to the current QObject being built. 74 * If the stack is visiting a dictionary or list, @value is now owned 75 * by that container. Otherwise, @value is now the root. */ 76 static void qobject_output_add_obj(QObjectOutputVisitor *qov, const char *name, 77 QObject *value) 78 { 79 QStackEntry *e = QSLIST_FIRST(&qov->stack); 80 QObject *cur = e ? e->value : NULL; 81 82 if (!cur) { 83 /* Don't allow reuse of visitor on more than one root */ 84 assert(!qov->root); 85 qov->root = value; 86 } else { 87 switch (qobject_type(cur)) { 88 case QTYPE_QDICT: 89 assert(name); 90 qdict_put_obj(qobject_to_qdict(cur), name, value); 91 break; 92 case QTYPE_QLIST: 93 assert(!name); 94 qlist_append_obj(qobject_to_qlist(cur), value); 95 break; 96 default: 97 g_assert_not_reached(); 98 } 99 } 100 } 101 102 static void qobject_output_start_struct(Visitor *v, const char *name, 103 void **obj, size_t unused, Error **errp) 104 { 105 QObjectOutputVisitor *qov = to_qov(v); 106 QDict *dict = qdict_new(); 107 108 qobject_output_add(qov, name, dict); 109 qobject_output_push(qov, dict, obj); 110 } 111 112 static void qobject_output_end_struct(Visitor *v, void **obj) 113 { 114 QObjectOutputVisitor *qov = to_qov(v); 115 QObject *value = qobject_output_pop(qov, obj); 116 assert(qobject_type(value) == QTYPE_QDICT); 117 } 118 119 static void qobject_output_start_list(Visitor *v, const char *name, 120 GenericList **listp, size_t size, 121 Error **errp) 122 { 123 QObjectOutputVisitor *qov = to_qov(v); 124 QList *list = qlist_new(); 125 126 qobject_output_add(qov, name, list); 127 qobject_output_push(qov, list, listp); 128 } 129 130 static GenericList *qobject_output_next_list(Visitor *v, GenericList *tail, 131 size_t size) 132 { 133 return tail->next; 134 } 135 136 static void qobject_output_end_list(Visitor *v, void **obj) 137 { 138 QObjectOutputVisitor *qov = to_qov(v); 139 QObject *value = qobject_output_pop(qov, obj); 140 assert(qobject_type(value) == QTYPE_QLIST); 141 } 142 143 static void qobject_output_type_int64(Visitor *v, const char *name, 144 int64_t *obj, Error **errp) 145 { 146 QObjectOutputVisitor *qov = to_qov(v); 147 qobject_output_add(qov, name, qint_from_int(*obj)); 148 } 149 150 static void qobject_output_type_uint64(Visitor *v, const char *name, 151 uint64_t *obj, Error **errp) 152 { 153 /* FIXME values larger than INT64_MAX become negative */ 154 QObjectOutputVisitor *qov = to_qov(v); 155 qobject_output_add(qov, name, qint_from_int(*obj)); 156 } 157 158 static void qobject_output_type_bool(Visitor *v, const char *name, bool *obj, 159 Error **errp) 160 { 161 QObjectOutputVisitor *qov = to_qov(v); 162 qobject_output_add(qov, name, qbool_from_bool(*obj)); 163 } 164 165 static void qobject_output_type_str(Visitor *v, const char *name, char **obj, 166 Error **errp) 167 { 168 QObjectOutputVisitor *qov = to_qov(v); 169 if (*obj) { 170 qobject_output_add(qov, name, qstring_from_str(*obj)); 171 } else { 172 qobject_output_add(qov, name, qstring_from_str("")); 173 } 174 } 175 176 static void qobject_output_type_number(Visitor *v, const char *name, 177 double *obj, Error **errp) 178 { 179 QObjectOutputVisitor *qov = to_qov(v); 180 qobject_output_add(qov, name, qfloat_from_double(*obj)); 181 } 182 183 static void qobject_output_type_any(Visitor *v, const char *name, 184 QObject **obj, Error **errp) 185 { 186 QObjectOutputVisitor *qov = to_qov(v); 187 qobject_incref(*obj); 188 qobject_output_add_obj(qov, name, *obj); 189 } 190 191 static void qobject_output_type_null(Visitor *v, const char *name, Error **errp) 192 { 193 QObjectOutputVisitor *qov = to_qov(v); 194 qobject_output_add_obj(qov, name, qnull()); 195 } 196 197 /* Finish building, and return the root object. 198 * The root object is never null. The caller becomes the object's 199 * owner, and should use qobject_decref() when done with it. */ 200 static void qobject_output_complete(Visitor *v, void *opaque) 201 { 202 QObjectOutputVisitor *qov = to_qov(v); 203 204 /* A visit must have occurred, with each start paired with end. */ 205 assert(qov->root && QSLIST_EMPTY(&qov->stack)); 206 assert(opaque == qov->result); 207 208 qobject_incref(qov->root); 209 *qov->result = qov->root; 210 qov->result = NULL; 211 } 212 213 static void qobject_output_free(Visitor *v) 214 { 215 QObjectOutputVisitor *qov = to_qov(v); 216 QStackEntry *e; 217 218 while (!QSLIST_EMPTY(&qov->stack)) { 219 e = QSLIST_FIRST(&qov->stack); 220 QSLIST_REMOVE_HEAD(&qov->stack, node); 221 g_free(e); 222 } 223 224 qobject_decref(qov->root); 225 g_free(qov); 226 } 227 228 Visitor *qobject_output_visitor_new(QObject **result) 229 { 230 QObjectOutputVisitor *v; 231 232 v = g_malloc0(sizeof(*v)); 233 234 v->visitor.type = VISITOR_OUTPUT; 235 v->visitor.start_struct = qobject_output_start_struct; 236 v->visitor.end_struct = qobject_output_end_struct; 237 v->visitor.start_list = qobject_output_start_list; 238 v->visitor.next_list = qobject_output_next_list; 239 v->visitor.end_list = qobject_output_end_list; 240 v->visitor.type_int64 = qobject_output_type_int64; 241 v->visitor.type_uint64 = qobject_output_type_uint64; 242 v->visitor.type_bool = qobject_output_type_bool; 243 v->visitor.type_str = qobject_output_type_str; 244 v->visitor.type_number = qobject_output_type_number; 245 v->visitor.type_any = qobject_output_type_any; 246 v->visitor.type_null = qobject_output_type_null; 247 v->visitor.complete = qobject_output_complete; 248 v->visitor.free = qobject_output_free; 249 250 *result = NULL; 251 v->result = result; 252 253 return &v->visitor; 254 } 255