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, qnum_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     QObjectOutputVisitor *qov = to_qov(v);
154     qobject_output_add(qov, name, qnum_from_uint(*obj));
155 }
156 
157 static void qobject_output_type_bool(Visitor *v, const char *name, bool *obj,
158                                      Error **errp)
159 {
160     QObjectOutputVisitor *qov = to_qov(v);
161     qobject_output_add(qov, name, qbool_from_bool(*obj));
162 }
163 
164 static void qobject_output_type_str(Visitor *v, const char *name, char **obj,
165                                     Error **errp)
166 {
167     QObjectOutputVisitor *qov = to_qov(v);
168     if (*obj) {
169         qobject_output_add(qov, name, qstring_from_str(*obj));
170     } else {
171         qobject_output_add(qov, name, qstring_from_str(""));
172     }
173 }
174 
175 static void qobject_output_type_number(Visitor *v, const char *name,
176                                        double *obj, Error **errp)
177 {
178     QObjectOutputVisitor *qov = to_qov(v);
179     qobject_output_add(qov, name, qnum_from_double(*obj));
180 }
181 
182 static void qobject_output_type_any(Visitor *v, const char *name,
183                                     QObject **obj, Error **errp)
184 {
185     QObjectOutputVisitor *qov = to_qov(v);
186     qobject_incref(*obj);
187     qobject_output_add_obj(qov, name, *obj);
188 }
189 
190 static void qobject_output_type_null(Visitor *v, const char *name, Error **errp)
191 {
192     QObjectOutputVisitor *qov = to_qov(v);
193     qobject_output_add_obj(qov, name, qnull());
194 }
195 
196 /* Finish building, and return the root object.
197  * The root object is never null. The caller becomes the object's
198  * owner, and should use qobject_decref() when done with it.  */
199 static void qobject_output_complete(Visitor *v, void *opaque)
200 {
201     QObjectOutputVisitor *qov = to_qov(v);
202 
203     /* A visit must have occurred, with each start paired with end.  */
204     assert(qov->root && QSLIST_EMPTY(&qov->stack));
205     assert(opaque == qov->result);
206 
207     qobject_incref(qov->root);
208     *qov->result = qov->root;
209     qov->result = NULL;
210 }
211 
212 static void qobject_output_free(Visitor *v)
213 {
214     QObjectOutputVisitor *qov = to_qov(v);
215     QStackEntry *e;
216 
217     while (!QSLIST_EMPTY(&qov->stack)) {
218         e = QSLIST_FIRST(&qov->stack);
219         QSLIST_REMOVE_HEAD(&qov->stack, node);
220         g_free(e);
221     }
222 
223     qobject_decref(qov->root);
224     g_free(qov);
225 }
226 
227 Visitor *qobject_output_visitor_new(QObject **result)
228 {
229     QObjectOutputVisitor *v;
230 
231     v = g_malloc0(sizeof(*v));
232 
233     v->visitor.type = VISITOR_OUTPUT;
234     v->visitor.start_struct = qobject_output_start_struct;
235     v->visitor.end_struct = qobject_output_end_struct;
236     v->visitor.start_list = qobject_output_start_list;
237     v->visitor.next_list = qobject_output_next_list;
238     v->visitor.end_list = qobject_output_end_list;
239     v->visitor.type_int64 = qobject_output_type_int64;
240     v->visitor.type_uint64 = qobject_output_type_uint64;
241     v->visitor.type_bool = qobject_output_type_bool;
242     v->visitor.type_str = qobject_output_type_str;
243     v->visitor.type_number = qobject_output_type_number;
244     v->visitor.type_any = qobject_output_type_any;
245     v->visitor.type_null = qobject_output_type_null;
246     v->visitor.complete = qobject_output_complete;
247     v->visitor.free = qobject_output_free;
248 
249     *result = NULL;
250     v->result = result;
251 
252     return &v->visitor;
253 }
254