1 | /* AUTOMATICALLY GENERATED, DO NOT MODIFY */ |
2 | |
3 | /* |
4 | * Schema-defined QAPI visitors |
5 | * |
6 | * Copyright IBM, Corp. 2011 |
7 | * Copyright (C) 2014-2018 Red Hat, Inc. |
8 | * |
9 | * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. |
10 | * See the COPYING.LIB file in the top-level directory. |
11 | */ |
12 | |
13 | #include "qemu/osdep.h" |
14 | #include "qapi/error.h" |
15 | #include "qapi/qmp/qerror.h" |
16 | #include "qapi-visit-misc.h" |
17 | |
18 | void visit_type_QMPCapabilityList(Visitor *v, const char *name, QMPCapabilityList **obj, Error **errp) |
19 | { |
20 | Error *err = NULL; |
21 | QMPCapabilityList *tail; |
22 | size_t size = sizeof(**obj); |
23 | |
24 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
25 | if (err) { |
26 | goto out; |
27 | } |
28 | |
29 | for (tail = *obj; tail; |
30 | tail = (QMPCapabilityList *)visit_next_list(v, (GenericList *)tail, size)) { |
31 | visit_type_QMPCapability(v, NULL, &tail->value, &err); |
32 | if (err) { |
33 | break; |
34 | } |
35 | } |
36 | |
37 | if (!err) { |
38 | visit_check_list(v, &err); |
39 | } |
40 | visit_end_list(v, (void **)obj); |
41 | if (err && visit_is_input(v)) { |
42 | qapi_free_QMPCapabilityList(*obj); |
43 | *obj = NULL; |
44 | } |
45 | out: |
46 | error_propagate(errp, err); |
47 | } |
48 | |
49 | void visit_type_q_obj_qmp_capabilities_arg_members(Visitor *v, q_obj_qmp_capabilities_arg *obj, Error **errp) |
50 | { |
51 | Error *err = NULL; |
52 | |
53 | if (visit_optional(v, "enable" , &obj->has_enable)) { |
54 | visit_type_QMPCapabilityList(v, "enable" , &obj->enable, &err); |
55 | if (err) { |
56 | goto out; |
57 | } |
58 | } |
59 | |
60 | out: |
61 | error_propagate(errp, err); |
62 | } |
63 | |
64 | void visit_type_QMPCapability(Visitor *v, const char *name, QMPCapability *obj, Error **errp) |
65 | { |
66 | int value = *obj; |
67 | visit_type_enum(v, name, &value, &QMPCapability_lookup, errp); |
68 | *obj = value; |
69 | } |
70 | |
71 | void visit_type_VersionTriple_members(Visitor *v, VersionTriple *obj, Error **errp) |
72 | { |
73 | Error *err = NULL; |
74 | |
75 | visit_type_int(v, "major" , &obj->major, &err); |
76 | if (err) { |
77 | goto out; |
78 | } |
79 | visit_type_int(v, "minor" , &obj->minor, &err); |
80 | if (err) { |
81 | goto out; |
82 | } |
83 | visit_type_int(v, "micro" , &obj->micro, &err); |
84 | if (err) { |
85 | goto out; |
86 | } |
87 | |
88 | out: |
89 | error_propagate(errp, err); |
90 | } |
91 | |
92 | void visit_type_VersionTriple(Visitor *v, const char *name, VersionTriple **obj, Error **errp) |
93 | { |
94 | Error *err = NULL; |
95 | |
96 | visit_start_struct(v, name, (void **)obj, sizeof(VersionTriple), &err); |
97 | if (err) { |
98 | goto out; |
99 | } |
100 | if (!*obj) { |
101 | goto out_obj; |
102 | } |
103 | visit_type_VersionTriple_members(v, *obj, &err); |
104 | if (err) { |
105 | goto out_obj; |
106 | } |
107 | visit_check_struct(v, &err); |
108 | out_obj: |
109 | visit_end_struct(v, (void **)obj); |
110 | if (err && visit_is_input(v)) { |
111 | qapi_free_VersionTriple(*obj); |
112 | *obj = NULL; |
113 | } |
114 | out: |
115 | error_propagate(errp, err); |
116 | } |
117 | |
118 | void visit_type_VersionInfo_members(Visitor *v, VersionInfo *obj, Error **errp) |
119 | { |
120 | Error *err = NULL; |
121 | |
122 | visit_type_VersionTriple(v, "qemu" , &obj->qemu, &err); |
123 | if (err) { |
124 | goto out; |
125 | } |
126 | visit_type_str(v, "package" , &obj->package, &err); |
127 | if (err) { |
128 | goto out; |
129 | } |
130 | |
131 | out: |
132 | error_propagate(errp, err); |
133 | } |
134 | |
135 | void visit_type_VersionInfo(Visitor *v, const char *name, VersionInfo **obj, Error **errp) |
136 | { |
137 | Error *err = NULL; |
138 | |
139 | visit_start_struct(v, name, (void **)obj, sizeof(VersionInfo), &err); |
140 | if (err) { |
141 | goto out; |
142 | } |
143 | if (!*obj) { |
144 | goto out_obj; |
145 | } |
146 | visit_type_VersionInfo_members(v, *obj, &err); |
147 | if (err) { |
148 | goto out_obj; |
149 | } |
150 | visit_check_struct(v, &err); |
151 | out_obj: |
152 | visit_end_struct(v, (void **)obj); |
153 | if (err && visit_is_input(v)) { |
154 | qapi_free_VersionInfo(*obj); |
155 | *obj = NULL; |
156 | } |
157 | out: |
158 | error_propagate(errp, err); |
159 | } |
160 | |
161 | void visit_type_CommandInfo_members(Visitor *v, CommandInfo *obj, Error **errp) |
162 | { |
163 | Error *err = NULL; |
164 | |
165 | visit_type_str(v, "name" , &obj->name, &err); |
166 | if (err) { |
167 | goto out; |
168 | } |
169 | |
170 | out: |
171 | error_propagate(errp, err); |
172 | } |
173 | |
174 | void visit_type_CommandInfo(Visitor *v, const char *name, CommandInfo **obj, Error **errp) |
175 | { |
176 | Error *err = NULL; |
177 | |
178 | visit_start_struct(v, name, (void **)obj, sizeof(CommandInfo), &err); |
179 | if (err) { |
180 | goto out; |
181 | } |
182 | if (!*obj) { |
183 | goto out_obj; |
184 | } |
185 | visit_type_CommandInfo_members(v, *obj, &err); |
186 | if (err) { |
187 | goto out_obj; |
188 | } |
189 | visit_check_struct(v, &err); |
190 | out_obj: |
191 | visit_end_struct(v, (void **)obj); |
192 | if (err && visit_is_input(v)) { |
193 | qapi_free_CommandInfo(*obj); |
194 | *obj = NULL; |
195 | } |
196 | out: |
197 | error_propagate(errp, err); |
198 | } |
199 | |
200 | void visit_type_CommandInfoList(Visitor *v, const char *name, CommandInfoList **obj, Error **errp) |
201 | { |
202 | Error *err = NULL; |
203 | CommandInfoList *tail; |
204 | size_t size = sizeof(**obj); |
205 | |
206 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
207 | if (err) { |
208 | goto out; |
209 | } |
210 | |
211 | for (tail = *obj; tail; |
212 | tail = (CommandInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
213 | visit_type_CommandInfo(v, NULL, &tail->value, &err); |
214 | if (err) { |
215 | break; |
216 | } |
217 | } |
218 | |
219 | if (!err) { |
220 | visit_check_list(v, &err); |
221 | } |
222 | visit_end_list(v, (void **)obj); |
223 | if (err && visit_is_input(v)) { |
224 | qapi_free_CommandInfoList(*obj); |
225 | *obj = NULL; |
226 | } |
227 | out: |
228 | error_propagate(errp, err); |
229 | } |
230 | |
231 | void visit_type_LostTickPolicy(Visitor *v, const char *name, LostTickPolicy *obj, Error **errp) |
232 | { |
233 | int value = *obj; |
234 | visit_type_enum(v, name, &value, &LostTickPolicy_lookup, errp); |
235 | *obj = value; |
236 | } |
237 | |
238 | void visit_type_q_obj_add_client_arg_members(Visitor *v, q_obj_add_client_arg *obj, Error **errp) |
239 | { |
240 | Error *err = NULL; |
241 | |
242 | visit_type_str(v, "protocol" , &obj->protocol, &err); |
243 | if (err) { |
244 | goto out; |
245 | } |
246 | visit_type_str(v, "fdname" , &obj->fdname, &err); |
247 | if (err) { |
248 | goto out; |
249 | } |
250 | if (visit_optional(v, "skipauth" , &obj->has_skipauth)) { |
251 | visit_type_bool(v, "skipauth" , &obj->skipauth, &err); |
252 | if (err) { |
253 | goto out; |
254 | } |
255 | } |
256 | if (visit_optional(v, "tls" , &obj->has_tls)) { |
257 | visit_type_bool(v, "tls" , &obj->tls, &err); |
258 | if (err) { |
259 | goto out; |
260 | } |
261 | } |
262 | |
263 | out: |
264 | error_propagate(errp, err); |
265 | } |
266 | |
267 | void visit_type_NameInfo_members(Visitor *v, NameInfo *obj, Error **errp) |
268 | { |
269 | Error *err = NULL; |
270 | |
271 | if (visit_optional(v, "name" , &obj->has_name)) { |
272 | visit_type_str(v, "name" , &obj->name, &err); |
273 | if (err) { |
274 | goto out; |
275 | } |
276 | } |
277 | |
278 | out: |
279 | error_propagate(errp, err); |
280 | } |
281 | |
282 | void visit_type_NameInfo(Visitor *v, const char *name, NameInfo **obj, Error **errp) |
283 | { |
284 | Error *err = NULL; |
285 | |
286 | visit_start_struct(v, name, (void **)obj, sizeof(NameInfo), &err); |
287 | if (err) { |
288 | goto out; |
289 | } |
290 | if (!*obj) { |
291 | goto out_obj; |
292 | } |
293 | visit_type_NameInfo_members(v, *obj, &err); |
294 | if (err) { |
295 | goto out_obj; |
296 | } |
297 | visit_check_struct(v, &err); |
298 | out_obj: |
299 | visit_end_struct(v, (void **)obj); |
300 | if (err && visit_is_input(v)) { |
301 | qapi_free_NameInfo(*obj); |
302 | *obj = NULL; |
303 | } |
304 | out: |
305 | error_propagate(errp, err); |
306 | } |
307 | |
308 | void visit_type_KvmInfo_members(Visitor *v, KvmInfo *obj, Error **errp) |
309 | { |
310 | Error *err = NULL; |
311 | |
312 | visit_type_bool(v, "enabled" , &obj->enabled, &err); |
313 | if (err) { |
314 | goto out; |
315 | } |
316 | visit_type_bool(v, "present" , &obj->present, &err); |
317 | if (err) { |
318 | goto out; |
319 | } |
320 | |
321 | out: |
322 | error_propagate(errp, err); |
323 | } |
324 | |
325 | void visit_type_KvmInfo(Visitor *v, const char *name, KvmInfo **obj, Error **errp) |
326 | { |
327 | Error *err = NULL; |
328 | |
329 | visit_start_struct(v, name, (void **)obj, sizeof(KvmInfo), &err); |
330 | if (err) { |
331 | goto out; |
332 | } |
333 | if (!*obj) { |
334 | goto out_obj; |
335 | } |
336 | visit_type_KvmInfo_members(v, *obj, &err); |
337 | if (err) { |
338 | goto out_obj; |
339 | } |
340 | visit_check_struct(v, &err); |
341 | out_obj: |
342 | visit_end_struct(v, (void **)obj); |
343 | if (err && visit_is_input(v)) { |
344 | qapi_free_KvmInfo(*obj); |
345 | *obj = NULL; |
346 | } |
347 | out: |
348 | error_propagate(errp, err); |
349 | } |
350 | |
351 | void visit_type_UuidInfo_members(Visitor *v, UuidInfo *obj, Error **errp) |
352 | { |
353 | Error *err = NULL; |
354 | |
355 | visit_type_str(v, "UUID" , &obj->UUID, &err); |
356 | if (err) { |
357 | goto out; |
358 | } |
359 | |
360 | out: |
361 | error_propagate(errp, err); |
362 | } |
363 | |
364 | void visit_type_UuidInfo(Visitor *v, const char *name, UuidInfo **obj, Error **errp) |
365 | { |
366 | Error *err = NULL; |
367 | |
368 | visit_start_struct(v, name, (void **)obj, sizeof(UuidInfo), &err); |
369 | if (err) { |
370 | goto out; |
371 | } |
372 | if (!*obj) { |
373 | goto out_obj; |
374 | } |
375 | visit_type_UuidInfo_members(v, *obj, &err); |
376 | if (err) { |
377 | goto out_obj; |
378 | } |
379 | visit_check_struct(v, &err); |
380 | out_obj: |
381 | visit_end_struct(v, (void **)obj); |
382 | if (err && visit_is_input(v)) { |
383 | qapi_free_UuidInfo(*obj); |
384 | *obj = NULL; |
385 | } |
386 | out: |
387 | error_propagate(errp, err); |
388 | } |
389 | |
390 | void visit_type_EventInfo_members(Visitor *v, EventInfo *obj, Error **errp) |
391 | { |
392 | Error *err = NULL; |
393 | |
394 | visit_type_str(v, "name" , &obj->name, &err); |
395 | if (err) { |
396 | goto out; |
397 | } |
398 | |
399 | out: |
400 | error_propagate(errp, err); |
401 | } |
402 | |
403 | void visit_type_EventInfo(Visitor *v, const char *name, EventInfo **obj, Error **errp) |
404 | { |
405 | Error *err = NULL; |
406 | |
407 | visit_start_struct(v, name, (void **)obj, sizeof(EventInfo), &err); |
408 | if (err) { |
409 | goto out; |
410 | } |
411 | if (!*obj) { |
412 | goto out_obj; |
413 | } |
414 | visit_type_EventInfo_members(v, *obj, &err); |
415 | if (err) { |
416 | goto out_obj; |
417 | } |
418 | visit_check_struct(v, &err); |
419 | out_obj: |
420 | visit_end_struct(v, (void **)obj); |
421 | if (err && visit_is_input(v)) { |
422 | qapi_free_EventInfo(*obj); |
423 | *obj = NULL; |
424 | } |
425 | out: |
426 | error_propagate(errp, err); |
427 | } |
428 | |
429 | void visit_type_EventInfoList(Visitor *v, const char *name, EventInfoList **obj, Error **errp) |
430 | { |
431 | Error *err = NULL; |
432 | EventInfoList *tail; |
433 | size_t size = sizeof(**obj); |
434 | |
435 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
436 | if (err) { |
437 | goto out; |
438 | } |
439 | |
440 | for (tail = *obj; tail; |
441 | tail = (EventInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
442 | visit_type_EventInfo(v, NULL, &tail->value, &err); |
443 | if (err) { |
444 | break; |
445 | } |
446 | } |
447 | |
448 | if (!err) { |
449 | visit_check_list(v, &err); |
450 | } |
451 | visit_end_list(v, (void **)obj); |
452 | if (err && visit_is_input(v)) { |
453 | qapi_free_EventInfoList(*obj); |
454 | *obj = NULL; |
455 | } |
456 | out: |
457 | error_propagate(errp, err); |
458 | } |
459 | |
460 | void visit_type_IOThreadInfo_members(Visitor *v, IOThreadInfo *obj, Error **errp) |
461 | { |
462 | Error *err = NULL; |
463 | |
464 | visit_type_str(v, "id" , &obj->id, &err); |
465 | if (err) { |
466 | goto out; |
467 | } |
468 | visit_type_int(v, "thread-id" , &obj->thread_id, &err); |
469 | if (err) { |
470 | goto out; |
471 | } |
472 | visit_type_int(v, "poll-max-ns" , &obj->poll_max_ns, &err); |
473 | if (err) { |
474 | goto out; |
475 | } |
476 | visit_type_int(v, "poll-grow" , &obj->poll_grow, &err); |
477 | if (err) { |
478 | goto out; |
479 | } |
480 | visit_type_int(v, "poll-shrink" , &obj->poll_shrink, &err); |
481 | if (err) { |
482 | goto out; |
483 | } |
484 | |
485 | out: |
486 | error_propagate(errp, err); |
487 | } |
488 | |
489 | void visit_type_IOThreadInfo(Visitor *v, const char *name, IOThreadInfo **obj, Error **errp) |
490 | { |
491 | Error *err = NULL; |
492 | |
493 | visit_start_struct(v, name, (void **)obj, sizeof(IOThreadInfo), &err); |
494 | if (err) { |
495 | goto out; |
496 | } |
497 | if (!*obj) { |
498 | goto out_obj; |
499 | } |
500 | visit_type_IOThreadInfo_members(v, *obj, &err); |
501 | if (err) { |
502 | goto out_obj; |
503 | } |
504 | visit_check_struct(v, &err); |
505 | out_obj: |
506 | visit_end_struct(v, (void **)obj); |
507 | if (err && visit_is_input(v)) { |
508 | qapi_free_IOThreadInfo(*obj); |
509 | *obj = NULL; |
510 | } |
511 | out: |
512 | error_propagate(errp, err); |
513 | } |
514 | |
515 | void visit_type_IOThreadInfoList(Visitor *v, const char *name, IOThreadInfoList **obj, Error **errp) |
516 | { |
517 | Error *err = NULL; |
518 | IOThreadInfoList *tail; |
519 | size_t size = sizeof(**obj); |
520 | |
521 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
522 | if (err) { |
523 | goto out; |
524 | } |
525 | |
526 | for (tail = *obj; tail; |
527 | tail = (IOThreadInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
528 | visit_type_IOThreadInfo(v, NULL, &tail->value, &err); |
529 | if (err) { |
530 | break; |
531 | } |
532 | } |
533 | |
534 | if (!err) { |
535 | visit_check_list(v, &err); |
536 | } |
537 | visit_end_list(v, (void **)obj); |
538 | if (err && visit_is_input(v)) { |
539 | qapi_free_IOThreadInfoList(*obj); |
540 | *obj = NULL; |
541 | } |
542 | out: |
543 | error_propagate(errp, err); |
544 | } |
545 | |
546 | void visit_type_BalloonInfo_members(Visitor *v, BalloonInfo *obj, Error **errp) |
547 | { |
548 | Error *err = NULL; |
549 | |
550 | visit_type_int(v, "actual" , &obj->actual, &err); |
551 | if (err) { |
552 | goto out; |
553 | } |
554 | |
555 | out: |
556 | error_propagate(errp, err); |
557 | } |
558 | |
559 | void visit_type_BalloonInfo(Visitor *v, const char *name, BalloonInfo **obj, Error **errp) |
560 | { |
561 | Error *err = NULL; |
562 | |
563 | visit_start_struct(v, name, (void **)obj, sizeof(BalloonInfo), &err); |
564 | if (err) { |
565 | goto out; |
566 | } |
567 | if (!*obj) { |
568 | goto out_obj; |
569 | } |
570 | visit_type_BalloonInfo_members(v, *obj, &err); |
571 | if (err) { |
572 | goto out_obj; |
573 | } |
574 | visit_check_struct(v, &err); |
575 | out_obj: |
576 | visit_end_struct(v, (void **)obj); |
577 | if (err && visit_is_input(v)) { |
578 | qapi_free_BalloonInfo(*obj); |
579 | *obj = NULL; |
580 | } |
581 | out: |
582 | error_propagate(errp, err); |
583 | } |
584 | |
585 | void visit_type_q_obj_BALLOON_CHANGE_arg_members(Visitor *v, q_obj_BALLOON_CHANGE_arg *obj, Error **errp) |
586 | { |
587 | Error *err = NULL; |
588 | |
589 | visit_type_int(v, "actual" , &obj->actual, &err); |
590 | if (err) { |
591 | goto out; |
592 | } |
593 | |
594 | out: |
595 | error_propagate(errp, err); |
596 | } |
597 | |
598 | void visit_type_PciMemoryRange_members(Visitor *v, PciMemoryRange *obj, Error **errp) |
599 | { |
600 | Error *err = NULL; |
601 | |
602 | visit_type_int(v, "base" , &obj->base, &err); |
603 | if (err) { |
604 | goto out; |
605 | } |
606 | visit_type_int(v, "limit" , &obj->limit, &err); |
607 | if (err) { |
608 | goto out; |
609 | } |
610 | |
611 | out: |
612 | error_propagate(errp, err); |
613 | } |
614 | |
615 | void visit_type_PciMemoryRange(Visitor *v, const char *name, PciMemoryRange **obj, Error **errp) |
616 | { |
617 | Error *err = NULL; |
618 | |
619 | visit_start_struct(v, name, (void **)obj, sizeof(PciMemoryRange), &err); |
620 | if (err) { |
621 | goto out; |
622 | } |
623 | if (!*obj) { |
624 | goto out_obj; |
625 | } |
626 | visit_type_PciMemoryRange_members(v, *obj, &err); |
627 | if (err) { |
628 | goto out_obj; |
629 | } |
630 | visit_check_struct(v, &err); |
631 | out_obj: |
632 | visit_end_struct(v, (void **)obj); |
633 | if (err && visit_is_input(v)) { |
634 | qapi_free_PciMemoryRange(*obj); |
635 | *obj = NULL; |
636 | } |
637 | out: |
638 | error_propagate(errp, err); |
639 | } |
640 | |
641 | void visit_type_PciMemoryRegion_members(Visitor *v, PciMemoryRegion *obj, Error **errp) |
642 | { |
643 | Error *err = NULL; |
644 | |
645 | visit_type_int(v, "bar" , &obj->bar, &err); |
646 | if (err) { |
647 | goto out; |
648 | } |
649 | visit_type_str(v, "type" , &obj->type, &err); |
650 | if (err) { |
651 | goto out; |
652 | } |
653 | visit_type_int(v, "address" , &obj->address, &err); |
654 | if (err) { |
655 | goto out; |
656 | } |
657 | visit_type_int(v, "size" , &obj->size, &err); |
658 | if (err) { |
659 | goto out; |
660 | } |
661 | if (visit_optional(v, "prefetch" , &obj->has_prefetch)) { |
662 | visit_type_bool(v, "prefetch" , &obj->prefetch, &err); |
663 | if (err) { |
664 | goto out; |
665 | } |
666 | } |
667 | if (visit_optional(v, "mem_type_64" , &obj->has_mem_type_64)) { |
668 | visit_type_bool(v, "mem_type_64" , &obj->mem_type_64, &err); |
669 | if (err) { |
670 | goto out; |
671 | } |
672 | } |
673 | |
674 | out: |
675 | error_propagate(errp, err); |
676 | } |
677 | |
678 | void visit_type_PciMemoryRegion(Visitor *v, const char *name, PciMemoryRegion **obj, Error **errp) |
679 | { |
680 | Error *err = NULL; |
681 | |
682 | visit_start_struct(v, name, (void **)obj, sizeof(PciMemoryRegion), &err); |
683 | if (err) { |
684 | goto out; |
685 | } |
686 | if (!*obj) { |
687 | goto out_obj; |
688 | } |
689 | visit_type_PciMemoryRegion_members(v, *obj, &err); |
690 | if (err) { |
691 | goto out_obj; |
692 | } |
693 | visit_check_struct(v, &err); |
694 | out_obj: |
695 | visit_end_struct(v, (void **)obj); |
696 | if (err && visit_is_input(v)) { |
697 | qapi_free_PciMemoryRegion(*obj); |
698 | *obj = NULL; |
699 | } |
700 | out: |
701 | error_propagate(errp, err); |
702 | } |
703 | |
704 | void visit_type_PciBusInfo_members(Visitor *v, PciBusInfo *obj, Error **errp) |
705 | { |
706 | Error *err = NULL; |
707 | |
708 | visit_type_int(v, "number" , &obj->number, &err); |
709 | if (err) { |
710 | goto out; |
711 | } |
712 | visit_type_int(v, "secondary" , &obj->secondary, &err); |
713 | if (err) { |
714 | goto out; |
715 | } |
716 | visit_type_int(v, "subordinate" , &obj->subordinate, &err); |
717 | if (err) { |
718 | goto out; |
719 | } |
720 | visit_type_PciMemoryRange(v, "io_range" , &obj->io_range, &err); |
721 | if (err) { |
722 | goto out; |
723 | } |
724 | visit_type_PciMemoryRange(v, "memory_range" , &obj->memory_range, &err); |
725 | if (err) { |
726 | goto out; |
727 | } |
728 | visit_type_PciMemoryRange(v, "prefetchable_range" , &obj->prefetchable_range, &err); |
729 | if (err) { |
730 | goto out; |
731 | } |
732 | |
733 | out: |
734 | error_propagate(errp, err); |
735 | } |
736 | |
737 | void visit_type_PciBusInfo(Visitor *v, const char *name, PciBusInfo **obj, Error **errp) |
738 | { |
739 | Error *err = NULL; |
740 | |
741 | visit_start_struct(v, name, (void **)obj, sizeof(PciBusInfo), &err); |
742 | if (err) { |
743 | goto out; |
744 | } |
745 | if (!*obj) { |
746 | goto out_obj; |
747 | } |
748 | visit_type_PciBusInfo_members(v, *obj, &err); |
749 | if (err) { |
750 | goto out_obj; |
751 | } |
752 | visit_check_struct(v, &err); |
753 | out_obj: |
754 | visit_end_struct(v, (void **)obj); |
755 | if (err && visit_is_input(v)) { |
756 | qapi_free_PciBusInfo(*obj); |
757 | *obj = NULL; |
758 | } |
759 | out: |
760 | error_propagate(errp, err); |
761 | } |
762 | |
763 | void visit_type_PciDeviceInfoList(Visitor *v, const char *name, PciDeviceInfoList **obj, Error **errp) |
764 | { |
765 | Error *err = NULL; |
766 | PciDeviceInfoList *tail; |
767 | size_t size = sizeof(**obj); |
768 | |
769 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
770 | if (err) { |
771 | goto out; |
772 | } |
773 | |
774 | for (tail = *obj; tail; |
775 | tail = (PciDeviceInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
776 | visit_type_PciDeviceInfo(v, NULL, &tail->value, &err); |
777 | if (err) { |
778 | break; |
779 | } |
780 | } |
781 | |
782 | if (!err) { |
783 | visit_check_list(v, &err); |
784 | } |
785 | visit_end_list(v, (void **)obj); |
786 | if (err && visit_is_input(v)) { |
787 | qapi_free_PciDeviceInfoList(*obj); |
788 | *obj = NULL; |
789 | } |
790 | out: |
791 | error_propagate(errp, err); |
792 | } |
793 | |
794 | void visit_type_PciBridgeInfo_members(Visitor *v, PciBridgeInfo *obj, Error **errp) |
795 | { |
796 | Error *err = NULL; |
797 | |
798 | visit_type_PciBusInfo(v, "bus" , &obj->bus, &err); |
799 | if (err) { |
800 | goto out; |
801 | } |
802 | if (visit_optional(v, "devices" , &obj->has_devices)) { |
803 | visit_type_PciDeviceInfoList(v, "devices" , &obj->devices, &err); |
804 | if (err) { |
805 | goto out; |
806 | } |
807 | } |
808 | |
809 | out: |
810 | error_propagate(errp, err); |
811 | } |
812 | |
813 | void visit_type_PciBridgeInfo(Visitor *v, const char *name, PciBridgeInfo **obj, Error **errp) |
814 | { |
815 | Error *err = NULL; |
816 | |
817 | visit_start_struct(v, name, (void **)obj, sizeof(PciBridgeInfo), &err); |
818 | if (err) { |
819 | goto out; |
820 | } |
821 | if (!*obj) { |
822 | goto out_obj; |
823 | } |
824 | visit_type_PciBridgeInfo_members(v, *obj, &err); |
825 | if (err) { |
826 | goto out_obj; |
827 | } |
828 | visit_check_struct(v, &err); |
829 | out_obj: |
830 | visit_end_struct(v, (void **)obj); |
831 | if (err && visit_is_input(v)) { |
832 | qapi_free_PciBridgeInfo(*obj); |
833 | *obj = NULL; |
834 | } |
835 | out: |
836 | error_propagate(errp, err); |
837 | } |
838 | |
839 | void visit_type_PciDeviceClass_members(Visitor *v, PciDeviceClass *obj, Error **errp) |
840 | { |
841 | Error *err = NULL; |
842 | |
843 | if (visit_optional(v, "desc" , &obj->has_desc)) { |
844 | visit_type_str(v, "desc" , &obj->desc, &err); |
845 | if (err) { |
846 | goto out; |
847 | } |
848 | } |
849 | visit_type_int(v, "class" , &obj->q_class, &err); |
850 | if (err) { |
851 | goto out; |
852 | } |
853 | |
854 | out: |
855 | error_propagate(errp, err); |
856 | } |
857 | |
858 | void visit_type_PciDeviceClass(Visitor *v, const char *name, PciDeviceClass **obj, Error **errp) |
859 | { |
860 | Error *err = NULL; |
861 | |
862 | visit_start_struct(v, name, (void **)obj, sizeof(PciDeviceClass), &err); |
863 | if (err) { |
864 | goto out; |
865 | } |
866 | if (!*obj) { |
867 | goto out_obj; |
868 | } |
869 | visit_type_PciDeviceClass_members(v, *obj, &err); |
870 | if (err) { |
871 | goto out_obj; |
872 | } |
873 | visit_check_struct(v, &err); |
874 | out_obj: |
875 | visit_end_struct(v, (void **)obj); |
876 | if (err && visit_is_input(v)) { |
877 | qapi_free_PciDeviceClass(*obj); |
878 | *obj = NULL; |
879 | } |
880 | out: |
881 | error_propagate(errp, err); |
882 | } |
883 | |
884 | void visit_type_PciDeviceId_members(Visitor *v, PciDeviceId *obj, Error **errp) |
885 | { |
886 | Error *err = NULL; |
887 | |
888 | visit_type_int(v, "device" , &obj->device, &err); |
889 | if (err) { |
890 | goto out; |
891 | } |
892 | visit_type_int(v, "vendor" , &obj->vendor, &err); |
893 | if (err) { |
894 | goto out; |
895 | } |
896 | if (visit_optional(v, "subsystem" , &obj->has_subsystem)) { |
897 | visit_type_int(v, "subsystem" , &obj->subsystem, &err); |
898 | if (err) { |
899 | goto out; |
900 | } |
901 | } |
902 | if (visit_optional(v, "subsystem-vendor" , &obj->has_subsystem_vendor)) { |
903 | visit_type_int(v, "subsystem-vendor" , &obj->subsystem_vendor, &err); |
904 | if (err) { |
905 | goto out; |
906 | } |
907 | } |
908 | |
909 | out: |
910 | error_propagate(errp, err); |
911 | } |
912 | |
913 | void visit_type_PciDeviceId(Visitor *v, const char *name, PciDeviceId **obj, Error **errp) |
914 | { |
915 | Error *err = NULL; |
916 | |
917 | visit_start_struct(v, name, (void **)obj, sizeof(PciDeviceId), &err); |
918 | if (err) { |
919 | goto out; |
920 | } |
921 | if (!*obj) { |
922 | goto out_obj; |
923 | } |
924 | visit_type_PciDeviceId_members(v, *obj, &err); |
925 | if (err) { |
926 | goto out_obj; |
927 | } |
928 | visit_check_struct(v, &err); |
929 | out_obj: |
930 | visit_end_struct(v, (void **)obj); |
931 | if (err && visit_is_input(v)) { |
932 | qapi_free_PciDeviceId(*obj); |
933 | *obj = NULL; |
934 | } |
935 | out: |
936 | error_propagate(errp, err); |
937 | } |
938 | |
939 | void visit_type_PciMemoryRegionList(Visitor *v, const char *name, PciMemoryRegionList **obj, Error **errp) |
940 | { |
941 | Error *err = NULL; |
942 | PciMemoryRegionList *tail; |
943 | size_t size = sizeof(**obj); |
944 | |
945 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
946 | if (err) { |
947 | goto out; |
948 | } |
949 | |
950 | for (tail = *obj; tail; |
951 | tail = (PciMemoryRegionList *)visit_next_list(v, (GenericList *)tail, size)) { |
952 | visit_type_PciMemoryRegion(v, NULL, &tail->value, &err); |
953 | if (err) { |
954 | break; |
955 | } |
956 | } |
957 | |
958 | if (!err) { |
959 | visit_check_list(v, &err); |
960 | } |
961 | visit_end_list(v, (void **)obj); |
962 | if (err && visit_is_input(v)) { |
963 | qapi_free_PciMemoryRegionList(*obj); |
964 | *obj = NULL; |
965 | } |
966 | out: |
967 | error_propagate(errp, err); |
968 | } |
969 | |
970 | void visit_type_PciDeviceInfo_members(Visitor *v, PciDeviceInfo *obj, Error **errp) |
971 | { |
972 | Error *err = NULL; |
973 | |
974 | visit_type_int(v, "bus" , &obj->bus, &err); |
975 | if (err) { |
976 | goto out; |
977 | } |
978 | visit_type_int(v, "slot" , &obj->slot, &err); |
979 | if (err) { |
980 | goto out; |
981 | } |
982 | visit_type_int(v, "function" , &obj->function, &err); |
983 | if (err) { |
984 | goto out; |
985 | } |
986 | visit_type_PciDeviceClass(v, "class_info" , &obj->class_info, &err); |
987 | if (err) { |
988 | goto out; |
989 | } |
990 | visit_type_PciDeviceId(v, "id" , &obj->id, &err); |
991 | if (err) { |
992 | goto out; |
993 | } |
994 | if (visit_optional(v, "irq" , &obj->has_irq)) { |
995 | visit_type_int(v, "irq" , &obj->irq, &err); |
996 | if (err) { |
997 | goto out; |
998 | } |
999 | } |
1000 | visit_type_str(v, "qdev_id" , &obj->qdev_id, &err); |
1001 | if (err) { |
1002 | goto out; |
1003 | } |
1004 | if (visit_optional(v, "pci_bridge" , &obj->has_pci_bridge)) { |
1005 | visit_type_PciBridgeInfo(v, "pci_bridge" , &obj->pci_bridge, &err); |
1006 | if (err) { |
1007 | goto out; |
1008 | } |
1009 | } |
1010 | visit_type_PciMemoryRegionList(v, "regions" , &obj->regions, &err); |
1011 | if (err) { |
1012 | goto out; |
1013 | } |
1014 | |
1015 | out: |
1016 | error_propagate(errp, err); |
1017 | } |
1018 | |
1019 | void visit_type_PciDeviceInfo(Visitor *v, const char *name, PciDeviceInfo **obj, Error **errp) |
1020 | { |
1021 | Error *err = NULL; |
1022 | |
1023 | visit_start_struct(v, name, (void **)obj, sizeof(PciDeviceInfo), &err); |
1024 | if (err) { |
1025 | goto out; |
1026 | } |
1027 | if (!*obj) { |
1028 | goto out_obj; |
1029 | } |
1030 | visit_type_PciDeviceInfo_members(v, *obj, &err); |
1031 | if (err) { |
1032 | goto out_obj; |
1033 | } |
1034 | visit_check_struct(v, &err); |
1035 | out_obj: |
1036 | visit_end_struct(v, (void **)obj); |
1037 | if (err && visit_is_input(v)) { |
1038 | qapi_free_PciDeviceInfo(*obj); |
1039 | *obj = NULL; |
1040 | } |
1041 | out: |
1042 | error_propagate(errp, err); |
1043 | } |
1044 | |
1045 | void visit_type_PciInfo_members(Visitor *v, PciInfo *obj, Error **errp) |
1046 | { |
1047 | Error *err = NULL; |
1048 | |
1049 | visit_type_int(v, "bus" , &obj->bus, &err); |
1050 | if (err) { |
1051 | goto out; |
1052 | } |
1053 | visit_type_PciDeviceInfoList(v, "devices" , &obj->devices, &err); |
1054 | if (err) { |
1055 | goto out; |
1056 | } |
1057 | |
1058 | out: |
1059 | error_propagate(errp, err); |
1060 | } |
1061 | |
1062 | void visit_type_PciInfo(Visitor *v, const char *name, PciInfo **obj, Error **errp) |
1063 | { |
1064 | Error *err = NULL; |
1065 | |
1066 | visit_start_struct(v, name, (void **)obj, sizeof(PciInfo), &err); |
1067 | if (err) { |
1068 | goto out; |
1069 | } |
1070 | if (!*obj) { |
1071 | goto out_obj; |
1072 | } |
1073 | visit_type_PciInfo_members(v, *obj, &err); |
1074 | if (err) { |
1075 | goto out_obj; |
1076 | } |
1077 | visit_check_struct(v, &err); |
1078 | out_obj: |
1079 | visit_end_struct(v, (void **)obj); |
1080 | if (err && visit_is_input(v)) { |
1081 | qapi_free_PciInfo(*obj); |
1082 | *obj = NULL; |
1083 | } |
1084 | out: |
1085 | error_propagate(errp, err); |
1086 | } |
1087 | |
1088 | void visit_type_PciInfoList(Visitor *v, const char *name, PciInfoList **obj, Error **errp) |
1089 | { |
1090 | Error *err = NULL; |
1091 | PciInfoList *tail; |
1092 | size_t size = sizeof(**obj); |
1093 | |
1094 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
1095 | if (err) { |
1096 | goto out; |
1097 | } |
1098 | |
1099 | for (tail = *obj; tail; |
1100 | tail = (PciInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
1101 | visit_type_PciInfo(v, NULL, &tail->value, &err); |
1102 | if (err) { |
1103 | break; |
1104 | } |
1105 | } |
1106 | |
1107 | if (!err) { |
1108 | visit_check_list(v, &err); |
1109 | } |
1110 | visit_end_list(v, (void **)obj); |
1111 | if (err && visit_is_input(v)) { |
1112 | qapi_free_PciInfoList(*obj); |
1113 | *obj = NULL; |
1114 | } |
1115 | out: |
1116 | error_propagate(errp, err); |
1117 | } |
1118 | |
1119 | void visit_type_q_obj_memsave_arg_members(Visitor *v, q_obj_memsave_arg *obj, Error **errp) |
1120 | { |
1121 | Error *err = NULL; |
1122 | |
1123 | visit_type_int(v, "val" , &obj->val, &err); |
1124 | if (err) { |
1125 | goto out; |
1126 | } |
1127 | visit_type_int(v, "size" , &obj->size, &err); |
1128 | if (err) { |
1129 | goto out; |
1130 | } |
1131 | visit_type_str(v, "filename" , &obj->filename, &err); |
1132 | if (err) { |
1133 | goto out; |
1134 | } |
1135 | if (visit_optional(v, "cpu-index" , &obj->has_cpu_index)) { |
1136 | visit_type_int(v, "cpu-index" , &obj->cpu_index, &err); |
1137 | if (err) { |
1138 | goto out; |
1139 | } |
1140 | } |
1141 | |
1142 | out: |
1143 | error_propagate(errp, err); |
1144 | } |
1145 | |
1146 | void visit_type_q_obj_pmemsave_arg_members(Visitor *v, q_obj_pmemsave_arg *obj, Error **errp) |
1147 | { |
1148 | Error *err = NULL; |
1149 | |
1150 | visit_type_int(v, "val" , &obj->val, &err); |
1151 | if (err) { |
1152 | goto out; |
1153 | } |
1154 | visit_type_int(v, "size" , &obj->size, &err); |
1155 | if (err) { |
1156 | goto out; |
1157 | } |
1158 | visit_type_str(v, "filename" , &obj->filename, &err); |
1159 | if (err) { |
1160 | goto out; |
1161 | } |
1162 | |
1163 | out: |
1164 | error_propagate(errp, err); |
1165 | } |
1166 | |
1167 | void visit_type_q_obj_balloon_arg_members(Visitor *v, q_obj_balloon_arg *obj, Error **errp) |
1168 | { |
1169 | Error *err = NULL; |
1170 | |
1171 | visit_type_int(v, "value" , &obj->value, &err); |
1172 | if (err) { |
1173 | goto out; |
1174 | } |
1175 | |
1176 | out: |
1177 | error_propagate(errp, err); |
1178 | } |
1179 | |
1180 | void visit_type_q_obj_human_monitor_command_arg_members(Visitor *v, q_obj_human_monitor_command_arg *obj, Error **errp) |
1181 | { |
1182 | Error *err = NULL; |
1183 | |
1184 | visit_type_str(v, "command-line" , &obj->command_line, &err); |
1185 | if (err) { |
1186 | goto out; |
1187 | } |
1188 | if (visit_optional(v, "cpu-index" , &obj->has_cpu_index)) { |
1189 | visit_type_int(v, "cpu-index" , &obj->cpu_index, &err); |
1190 | if (err) { |
1191 | goto out; |
1192 | } |
1193 | } |
1194 | |
1195 | out: |
1196 | error_propagate(errp, err); |
1197 | } |
1198 | |
1199 | void visit_type_q_obj_change_arg_members(Visitor *v, q_obj_change_arg *obj, Error **errp) |
1200 | { |
1201 | Error *err = NULL; |
1202 | |
1203 | visit_type_str(v, "device" , &obj->device, &err); |
1204 | if (err) { |
1205 | goto out; |
1206 | } |
1207 | visit_type_str(v, "target" , &obj->target, &err); |
1208 | if (err) { |
1209 | goto out; |
1210 | } |
1211 | if (visit_optional(v, "arg" , &obj->has_arg)) { |
1212 | visit_type_str(v, "arg" , &obj->arg, &err); |
1213 | if (err) { |
1214 | goto out; |
1215 | } |
1216 | } |
1217 | |
1218 | out: |
1219 | error_propagate(errp, err); |
1220 | } |
1221 | |
1222 | void visit_type_q_obj_xen_set_global_dirty_log_arg_members(Visitor *v, q_obj_xen_set_global_dirty_log_arg *obj, Error **errp) |
1223 | { |
1224 | Error *err = NULL; |
1225 | |
1226 | visit_type_bool(v, "enable" , &obj->enable, &err); |
1227 | if (err) { |
1228 | goto out; |
1229 | } |
1230 | |
1231 | out: |
1232 | error_propagate(errp, err); |
1233 | } |
1234 | |
1235 | void visit_type_q_obj_getfd_arg_members(Visitor *v, q_obj_getfd_arg *obj, Error **errp) |
1236 | { |
1237 | Error *err = NULL; |
1238 | |
1239 | visit_type_str(v, "fdname" , &obj->fdname, &err); |
1240 | if (err) { |
1241 | goto out; |
1242 | } |
1243 | |
1244 | out: |
1245 | error_propagate(errp, err); |
1246 | } |
1247 | |
1248 | void visit_type_q_obj_closefd_arg_members(Visitor *v, q_obj_closefd_arg *obj, Error **errp) |
1249 | { |
1250 | Error *err = NULL; |
1251 | |
1252 | visit_type_str(v, "fdname" , &obj->fdname, &err); |
1253 | if (err) { |
1254 | goto out; |
1255 | } |
1256 | |
1257 | out: |
1258 | error_propagate(errp, err); |
1259 | } |
1260 | |
1261 | void visit_type_MemoryInfo_members(Visitor *v, MemoryInfo *obj, Error **errp) |
1262 | { |
1263 | Error *err = NULL; |
1264 | |
1265 | visit_type_size(v, "base-memory" , &obj->base_memory, &err); |
1266 | if (err) { |
1267 | goto out; |
1268 | } |
1269 | if (visit_optional(v, "plugged-memory" , &obj->has_plugged_memory)) { |
1270 | visit_type_size(v, "plugged-memory" , &obj->plugged_memory, &err); |
1271 | if (err) { |
1272 | goto out; |
1273 | } |
1274 | } |
1275 | |
1276 | out: |
1277 | error_propagate(errp, err); |
1278 | } |
1279 | |
1280 | void visit_type_MemoryInfo(Visitor *v, const char *name, MemoryInfo **obj, Error **errp) |
1281 | { |
1282 | Error *err = NULL; |
1283 | |
1284 | visit_start_struct(v, name, (void **)obj, sizeof(MemoryInfo), &err); |
1285 | if (err) { |
1286 | goto out; |
1287 | } |
1288 | if (!*obj) { |
1289 | goto out_obj; |
1290 | } |
1291 | visit_type_MemoryInfo_members(v, *obj, &err); |
1292 | if (err) { |
1293 | goto out_obj; |
1294 | } |
1295 | visit_check_struct(v, &err); |
1296 | out_obj: |
1297 | visit_end_struct(v, (void **)obj); |
1298 | if (err && visit_is_input(v)) { |
1299 | qapi_free_MemoryInfo(*obj); |
1300 | *obj = NULL; |
1301 | } |
1302 | out: |
1303 | error_propagate(errp, err); |
1304 | } |
1305 | |
1306 | void visit_type_AddfdInfo_members(Visitor *v, AddfdInfo *obj, Error **errp) |
1307 | { |
1308 | Error *err = NULL; |
1309 | |
1310 | visit_type_int(v, "fdset-id" , &obj->fdset_id, &err); |
1311 | if (err) { |
1312 | goto out; |
1313 | } |
1314 | visit_type_int(v, "fd" , &obj->fd, &err); |
1315 | if (err) { |
1316 | goto out; |
1317 | } |
1318 | |
1319 | out: |
1320 | error_propagate(errp, err); |
1321 | } |
1322 | |
1323 | void visit_type_AddfdInfo(Visitor *v, const char *name, AddfdInfo **obj, Error **errp) |
1324 | { |
1325 | Error *err = NULL; |
1326 | |
1327 | visit_start_struct(v, name, (void **)obj, sizeof(AddfdInfo), &err); |
1328 | if (err) { |
1329 | goto out; |
1330 | } |
1331 | if (!*obj) { |
1332 | goto out_obj; |
1333 | } |
1334 | visit_type_AddfdInfo_members(v, *obj, &err); |
1335 | if (err) { |
1336 | goto out_obj; |
1337 | } |
1338 | visit_check_struct(v, &err); |
1339 | out_obj: |
1340 | visit_end_struct(v, (void **)obj); |
1341 | if (err && visit_is_input(v)) { |
1342 | qapi_free_AddfdInfo(*obj); |
1343 | *obj = NULL; |
1344 | } |
1345 | out: |
1346 | error_propagate(errp, err); |
1347 | } |
1348 | |
1349 | void visit_type_q_obj_add_fd_arg_members(Visitor *v, q_obj_add_fd_arg *obj, Error **errp) |
1350 | { |
1351 | Error *err = NULL; |
1352 | |
1353 | if (visit_optional(v, "fdset-id" , &obj->has_fdset_id)) { |
1354 | visit_type_int(v, "fdset-id" , &obj->fdset_id, &err); |
1355 | if (err) { |
1356 | goto out; |
1357 | } |
1358 | } |
1359 | if (visit_optional(v, "opaque" , &obj->has_opaque)) { |
1360 | visit_type_str(v, "opaque" , &obj->opaque, &err); |
1361 | if (err) { |
1362 | goto out; |
1363 | } |
1364 | } |
1365 | |
1366 | out: |
1367 | error_propagate(errp, err); |
1368 | } |
1369 | |
1370 | void visit_type_q_obj_remove_fd_arg_members(Visitor *v, q_obj_remove_fd_arg *obj, Error **errp) |
1371 | { |
1372 | Error *err = NULL; |
1373 | |
1374 | visit_type_int(v, "fdset-id" , &obj->fdset_id, &err); |
1375 | if (err) { |
1376 | goto out; |
1377 | } |
1378 | if (visit_optional(v, "fd" , &obj->has_fd)) { |
1379 | visit_type_int(v, "fd" , &obj->fd, &err); |
1380 | if (err) { |
1381 | goto out; |
1382 | } |
1383 | } |
1384 | |
1385 | out: |
1386 | error_propagate(errp, err); |
1387 | } |
1388 | |
1389 | void visit_type_FdsetFdInfo_members(Visitor *v, FdsetFdInfo *obj, Error **errp) |
1390 | { |
1391 | Error *err = NULL; |
1392 | |
1393 | visit_type_int(v, "fd" , &obj->fd, &err); |
1394 | if (err) { |
1395 | goto out; |
1396 | } |
1397 | if (visit_optional(v, "opaque" , &obj->has_opaque)) { |
1398 | visit_type_str(v, "opaque" , &obj->opaque, &err); |
1399 | if (err) { |
1400 | goto out; |
1401 | } |
1402 | } |
1403 | |
1404 | out: |
1405 | error_propagate(errp, err); |
1406 | } |
1407 | |
1408 | void visit_type_FdsetFdInfo(Visitor *v, const char *name, FdsetFdInfo **obj, Error **errp) |
1409 | { |
1410 | Error *err = NULL; |
1411 | |
1412 | visit_start_struct(v, name, (void **)obj, sizeof(FdsetFdInfo), &err); |
1413 | if (err) { |
1414 | goto out; |
1415 | } |
1416 | if (!*obj) { |
1417 | goto out_obj; |
1418 | } |
1419 | visit_type_FdsetFdInfo_members(v, *obj, &err); |
1420 | if (err) { |
1421 | goto out_obj; |
1422 | } |
1423 | visit_check_struct(v, &err); |
1424 | out_obj: |
1425 | visit_end_struct(v, (void **)obj); |
1426 | if (err && visit_is_input(v)) { |
1427 | qapi_free_FdsetFdInfo(*obj); |
1428 | *obj = NULL; |
1429 | } |
1430 | out: |
1431 | error_propagate(errp, err); |
1432 | } |
1433 | |
1434 | void visit_type_FdsetFdInfoList(Visitor *v, const char *name, FdsetFdInfoList **obj, Error **errp) |
1435 | { |
1436 | Error *err = NULL; |
1437 | FdsetFdInfoList *tail; |
1438 | size_t size = sizeof(**obj); |
1439 | |
1440 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
1441 | if (err) { |
1442 | goto out; |
1443 | } |
1444 | |
1445 | for (tail = *obj; tail; |
1446 | tail = (FdsetFdInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
1447 | visit_type_FdsetFdInfo(v, NULL, &tail->value, &err); |
1448 | if (err) { |
1449 | break; |
1450 | } |
1451 | } |
1452 | |
1453 | if (!err) { |
1454 | visit_check_list(v, &err); |
1455 | } |
1456 | visit_end_list(v, (void **)obj); |
1457 | if (err && visit_is_input(v)) { |
1458 | qapi_free_FdsetFdInfoList(*obj); |
1459 | *obj = NULL; |
1460 | } |
1461 | out: |
1462 | error_propagate(errp, err); |
1463 | } |
1464 | |
1465 | void visit_type_FdsetInfo_members(Visitor *v, FdsetInfo *obj, Error **errp) |
1466 | { |
1467 | Error *err = NULL; |
1468 | |
1469 | visit_type_int(v, "fdset-id" , &obj->fdset_id, &err); |
1470 | if (err) { |
1471 | goto out; |
1472 | } |
1473 | visit_type_FdsetFdInfoList(v, "fds" , &obj->fds, &err); |
1474 | if (err) { |
1475 | goto out; |
1476 | } |
1477 | |
1478 | out: |
1479 | error_propagate(errp, err); |
1480 | } |
1481 | |
1482 | void visit_type_FdsetInfo(Visitor *v, const char *name, FdsetInfo **obj, Error **errp) |
1483 | { |
1484 | Error *err = NULL; |
1485 | |
1486 | visit_start_struct(v, name, (void **)obj, sizeof(FdsetInfo), &err); |
1487 | if (err) { |
1488 | goto out; |
1489 | } |
1490 | if (!*obj) { |
1491 | goto out_obj; |
1492 | } |
1493 | visit_type_FdsetInfo_members(v, *obj, &err); |
1494 | if (err) { |
1495 | goto out_obj; |
1496 | } |
1497 | visit_check_struct(v, &err); |
1498 | out_obj: |
1499 | visit_end_struct(v, (void **)obj); |
1500 | if (err && visit_is_input(v)) { |
1501 | qapi_free_FdsetInfo(*obj); |
1502 | *obj = NULL; |
1503 | } |
1504 | out: |
1505 | error_propagate(errp, err); |
1506 | } |
1507 | |
1508 | void visit_type_FdsetInfoList(Visitor *v, const char *name, FdsetInfoList **obj, Error **errp) |
1509 | { |
1510 | Error *err = NULL; |
1511 | FdsetInfoList *tail; |
1512 | size_t size = sizeof(**obj); |
1513 | |
1514 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
1515 | if (err) { |
1516 | goto out; |
1517 | } |
1518 | |
1519 | for (tail = *obj; tail; |
1520 | tail = (FdsetInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
1521 | visit_type_FdsetInfo(v, NULL, &tail->value, &err); |
1522 | if (err) { |
1523 | break; |
1524 | } |
1525 | } |
1526 | |
1527 | if (!err) { |
1528 | visit_check_list(v, &err); |
1529 | } |
1530 | visit_end_list(v, (void **)obj); |
1531 | if (err && visit_is_input(v)) { |
1532 | qapi_free_FdsetInfoList(*obj); |
1533 | *obj = NULL; |
1534 | } |
1535 | out: |
1536 | error_propagate(errp, err); |
1537 | } |
1538 | |
1539 | void visit_type_AcpiTableOptions_members(Visitor *v, AcpiTableOptions *obj, Error **errp) |
1540 | { |
1541 | Error *err = NULL; |
1542 | |
1543 | if (visit_optional(v, "sig" , &obj->has_sig)) { |
1544 | visit_type_str(v, "sig" , &obj->sig, &err); |
1545 | if (err) { |
1546 | goto out; |
1547 | } |
1548 | } |
1549 | if (visit_optional(v, "rev" , &obj->has_rev)) { |
1550 | visit_type_uint8(v, "rev" , &obj->rev, &err); |
1551 | if (err) { |
1552 | goto out; |
1553 | } |
1554 | } |
1555 | if (visit_optional(v, "oem_id" , &obj->has_oem_id)) { |
1556 | visit_type_str(v, "oem_id" , &obj->oem_id, &err); |
1557 | if (err) { |
1558 | goto out; |
1559 | } |
1560 | } |
1561 | if (visit_optional(v, "oem_table_id" , &obj->has_oem_table_id)) { |
1562 | visit_type_str(v, "oem_table_id" , &obj->oem_table_id, &err); |
1563 | if (err) { |
1564 | goto out; |
1565 | } |
1566 | } |
1567 | if (visit_optional(v, "oem_rev" , &obj->has_oem_rev)) { |
1568 | visit_type_uint32(v, "oem_rev" , &obj->oem_rev, &err); |
1569 | if (err) { |
1570 | goto out; |
1571 | } |
1572 | } |
1573 | if (visit_optional(v, "asl_compiler_id" , &obj->has_asl_compiler_id)) { |
1574 | visit_type_str(v, "asl_compiler_id" , &obj->asl_compiler_id, &err); |
1575 | if (err) { |
1576 | goto out; |
1577 | } |
1578 | } |
1579 | if (visit_optional(v, "asl_compiler_rev" , &obj->has_asl_compiler_rev)) { |
1580 | visit_type_uint32(v, "asl_compiler_rev" , &obj->asl_compiler_rev, &err); |
1581 | if (err) { |
1582 | goto out; |
1583 | } |
1584 | } |
1585 | if (visit_optional(v, "file" , &obj->has_file)) { |
1586 | visit_type_str(v, "file" , &obj->file, &err); |
1587 | if (err) { |
1588 | goto out; |
1589 | } |
1590 | } |
1591 | if (visit_optional(v, "data" , &obj->has_data)) { |
1592 | visit_type_str(v, "data" , &obj->data, &err); |
1593 | if (err) { |
1594 | goto out; |
1595 | } |
1596 | } |
1597 | |
1598 | out: |
1599 | error_propagate(errp, err); |
1600 | } |
1601 | |
1602 | void visit_type_AcpiTableOptions(Visitor *v, const char *name, AcpiTableOptions **obj, Error **errp) |
1603 | { |
1604 | Error *err = NULL; |
1605 | |
1606 | visit_start_struct(v, name, (void **)obj, sizeof(AcpiTableOptions), &err); |
1607 | if (err) { |
1608 | goto out; |
1609 | } |
1610 | if (!*obj) { |
1611 | goto out_obj; |
1612 | } |
1613 | visit_type_AcpiTableOptions_members(v, *obj, &err); |
1614 | if (err) { |
1615 | goto out_obj; |
1616 | } |
1617 | visit_check_struct(v, &err); |
1618 | out_obj: |
1619 | visit_end_struct(v, (void **)obj); |
1620 | if (err && visit_is_input(v)) { |
1621 | qapi_free_AcpiTableOptions(*obj); |
1622 | *obj = NULL; |
1623 | } |
1624 | out: |
1625 | error_propagate(errp, err); |
1626 | } |
1627 | |
1628 | void visit_type_CommandLineParameterType(Visitor *v, const char *name, CommandLineParameterType *obj, Error **errp) |
1629 | { |
1630 | int value = *obj; |
1631 | visit_type_enum(v, name, &value, &CommandLineParameterType_lookup, errp); |
1632 | *obj = value; |
1633 | } |
1634 | |
1635 | void visit_type_CommandLineParameterInfo_members(Visitor *v, CommandLineParameterInfo *obj, Error **errp) |
1636 | { |
1637 | Error *err = NULL; |
1638 | |
1639 | visit_type_str(v, "name" , &obj->name, &err); |
1640 | if (err) { |
1641 | goto out; |
1642 | } |
1643 | visit_type_CommandLineParameterType(v, "type" , &obj->type, &err); |
1644 | if (err) { |
1645 | goto out; |
1646 | } |
1647 | if (visit_optional(v, "help" , &obj->has_help)) { |
1648 | visit_type_str(v, "help" , &obj->help, &err); |
1649 | if (err) { |
1650 | goto out; |
1651 | } |
1652 | } |
1653 | if (visit_optional(v, "default" , &obj->has_q_default)) { |
1654 | visit_type_str(v, "default" , &obj->q_default, &err); |
1655 | if (err) { |
1656 | goto out; |
1657 | } |
1658 | } |
1659 | |
1660 | out: |
1661 | error_propagate(errp, err); |
1662 | } |
1663 | |
1664 | void visit_type_CommandLineParameterInfo(Visitor *v, const char *name, CommandLineParameterInfo **obj, Error **errp) |
1665 | { |
1666 | Error *err = NULL; |
1667 | |
1668 | visit_start_struct(v, name, (void **)obj, sizeof(CommandLineParameterInfo), &err); |
1669 | if (err) { |
1670 | goto out; |
1671 | } |
1672 | if (!*obj) { |
1673 | goto out_obj; |
1674 | } |
1675 | visit_type_CommandLineParameterInfo_members(v, *obj, &err); |
1676 | if (err) { |
1677 | goto out_obj; |
1678 | } |
1679 | visit_check_struct(v, &err); |
1680 | out_obj: |
1681 | visit_end_struct(v, (void **)obj); |
1682 | if (err && visit_is_input(v)) { |
1683 | qapi_free_CommandLineParameterInfo(*obj); |
1684 | *obj = NULL; |
1685 | } |
1686 | out: |
1687 | error_propagate(errp, err); |
1688 | } |
1689 | |
1690 | void visit_type_CommandLineParameterInfoList(Visitor *v, const char *name, CommandLineParameterInfoList **obj, Error **errp) |
1691 | { |
1692 | Error *err = NULL; |
1693 | CommandLineParameterInfoList *tail; |
1694 | size_t size = sizeof(**obj); |
1695 | |
1696 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
1697 | if (err) { |
1698 | goto out; |
1699 | } |
1700 | |
1701 | for (tail = *obj; tail; |
1702 | tail = (CommandLineParameterInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
1703 | visit_type_CommandLineParameterInfo(v, NULL, &tail->value, &err); |
1704 | if (err) { |
1705 | break; |
1706 | } |
1707 | } |
1708 | |
1709 | if (!err) { |
1710 | visit_check_list(v, &err); |
1711 | } |
1712 | visit_end_list(v, (void **)obj); |
1713 | if (err && visit_is_input(v)) { |
1714 | qapi_free_CommandLineParameterInfoList(*obj); |
1715 | *obj = NULL; |
1716 | } |
1717 | out: |
1718 | error_propagate(errp, err); |
1719 | } |
1720 | |
1721 | void visit_type_CommandLineOptionInfo_members(Visitor *v, CommandLineOptionInfo *obj, Error **errp) |
1722 | { |
1723 | Error *err = NULL; |
1724 | |
1725 | visit_type_str(v, "option" , &obj->option, &err); |
1726 | if (err) { |
1727 | goto out; |
1728 | } |
1729 | visit_type_CommandLineParameterInfoList(v, "parameters" , &obj->parameters, &err); |
1730 | if (err) { |
1731 | goto out; |
1732 | } |
1733 | |
1734 | out: |
1735 | error_propagate(errp, err); |
1736 | } |
1737 | |
1738 | void visit_type_CommandLineOptionInfo(Visitor *v, const char *name, CommandLineOptionInfo **obj, Error **errp) |
1739 | { |
1740 | Error *err = NULL; |
1741 | |
1742 | visit_start_struct(v, name, (void **)obj, sizeof(CommandLineOptionInfo), &err); |
1743 | if (err) { |
1744 | goto out; |
1745 | } |
1746 | if (!*obj) { |
1747 | goto out_obj; |
1748 | } |
1749 | visit_type_CommandLineOptionInfo_members(v, *obj, &err); |
1750 | if (err) { |
1751 | goto out_obj; |
1752 | } |
1753 | visit_check_struct(v, &err); |
1754 | out_obj: |
1755 | visit_end_struct(v, (void **)obj); |
1756 | if (err && visit_is_input(v)) { |
1757 | qapi_free_CommandLineOptionInfo(*obj); |
1758 | *obj = NULL; |
1759 | } |
1760 | out: |
1761 | error_propagate(errp, err); |
1762 | } |
1763 | |
1764 | void visit_type_q_obj_query_command_line_options_arg_members(Visitor *v, q_obj_query_command_line_options_arg *obj, Error **errp) |
1765 | { |
1766 | Error *err = NULL; |
1767 | |
1768 | if (visit_optional(v, "option" , &obj->has_option)) { |
1769 | visit_type_str(v, "option" , &obj->option, &err); |
1770 | if (err) { |
1771 | goto out; |
1772 | } |
1773 | } |
1774 | |
1775 | out: |
1776 | error_propagate(errp, err); |
1777 | } |
1778 | |
1779 | void visit_type_CommandLineOptionInfoList(Visitor *v, const char *name, CommandLineOptionInfoList **obj, Error **errp) |
1780 | { |
1781 | Error *err = NULL; |
1782 | CommandLineOptionInfoList *tail; |
1783 | size_t size = sizeof(**obj); |
1784 | |
1785 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
1786 | if (err) { |
1787 | goto out; |
1788 | } |
1789 | |
1790 | for (tail = *obj; tail; |
1791 | tail = (CommandLineOptionInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
1792 | visit_type_CommandLineOptionInfo(v, NULL, &tail->value, &err); |
1793 | if (err) { |
1794 | break; |
1795 | } |
1796 | } |
1797 | |
1798 | if (!err) { |
1799 | visit_check_list(v, &err); |
1800 | } |
1801 | visit_end_list(v, (void **)obj); |
1802 | if (err && visit_is_input(v)) { |
1803 | qapi_free_CommandLineOptionInfoList(*obj); |
1804 | *obj = NULL; |
1805 | } |
1806 | out: |
1807 | error_propagate(errp, err); |
1808 | } |
1809 | |
1810 | void visit_type_PCDIMMDeviceInfo_members(Visitor *v, PCDIMMDeviceInfo *obj, Error **errp) |
1811 | { |
1812 | Error *err = NULL; |
1813 | |
1814 | if (visit_optional(v, "id" , &obj->has_id)) { |
1815 | visit_type_str(v, "id" , &obj->id, &err); |
1816 | if (err) { |
1817 | goto out; |
1818 | } |
1819 | } |
1820 | visit_type_int(v, "addr" , &obj->addr, &err); |
1821 | if (err) { |
1822 | goto out; |
1823 | } |
1824 | visit_type_int(v, "size" , &obj->size, &err); |
1825 | if (err) { |
1826 | goto out; |
1827 | } |
1828 | visit_type_int(v, "slot" , &obj->slot, &err); |
1829 | if (err) { |
1830 | goto out; |
1831 | } |
1832 | visit_type_int(v, "node" , &obj->node, &err); |
1833 | if (err) { |
1834 | goto out; |
1835 | } |
1836 | visit_type_str(v, "memdev" , &obj->memdev, &err); |
1837 | if (err) { |
1838 | goto out; |
1839 | } |
1840 | visit_type_bool(v, "hotplugged" , &obj->hotplugged, &err); |
1841 | if (err) { |
1842 | goto out; |
1843 | } |
1844 | visit_type_bool(v, "hotpluggable" , &obj->hotpluggable, &err); |
1845 | if (err) { |
1846 | goto out; |
1847 | } |
1848 | |
1849 | out: |
1850 | error_propagate(errp, err); |
1851 | } |
1852 | |
1853 | void visit_type_PCDIMMDeviceInfo(Visitor *v, const char *name, PCDIMMDeviceInfo **obj, Error **errp) |
1854 | { |
1855 | Error *err = NULL; |
1856 | |
1857 | visit_start_struct(v, name, (void **)obj, sizeof(PCDIMMDeviceInfo), &err); |
1858 | if (err) { |
1859 | goto out; |
1860 | } |
1861 | if (!*obj) { |
1862 | goto out_obj; |
1863 | } |
1864 | visit_type_PCDIMMDeviceInfo_members(v, *obj, &err); |
1865 | if (err) { |
1866 | goto out_obj; |
1867 | } |
1868 | visit_check_struct(v, &err); |
1869 | out_obj: |
1870 | visit_end_struct(v, (void **)obj); |
1871 | if (err && visit_is_input(v)) { |
1872 | qapi_free_PCDIMMDeviceInfo(*obj); |
1873 | *obj = NULL; |
1874 | } |
1875 | out: |
1876 | error_propagate(errp, err); |
1877 | } |
1878 | |
1879 | void visit_type_VirtioPMEMDeviceInfo_members(Visitor *v, VirtioPMEMDeviceInfo *obj, Error **errp) |
1880 | { |
1881 | Error *err = NULL; |
1882 | |
1883 | if (visit_optional(v, "id" , &obj->has_id)) { |
1884 | visit_type_str(v, "id" , &obj->id, &err); |
1885 | if (err) { |
1886 | goto out; |
1887 | } |
1888 | } |
1889 | visit_type_size(v, "memaddr" , &obj->memaddr, &err); |
1890 | if (err) { |
1891 | goto out; |
1892 | } |
1893 | visit_type_size(v, "size" , &obj->size, &err); |
1894 | if (err) { |
1895 | goto out; |
1896 | } |
1897 | visit_type_str(v, "memdev" , &obj->memdev, &err); |
1898 | if (err) { |
1899 | goto out; |
1900 | } |
1901 | |
1902 | out: |
1903 | error_propagate(errp, err); |
1904 | } |
1905 | |
1906 | void visit_type_VirtioPMEMDeviceInfo(Visitor *v, const char *name, VirtioPMEMDeviceInfo **obj, Error **errp) |
1907 | { |
1908 | Error *err = NULL; |
1909 | |
1910 | visit_start_struct(v, name, (void **)obj, sizeof(VirtioPMEMDeviceInfo), &err); |
1911 | if (err) { |
1912 | goto out; |
1913 | } |
1914 | if (!*obj) { |
1915 | goto out_obj; |
1916 | } |
1917 | visit_type_VirtioPMEMDeviceInfo_members(v, *obj, &err); |
1918 | if (err) { |
1919 | goto out_obj; |
1920 | } |
1921 | visit_check_struct(v, &err); |
1922 | out_obj: |
1923 | visit_end_struct(v, (void **)obj); |
1924 | if (err && visit_is_input(v)) { |
1925 | qapi_free_VirtioPMEMDeviceInfo(*obj); |
1926 | *obj = NULL; |
1927 | } |
1928 | out: |
1929 | error_propagate(errp, err); |
1930 | } |
1931 | |
1932 | void visit_type_q_obj_PCDIMMDeviceInfo_wrapper_members(Visitor *v, q_obj_PCDIMMDeviceInfo_wrapper *obj, Error **errp) |
1933 | { |
1934 | Error *err = NULL; |
1935 | |
1936 | visit_type_PCDIMMDeviceInfo(v, "data" , &obj->data, &err); |
1937 | if (err) { |
1938 | goto out; |
1939 | } |
1940 | |
1941 | out: |
1942 | error_propagate(errp, err); |
1943 | } |
1944 | |
1945 | void visit_type_q_obj_VirtioPMEMDeviceInfo_wrapper_members(Visitor *v, q_obj_VirtioPMEMDeviceInfo_wrapper *obj, Error **errp) |
1946 | { |
1947 | Error *err = NULL; |
1948 | |
1949 | visit_type_VirtioPMEMDeviceInfo(v, "data" , &obj->data, &err); |
1950 | if (err) { |
1951 | goto out; |
1952 | } |
1953 | |
1954 | out: |
1955 | error_propagate(errp, err); |
1956 | } |
1957 | |
1958 | void visit_type_MemoryDeviceInfoKind(Visitor *v, const char *name, MemoryDeviceInfoKind *obj, Error **errp) |
1959 | { |
1960 | int value = *obj; |
1961 | visit_type_enum(v, name, &value, &MemoryDeviceInfoKind_lookup, errp); |
1962 | *obj = value; |
1963 | } |
1964 | |
1965 | void visit_type_MemoryDeviceInfo_members(Visitor *v, MemoryDeviceInfo *obj, Error **errp) |
1966 | { |
1967 | Error *err = NULL; |
1968 | |
1969 | visit_type_MemoryDeviceInfoKind(v, "type" , &obj->type, &err); |
1970 | if (err) { |
1971 | goto out; |
1972 | } |
1973 | switch (obj->type) { |
1974 | case MEMORY_DEVICE_INFO_KIND_DIMM: |
1975 | visit_type_q_obj_PCDIMMDeviceInfo_wrapper_members(v, &obj->u.dimm, &err); |
1976 | break; |
1977 | case MEMORY_DEVICE_INFO_KIND_NVDIMM: |
1978 | visit_type_q_obj_PCDIMMDeviceInfo_wrapper_members(v, &obj->u.nvdimm, &err); |
1979 | break; |
1980 | case MEMORY_DEVICE_INFO_KIND_VIRTIO_PMEM: |
1981 | visit_type_q_obj_VirtioPMEMDeviceInfo_wrapper_members(v, &obj->u.virtio_pmem, &err); |
1982 | break; |
1983 | default: |
1984 | abort(); |
1985 | } |
1986 | |
1987 | out: |
1988 | error_propagate(errp, err); |
1989 | } |
1990 | |
1991 | void visit_type_MemoryDeviceInfo(Visitor *v, const char *name, MemoryDeviceInfo **obj, Error **errp) |
1992 | { |
1993 | Error *err = NULL; |
1994 | |
1995 | visit_start_struct(v, name, (void **)obj, sizeof(MemoryDeviceInfo), &err); |
1996 | if (err) { |
1997 | goto out; |
1998 | } |
1999 | if (!*obj) { |
2000 | goto out_obj; |
2001 | } |
2002 | visit_type_MemoryDeviceInfo_members(v, *obj, &err); |
2003 | if (err) { |
2004 | goto out_obj; |
2005 | } |
2006 | visit_check_struct(v, &err); |
2007 | out_obj: |
2008 | visit_end_struct(v, (void **)obj); |
2009 | if (err && visit_is_input(v)) { |
2010 | qapi_free_MemoryDeviceInfo(*obj); |
2011 | *obj = NULL; |
2012 | } |
2013 | out: |
2014 | error_propagate(errp, err); |
2015 | } |
2016 | |
2017 | void visit_type_MemoryDeviceInfoList(Visitor *v, const char *name, MemoryDeviceInfoList **obj, Error **errp) |
2018 | { |
2019 | Error *err = NULL; |
2020 | MemoryDeviceInfoList *tail; |
2021 | size_t size = sizeof(**obj); |
2022 | |
2023 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
2024 | if (err) { |
2025 | goto out; |
2026 | } |
2027 | |
2028 | for (tail = *obj; tail; |
2029 | tail = (MemoryDeviceInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
2030 | visit_type_MemoryDeviceInfo(v, NULL, &tail->value, &err); |
2031 | if (err) { |
2032 | break; |
2033 | } |
2034 | } |
2035 | |
2036 | if (!err) { |
2037 | visit_check_list(v, &err); |
2038 | } |
2039 | visit_end_list(v, (void **)obj); |
2040 | if (err && visit_is_input(v)) { |
2041 | qapi_free_MemoryDeviceInfoList(*obj); |
2042 | *obj = NULL; |
2043 | } |
2044 | out: |
2045 | error_propagate(errp, err); |
2046 | } |
2047 | |
2048 | void visit_type_q_obj_MEM_UNPLUG_ERROR_arg_members(Visitor *v, q_obj_MEM_UNPLUG_ERROR_arg *obj, Error **errp) |
2049 | { |
2050 | Error *err = NULL; |
2051 | |
2052 | visit_type_str(v, "device" , &obj->device, &err); |
2053 | if (err) { |
2054 | goto out; |
2055 | } |
2056 | visit_type_str(v, "msg" , &obj->msg, &err); |
2057 | if (err) { |
2058 | goto out; |
2059 | } |
2060 | |
2061 | out: |
2062 | error_propagate(errp, err); |
2063 | } |
2064 | |
2065 | void visit_type_ACPISlotType(Visitor *v, const char *name, ACPISlotType *obj, Error **errp) |
2066 | { |
2067 | int value = *obj; |
2068 | visit_type_enum(v, name, &value, &ACPISlotType_lookup, errp); |
2069 | *obj = value; |
2070 | } |
2071 | |
2072 | void visit_type_ACPIOSTInfo_members(Visitor *v, ACPIOSTInfo *obj, Error **errp) |
2073 | { |
2074 | Error *err = NULL; |
2075 | |
2076 | if (visit_optional(v, "device" , &obj->has_device)) { |
2077 | visit_type_str(v, "device" , &obj->device, &err); |
2078 | if (err) { |
2079 | goto out; |
2080 | } |
2081 | } |
2082 | visit_type_str(v, "slot" , &obj->slot, &err); |
2083 | if (err) { |
2084 | goto out; |
2085 | } |
2086 | visit_type_ACPISlotType(v, "slot-type" , &obj->slot_type, &err); |
2087 | if (err) { |
2088 | goto out; |
2089 | } |
2090 | visit_type_int(v, "source" , &obj->source, &err); |
2091 | if (err) { |
2092 | goto out; |
2093 | } |
2094 | visit_type_int(v, "status" , &obj->status, &err); |
2095 | if (err) { |
2096 | goto out; |
2097 | } |
2098 | |
2099 | out: |
2100 | error_propagate(errp, err); |
2101 | } |
2102 | |
2103 | void visit_type_ACPIOSTInfo(Visitor *v, const char *name, ACPIOSTInfo **obj, Error **errp) |
2104 | { |
2105 | Error *err = NULL; |
2106 | |
2107 | visit_start_struct(v, name, (void **)obj, sizeof(ACPIOSTInfo), &err); |
2108 | if (err) { |
2109 | goto out; |
2110 | } |
2111 | if (!*obj) { |
2112 | goto out_obj; |
2113 | } |
2114 | visit_type_ACPIOSTInfo_members(v, *obj, &err); |
2115 | if (err) { |
2116 | goto out_obj; |
2117 | } |
2118 | visit_check_struct(v, &err); |
2119 | out_obj: |
2120 | visit_end_struct(v, (void **)obj); |
2121 | if (err && visit_is_input(v)) { |
2122 | qapi_free_ACPIOSTInfo(*obj); |
2123 | *obj = NULL; |
2124 | } |
2125 | out: |
2126 | error_propagate(errp, err); |
2127 | } |
2128 | |
2129 | void visit_type_ACPIOSTInfoList(Visitor *v, const char *name, ACPIOSTInfoList **obj, Error **errp) |
2130 | { |
2131 | Error *err = NULL; |
2132 | ACPIOSTInfoList *tail; |
2133 | size_t size = sizeof(**obj); |
2134 | |
2135 | visit_start_list(v, name, (GenericList **)obj, size, &err); |
2136 | if (err) { |
2137 | goto out; |
2138 | } |
2139 | |
2140 | for (tail = *obj; tail; |
2141 | tail = (ACPIOSTInfoList *)visit_next_list(v, (GenericList *)tail, size)) { |
2142 | visit_type_ACPIOSTInfo(v, NULL, &tail->value, &err); |
2143 | if (err) { |
2144 | break; |
2145 | } |
2146 | } |
2147 | |
2148 | if (!err) { |
2149 | visit_check_list(v, &err); |
2150 | } |
2151 | visit_end_list(v, (void **)obj); |
2152 | if (err && visit_is_input(v)) { |
2153 | qapi_free_ACPIOSTInfoList(*obj); |
2154 | *obj = NULL; |
2155 | } |
2156 | out: |
2157 | error_propagate(errp, err); |
2158 | } |
2159 | |
2160 | void visit_type_q_obj_ACPI_DEVICE_OST_arg_members(Visitor *v, q_obj_ACPI_DEVICE_OST_arg *obj, Error **errp) |
2161 | { |
2162 | Error *err = NULL; |
2163 | |
2164 | visit_type_ACPIOSTInfo(v, "info" , &obj->info, &err); |
2165 | if (err) { |
2166 | goto out; |
2167 | } |
2168 | |
2169 | out: |
2170 | error_propagate(errp, err); |
2171 | } |
2172 | |
2173 | void visit_type_ReplayMode(Visitor *v, const char *name, ReplayMode *obj, Error **errp) |
2174 | { |
2175 | int value = *obj; |
2176 | visit_type_enum(v, name, &value, &ReplayMode_lookup, errp); |
2177 | *obj = value; |
2178 | } |
2179 | |
2180 | void visit_type_q_obj_xen_load_devices_state_arg_members(Visitor *v, q_obj_xen_load_devices_state_arg *obj, Error **errp) |
2181 | { |
2182 | Error *err = NULL; |
2183 | |
2184 | visit_type_str(v, "filename" , &obj->filename, &err); |
2185 | if (err) { |
2186 | goto out; |
2187 | } |
2188 | |
2189 | out: |
2190 | error_propagate(errp, err); |
2191 | } |
2192 | |
2193 | void visit_type_GuidInfo_members(Visitor *v, GuidInfo *obj, Error **errp) |
2194 | { |
2195 | Error *err = NULL; |
2196 | |
2197 | visit_type_str(v, "guid" , &obj->guid, &err); |
2198 | if (err) { |
2199 | goto out; |
2200 | } |
2201 | |
2202 | out: |
2203 | error_propagate(errp, err); |
2204 | } |
2205 | |
2206 | void visit_type_GuidInfo(Visitor *v, const char *name, GuidInfo **obj, Error **errp) |
2207 | { |
2208 | Error *err = NULL; |
2209 | |
2210 | visit_start_struct(v, name, (void **)obj, sizeof(GuidInfo), &err); |
2211 | if (err) { |
2212 | goto out; |
2213 | } |
2214 | if (!*obj) { |
2215 | goto out_obj; |
2216 | } |
2217 | visit_type_GuidInfo_members(v, *obj, &err); |
2218 | if (err) { |
2219 | goto out_obj; |
2220 | } |
2221 | visit_check_struct(v, &err); |
2222 | out_obj: |
2223 | visit_end_struct(v, (void **)obj); |
2224 | if (err && visit_is_input(v)) { |
2225 | qapi_free_GuidInfo(*obj); |
2226 | *obj = NULL; |
2227 | } |
2228 | out: |
2229 | error_propagate(errp, err); |
2230 | } |
2231 | |
2232 | /* Dummy declaration to prevent empty .o file */ |
2233 | char qapi_dummy_qapi_visit_misc_c; |
2234 | |