Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20210921' into staging
[qemu.git] / qapi / qapi-visit-core.c
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 "qapi/qmp/qerror.h"
18 #include "qapi/visitor.h"
19 #include "qapi/visitor-impl.h"
20 #include "trace.h"
21
22 void visit_complete(Visitor *v, void *opaque)
23 {
24 assert(v->type != VISITOR_OUTPUT || v->complete);
25 trace_visit_complete(v, opaque);
26 if (v->complete) {
27 v->complete(v, opaque);
28 }
29 }
30
31 void visit_free(Visitor *v)
32 {
33 trace_visit_free(v);
34 if (v) {
35 v->free(v);
36 }
37 }
38
39 bool visit_start_struct(Visitor *v, const char *name, void **obj,
40 size_t size, Error **errp)
41 {
42 bool ok;
43
44 trace_visit_start_struct(v, name, obj, size);
45 if (obj) {
46 assert(size);
47 assert(!(v->type & VISITOR_OUTPUT) || *obj);
48 }
49 ok = v->start_struct(v, name, obj, size, errp);
50 if (obj && (v->type & VISITOR_INPUT)) {
51 assert(ok != !*obj);
52 }
53 return ok;
54 }
55
56 bool visit_check_struct(Visitor *v, Error **errp)
57 {
58 trace_visit_check_struct(v);
59 return v->check_struct ? v->check_struct(v, errp) : true;
60 }
61
62 void visit_end_struct(Visitor *v, void **obj)
63 {
64 trace_visit_end_struct(v, obj);
65 v->end_struct(v, obj);
66 }
67
68 bool visit_start_list(Visitor *v, const char *name, GenericList **list,
69 size_t size, Error **errp)
70 {
71 bool ok;
72
73 assert(!list || size >= sizeof(GenericList));
74 trace_visit_start_list(v, name, list, size);
75 ok = v->start_list(v, name, list, size, errp);
76 if (list && (v->type & VISITOR_INPUT)) {
77 assert(ok || !*list);
78 }
79 return ok;
80 }
81
82 GenericList *visit_next_list(Visitor *v, GenericList *tail, size_t size)
83 {
84 assert(tail && size >= sizeof(GenericList));
85 trace_visit_next_list(v, tail, size);
86 return v->next_list(v, tail, size);
87 }
88
89 bool visit_check_list(Visitor *v, Error **errp)
90 {
91 trace_visit_check_list(v);
92 return v->check_list ? v->check_list(v, errp) : true;
93 }
94
95 void visit_end_list(Visitor *v, void **obj)
96 {
97 trace_visit_end_list(v, obj);
98 v->end_list(v, obj);
99 }
100
101 bool visit_start_alternate(Visitor *v, const char *name,
102 GenericAlternate **obj, size_t size,
103 Error **errp)
104 {
105 bool ok;
106
107 assert(obj && size >= sizeof(GenericAlternate));
108 assert(!(v->type & VISITOR_OUTPUT) || *obj);
109 trace_visit_start_alternate(v, name, obj, size);
110 if (!v->start_alternate) {
111 assert(!(v->type & VISITOR_INPUT));
112 return true;
113 }
114 ok = v->start_alternate(v, name, obj, size, errp);
115 if (v->type & VISITOR_INPUT) {
116 assert(ok != !*obj);
117 }
118 return ok;
119 }
120
121 void visit_end_alternate(Visitor *v, void **obj)
122 {
123 trace_visit_end_alternate(v, obj);
124 if (v->end_alternate) {
125 v->end_alternate(v, obj);
126 }
127 }
128
129 bool visit_optional(Visitor *v, const char *name, bool *present)
130 {
131 trace_visit_optional(v, name, present);
132 if (v->optional) {
133 v->optional(v, name, present);
134 }
135 return *present;
136 }
137
138 bool visit_deprecated_accept(Visitor *v, const char *name, Error **errp)
139 {
140 trace_visit_deprecated_accept(v, name);
141 if (v->deprecated_accept) {
142 return v->deprecated_accept(v, name, errp);
143 }
144 return true;
145 }
146
147 bool visit_deprecated(Visitor *v, const char *name)
148 {
149 trace_visit_deprecated(v, name);
150 if (v->deprecated) {
151 return v->deprecated(v, name);
152 }
153 return true;
154 }
155
156 bool visit_is_input(Visitor *v)
157 {
158 return v->type == VISITOR_INPUT;
159 }
160
161 bool visit_is_dealloc(Visitor *v)
162 {
163 return v->type == VISITOR_DEALLOC;
164 }
165
166 bool visit_type_int(Visitor *v, const char *name, int64_t *obj, Error **errp)
167 {
168 assert(obj);
169 trace_visit_type_int(v, name, obj);
170 return v->type_int64(v, name, obj, errp);
171 }
172
173 static bool visit_type_uintN(Visitor *v, uint64_t *obj, const char *name,
174 uint64_t max, const char *type, Error **errp)
175 {
176 uint64_t value = *obj;
177
178 assert(v->type == VISITOR_INPUT || value <= max);
179
180 if (!v->type_uint64(v, name, &value, errp)) {
181 return false;
182 }
183 if (value > max) {
184 assert(v->type == VISITOR_INPUT);
185 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
186 name ? name : "null", type);
187 return false;
188 }
189 *obj = value;
190 return true;
191 }
192
193 bool visit_type_uint8(Visitor *v, const char *name, uint8_t *obj,
194 Error **errp)
195 {
196 uint64_t value;
197 bool ok;
198
199 trace_visit_type_uint8(v, name, obj);
200 value = *obj;
201 ok = visit_type_uintN(v, &value, name, UINT8_MAX, "uint8_t", errp);
202 *obj = value;
203 return ok;
204 }
205
206 bool visit_type_uint16(Visitor *v, const char *name, uint16_t *obj,
207 Error **errp)
208 {
209 uint64_t value;
210 bool ok;
211
212 trace_visit_type_uint16(v, name, obj);
213 value = *obj;
214 ok = visit_type_uintN(v, &value, name, UINT16_MAX, "uint16_t", errp);
215 *obj = value;
216 return ok;
217 }
218
219 bool visit_type_uint32(Visitor *v, const char *name, uint32_t *obj,
220 Error **errp)
221 {
222 uint64_t value;
223 bool ok;
224
225 trace_visit_type_uint32(v, name, obj);
226 value = *obj;
227 ok = visit_type_uintN(v, &value, name, UINT32_MAX, "uint32_t", errp);
228 *obj = value;
229 return ok;
230 }
231
232 bool visit_type_uint64(Visitor *v, const char *name, uint64_t *obj,
233 Error **errp)
234 {
235 assert(obj);
236 trace_visit_type_uint64(v, name, obj);
237 return v->type_uint64(v, name, obj, errp);
238 }
239
240 static bool visit_type_intN(Visitor *v, int64_t *obj, const char *name,
241 int64_t min, int64_t max, const char *type,
242 Error **errp)
243 {
244 int64_t value = *obj;
245
246 assert(v->type == VISITOR_INPUT || (value >= min && value <= max));
247
248 if (!v->type_int64(v, name, &value, errp)) {
249 return false;
250 }
251 if (value < min || value > max) {
252 assert(v->type == VISITOR_INPUT);
253 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
254 name ? name : "null", type);
255 return false;
256 }
257 *obj = value;
258 return true;
259 }
260
261 bool visit_type_int8(Visitor *v, const char *name, int8_t *obj, Error **errp)
262 {
263 int64_t value;
264 bool ok;
265
266 trace_visit_type_int8(v, name, obj);
267 value = *obj;
268 ok = visit_type_intN(v, &value, name, INT8_MIN, INT8_MAX, "int8_t", errp);
269 *obj = value;
270 return ok;
271 }
272
273 bool visit_type_int16(Visitor *v, const char *name, int16_t *obj,
274 Error **errp)
275 {
276 int64_t value;
277 bool ok;
278
279 trace_visit_type_int16(v, name, obj);
280 value = *obj;
281 ok = visit_type_intN(v, &value, name, INT16_MIN, INT16_MAX, "int16_t",
282 errp);
283 *obj = value;
284 return ok;
285 }
286
287 bool visit_type_int32(Visitor *v, const char *name, int32_t *obj,
288 Error **errp)
289 {
290 int64_t value;
291 bool ok;
292
293 trace_visit_type_int32(v, name, obj);
294 value = *obj;
295 ok = visit_type_intN(v, &value, name, INT32_MIN, INT32_MAX, "int32_t",
296 errp);
297 *obj = value;
298 return ok;
299 }
300
301 bool visit_type_int64(Visitor *v, const char *name, int64_t *obj,
302 Error **errp)
303 {
304 assert(obj);
305 trace_visit_type_int64(v, name, obj);
306 return v->type_int64(v, name, obj, errp);
307 }
308
309 bool visit_type_size(Visitor *v, const char *name, uint64_t *obj,
310 Error **errp)
311 {
312 assert(obj);
313 trace_visit_type_size(v, name, obj);
314 if (v->type_size) {
315 return v->type_size(v, name, obj, errp);
316 }
317 return v->type_uint64(v, name, obj, errp);
318 }
319
320 bool visit_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
321 {
322 assert(obj);
323 trace_visit_type_bool(v, name, obj);
324 return v->type_bool(v, name, obj, errp);
325 }
326
327 bool visit_type_str(Visitor *v, const char *name, char **obj, Error **errp)
328 {
329 bool ok;
330
331 assert(obj);
332 /* TODO: Fix callers to not pass NULL when they mean "", so that we
333 * can enable:
334 assert(!(v->type & VISITOR_OUTPUT) || *obj);
335 */
336 trace_visit_type_str(v, name, obj);
337 ok = v->type_str(v, name, obj, errp);
338 if (v->type & VISITOR_INPUT) {
339 assert(ok != !*obj);
340 }
341 return ok;
342 }
343
344 bool visit_type_number(Visitor *v, const char *name, double *obj,
345 Error **errp)
346 {
347 assert(obj);
348 trace_visit_type_number(v, name, obj);
349 return v->type_number(v, name, obj, errp);
350 }
351
352 bool visit_type_any(Visitor *v, const char *name, QObject **obj, Error **errp)
353 {
354 bool ok;
355
356 assert(obj);
357 assert(v->type != VISITOR_OUTPUT || *obj);
358 trace_visit_type_any(v, name, obj);
359 ok = v->type_any(v, name, obj, errp);
360 if (v->type == VISITOR_INPUT) {
361 assert(ok != !*obj);
362 }
363 return ok;
364 }
365
366 bool visit_type_null(Visitor *v, const char *name, QNull **obj,
367 Error **errp)
368 {
369 trace_visit_type_null(v, name, obj);
370 return v->type_null(v, name, obj, errp);
371 }
372
373 static bool output_type_enum(Visitor *v, const char *name, int *obj,
374 const QEnumLookup *lookup, Error **errp)
375 {
376 int value = *obj;
377 char *enum_str;
378
379 enum_str = (char *)qapi_enum_lookup(lookup, value);
380 return visit_type_str(v, name, &enum_str, errp);
381 }
382
383 static bool input_type_enum(Visitor *v, const char *name, int *obj,
384 const QEnumLookup *lookup, Error **errp)
385 {
386 int64_t value;
387 char *enum_str;
388
389 if (!visit_type_str(v, name, &enum_str, errp)) {
390 return false;
391 }
392
393 value = qapi_enum_parse(lookup, enum_str, -1, NULL);
394 if (value < 0) {
395 error_setg(errp, QERR_INVALID_PARAMETER, enum_str);
396 g_free(enum_str);
397 return false;
398 }
399
400 g_free(enum_str);
401 *obj = value;
402 return true;
403 }
404
405 bool visit_type_enum(Visitor *v, const char *name, int *obj,
406 const QEnumLookup *lookup, Error **errp)
407 {
408 assert(obj && lookup);
409 trace_visit_type_enum(v, name, obj);
410 switch (v->type) {
411 case VISITOR_INPUT:
412 return input_type_enum(v, name, obj, lookup, errp);
413 case VISITOR_OUTPUT:
414 return output_type_enum(v, name, obj, lookup, errp);
415 case VISITOR_CLONE:
416 /* nothing further to do, scalar value was already copied by
417 * g_memdup() during visit_start_*() */
418 return true;
419 case VISITOR_DEALLOC:
420 /* nothing to deallocate for a scalar */
421 return true;
422 default:
423 abort();
424 }
425 }