]> git.proxmox.com Git - mirror_qemu.git/blob - qapi/qobject-output-visitor.c
qapi: Generalize command policy checking
[mirror_qemu.git] / 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 }