qobject-output-visitor.c (8501B)
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 CompatPolicy *pol = &v->compat_policy; 216 217 return ((special_features & 1u << QAPI_DEPRECATED) 218 && pol->deprecated_output == COMPAT_POLICY_OUTPUT_HIDE) 219 || ((special_features & 1u << QAPI_UNSTABLE) 220 && pol->unstable_output == COMPAT_POLICY_OUTPUT_HIDE); 221 } 222 223 /* Finish building, and return the root object. 224 * The root object is never null. The caller becomes the object's 225 * owner, and should use qobject_unref() when done with it. */ 226 static void qobject_output_complete(Visitor *v, void *opaque) 227 { 228 QObjectOutputVisitor *qov = to_qov(v); 229 230 /* A visit must have occurred, with each start paired with end. */ 231 assert(qov->root && QSLIST_EMPTY(&qov->stack)); 232 assert(opaque == qov->result); 233 234 *qov->result = qobject_ref(qov->root); 235 qov->result = NULL; 236 } 237 238 static void qobject_output_free(Visitor *v) 239 { 240 QObjectOutputVisitor *qov = to_qov(v); 241 QStackEntry *e; 242 243 while (!QSLIST_EMPTY(&qov->stack)) { 244 e = QSLIST_FIRST(&qov->stack); 245 QSLIST_REMOVE_HEAD(&qov->stack, node); 246 g_free(e); 247 } 248 249 qobject_unref(qov->root); 250 g_free(qov); 251 } 252 253 Visitor *qobject_output_visitor_new(QObject **result) 254 { 255 QObjectOutputVisitor *v; 256 257 v = g_malloc0(sizeof(*v)); 258 259 v->visitor.type = VISITOR_OUTPUT; 260 v->visitor.start_struct = qobject_output_start_struct; 261 v->visitor.end_struct = qobject_output_end_struct; 262 v->visitor.start_list = qobject_output_start_list; 263 v->visitor.next_list = qobject_output_next_list; 264 v->visitor.end_list = qobject_output_end_list; 265 v->visitor.type_int64 = qobject_output_type_int64; 266 v->visitor.type_uint64 = qobject_output_type_uint64; 267 v->visitor.type_bool = qobject_output_type_bool; 268 v->visitor.type_str = qobject_output_type_str; 269 v->visitor.type_number = qobject_output_type_number; 270 v->visitor.type_any = qobject_output_type_any; 271 v->visitor.type_null = qobject_output_type_null; 272 v->visitor.policy_skip = qobject_output_policy_skip; 273 v->visitor.complete = qobject_output_complete; 274 v->visitor.free = qobject_output_free; 275 276 *result = NULL; 277 v->result = result; 278 279 return &v->visitor; 280 }