xref: /openbmc/qemu/qapi/qapi-visit-core.c (revision b70ce101) 
1 /*
2  * Core Definitions for QAPI Visitor Classes
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/error.h"
17 #include "qemu-common.h"
18 #include "qapi/qmp/qobject.h"
19 #include "qapi/qmp/qerror.h"
20 #include "qapi/visitor.h"
21 #include "qapi/visitor-impl.h"
22 
23 void visit_free(Visitor *v)
24 {
25     if (v) {
26         v->free(v);
27     }
28 }
29 
30 void visit_start_struct(Visitor *v, const char *name, void **obj,
31                         size_t size, Error **errp)
32 {
33     Error *err = NULL;
34 
35     if (obj) {
36         assert(size);
37         assert(v->type != VISITOR_OUTPUT || *obj);
38     }
39     v->start_struct(v, name, obj, size, &err);
40     if (obj && v->type == VISITOR_INPUT) {
41         assert(!err != !*obj);
42     }
43     error_propagate(errp, err);
44 }
45 
46 void visit_check_struct(Visitor *v, Error **errp)
47 {
48     if (v->check_struct) {
49         v->check_struct(v, errp);
50     }
51 }
52 
53 void visit_end_struct(Visitor *v, void **obj)
54 {
55     v->end_struct(v, obj);
56 }
57 
58 void visit_start_list(Visitor *v, const char *name, GenericList **list,
59                       size_t size, Error **errp)
60 {
61     Error *err = NULL;
62 
63     assert(!list || size >= sizeof(GenericList));
64     v->start_list(v, name, list, size, &err);
65     if (list && v->type == VISITOR_INPUT) {
66         assert(!(err && *list));
67     }
68     error_propagate(errp, err);
69 }
70 
71 GenericList *visit_next_list(Visitor *v, GenericList *tail, size_t size)
72 {
73     assert(tail && size >= sizeof(GenericList));
74     return v->next_list(v, tail, size);
75 }
76 
77 void visit_end_list(Visitor *v, void **obj)
78 {
79     v->end_list(v, obj);
80 }
81 
82 void visit_start_alternate(Visitor *v, const char *name,
83                            GenericAlternate **obj, size_t size,
84                            bool promote_int, Error **errp)
85 {
86     Error *err = NULL;
87 
88     assert(obj && size >= sizeof(GenericAlternate));
89     assert(v->type != VISITOR_OUTPUT || *obj);
90     if (v->start_alternate) {
91         v->start_alternate(v, name, obj, size, promote_int, &err);
92     }
93     if (v->type == VISITOR_INPUT) {
94         assert(v->start_alternate && !err != !*obj);
95     }
96     error_propagate(errp, err);
97 }
98 
99 void visit_end_alternate(Visitor *v, void **obj)
100 {
101     if (v->end_alternate) {
102         v->end_alternate(v, obj);
103     }
104 }
105 
106 bool visit_optional(Visitor *v, const char *name, bool *present)
107 {
108     if (v->optional) {
109         v->optional(v, name, present);
110     }
111     return *present;
112 }
113 
114 bool visit_is_input(Visitor *v)
115 {
116     return v->type == VISITOR_INPUT;
117 }
118 
119 void visit_type_int(Visitor *v, const char *name, int64_t *obj, Error **errp)
120 {
121     assert(obj);
122     v->type_int64(v, name, obj, errp);
123 }
124 
125 static void visit_type_uintN(Visitor *v, uint64_t *obj, const char *name,
126                              uint64_t max, const char *type, Error **errp)
127 {
128     Error *err = NULL;
129     uint64_t value = *obj;
130 
131     v->type_uint64(v, name, &value, &err);
132     if (err) {
133         error_propagate(errp, err);
134     } else if (value > max) {
135         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
136                    name ? name : "null", type);
137     } else {
138         *obj = value;
139     }
140 }
141 
142 void visit_type_uint8(Visitor *v, const char *name, uint8_t *obj,
143                       Error **errp)
144 {
145     uint64_t value = *obj;
146     visit_type_uintN(v, &value, name, UINT8_MAX, "uint8_t", errp);
147     *obj = value;
148 }
149 
150 void visit_type_uint16(Visitor *v, const char *name, uint16_t *obj,
151                        Error **errp)
152 {
153     uint64_t value = *obj;
154     visit_type_uintN(v, &value, name, UINT16_MAX, "uint16_t", errp);
155     *obj = value;
156 }
157 
158 void visit_type_uint32(Visitor *v, const char *name, uint32_t *obj,
159                        Error **errp)
160 {
161     uint64_t value = *obj;
162     visit_type_uintN(v, &value, name, UINT32_MAX, "uint32_t", errp);
163     *obj = value;
164 }
165 
166 void visit_type_uint64(Visitor *v, const char *name, uint64_t *obj,
167                        Error **errp)
168 {
169     assert(obj);
170     v->type_uint64(v, name, obj, errp);
171 }
172 
173 static void visit_type_intN(Visitor *v, int64_t *obj, const char *name,
174                             int64_t min, int64_t max, const char *type,
175                             Error **errp)
176 {
177     Error *err = NULL;
178     int64_t value = *obj;
179 
180     v->type_int64(v, name, &value, &err);
181     if (err) {
182         error_propagate(errp, err);
183     } else if (value < min || value > max) {
184         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
185                    name ? name : "null", type);
186     } else {
187         *obj = value;
188     }
189 }
190 
191 void visit_type_int8(Visitor *v, const char *name, int8_t *obj, Error **errp)
192 {
193     int64_t value = *obj;
194     visit_type_intN(v, &value, name, INT8_MIN, INT8_MAX, "int8_t", errp);
195     *obj = value;
196 }
197 
198 void visit_type_int16(Visitor *v, const char *name, int16_t *obj,
199                       Error **errp)
200 {
201     int64_t value = *obj;
202     visit_type_intN(v, &value, name, INT16_MIN, INT16_MAX, "int16_t", errp);
203     *obj = value;
204 }
205 
206 void visit_type_int32(Visitor *v, const char *name, int32_t *obj,
207                       Error **errp)
208 {
209     int64_t value = *obj;
210     visit_type_intN(v, &value, name, INT32_MIN, INT32_MAX, "int32_t", errp);
211     *obj = value;
212 }
213 
214 void visit_type_int64(Visitor *v, const char *name, int64_t *obj,
215                       Error **errp)
216 {
217     assert(obj);
218     v->type_int64(v, name, obj, errp);
219 }
220 
221 void visit_type_size(Visitor *v, const char *name, uint64_t *obj,
222                      Error **errp)
223 {
224     assert(obj);
225     if (v->type_size) {
226         v->type_size(v, name, obj, errp);
227     } else {
228         v->type_uint64(v, name, obj, errp);
229     }
230 }
231 
232 void visit_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
233 {
234     assert(obj);
235     v->type_bool(v, name, obj, errp);
236 }
237 
238 void visit_type_str(Visitor *v, const char *name, char **obj, Error **errp)
239 {
240     Error *err = NULL;
241 
242     assert(obj);
243     /* TODO: Fix callers to not pass NULL when they mean "", so that we
244      * can enable:
245     assert(v->type != VISITOR_OUTPUT || *obj);
246      */
247     v->type_str(v, name, obj, &err);
248     if (v->type == VISITOR_INPUT) {
249         assert(!err != !*obj);
250     }
251     error_propagate(errp, err);
252 }
253 
254 void visit_type_number(Visitor *v, const char *name, double *obj,
255                        Error **errp)
256 {
257     assert(obj);
258     v->type_number(v, name, obj, errp);
259 }
260 
261 void visit_type_any(Visitor *v, const char *name, QObject **obj, Error **errp)
262 {
263     Error *err = NULL;
264 
265     assert(obj);
266     assert(v->type != VISITOR_OUTPUT || *obj);
267     v->type_any(v, name, obj, &err);
268     if (v->type == VISITOR_INPUT) {
269         assert(!err != !*obj);
270     }
271     error_propagate(errp, err);
272 }
273 
274 void visit_type_null(Visitor *v, const char *name, Error **errp)
275 {
276     v->type_null(v, name, errp);
277 }
278 
279 static void output_type_enum(Visitor *v, const char *name, int *obj,
280                              const char *const strings[], Error **errp)
281 {
282     int i = 0;
283     int value = *obj;
284     char *enum_str;
285 
286     while (strings[i++] != NULL);
287     if (value < 0 || value >= i - 1) {
288         error_setg(errp, QERR_INVALID_PARAMETER, name ? name : "null");
289         return;
290     }
291 
292     enum_str = (char *)strings[value];
293     visit_type_str(v, name, &enum_str, errp);
294 }
295 
296 static void input_type_enum(Visitor *v, const char *name, int *obj,
297                             const char *const strings[], Error **errp)
298 {
299     Error *local_err = NULL;
300     int64_t value = 0;
301     char *enum_str;
302 
303     visit_type_str(v, name, &enum_str, &local_err);
304     if (local_err) {
305         error_propagate(errp, local_err);
306         return;
307     }
308 
309     while (strings[value] != NULL) {
310         if (strcmp(strings[value], enum_str) == 0) {
311             break;
312         }
313         value++;
314     }
315 
316     if (strings[value] == NULL) {
317         error_setg(errp, QERR_INVALID_PARAMETER, enum_str);
318         g_free(enum_str);
319         return;
320     }
321 
322     g_free(enum_str);
323     *obj = value;
324 }
325 
326 void visit_type_enum(Visitor *v, const char *name, int *obj,
327                      const char *const strings[], Error **errp)
328 {
329     assert(obj && strings);
330     if (v->type == VISITOR_INPUT) {
331         input_type_enum(v, name, obj, strings, errp);
332     } else if (v->type == VISITOR_OUTPUT) {
333         output_type_enum(v, name, obj, strings, errp);
334     }
335 }
336