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