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
18void 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 }
45out:
46 error_propagate(errp, err);
47}
48
49void 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
60out:
61 error_propagate(errp, err);
62}
63
64void 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
71void 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
88out:
89 error_propagate(errp, err);
90}
91
92void 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);
108out_obj:
109 visit_end_struct(v, (void **)obj);
110 if (err && visit_is_input(v)) {
111 qapi_free_VersionTriple(*obj);
112 *obj = NULL;
113 }
114out:
115 error_propagate(errp, err);
116}
117
118void 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
131out:
132 error_propagate(errp, err);
133}
134
135void 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);
151out_obj:
152 visit_end_struct(v, (void **)obj);
153 if (err && visit_is_input(v)) {
154 qapi_free_VersionInfo(*obj);
155 *obj = NULL;
156 }
157out:
158 error_propagate(errp, err);
159}
160
161void 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
170out:
171 error_propagate(errp, err);
172}
173
174void 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);
190out_obj:
191 visit_end_struct(v, (void **)obj);
192 if (err && visit_is_input(v)) {
193 qapi_free_CommandInfo(*obj);
194 *obj = NULL;
195 }
196out:
197 error_propagate(errp, err);
198}
199
200void 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 }
227out:
228 error_propagate(errp, err);
229}
230
231void 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
238void 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
263out:
264 error_propagate(errp, err);
265}
266
267void 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
278out:
279 error_propagate(errp, err);
280}
281
282void 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);
298out_obj:
299 visit_end_struct(v, (void **)obj);
300 if (err && visit_is_input(v)) {
301 qapi_free_NameInfo(*obj);
302 *obj = NULL;
303 }
304out:
305 error_propagate(errp, err);
306}
307
308void 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
321out:
322 error_propagate(errp, err);
323}
324
325void 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);
341out_obj:
342 visit_end_struct(v, (void **)obj);
343 if (err && visit_is_input(v)) {
344 qapi_free_KvmInfo(*obj);
345 *obj = NULL;
346 }
347out:
348 error_propagate(errp, err);
349}
350
351void 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
360out:
361 error_propagate(errp, err);
362}
363
364void 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);
380out_obj:
381 visit_end_struct(v, (void **)obj);
382 if (err && visit_is_input(v)) {
383 qapi_free_UuidInfo(*obj);
384 *obj = NULL;
385 }
386out:
387 error_propagate(errp, err);
388}
389
390void 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
399out:
400 error_propagate(errp, err);
401}
402
403void 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);
419out_obj:
420 visit_end_struct(v, (void **)obj);
421 if (err && visit_is_input(v)) {
422 qapi_free_EventInfo(*obj);
423 *obj = NULL;
424 }
425out:
426 error_propagate(errp, err);
427}
428
429void 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 }
456out:
457 error_propagate(errp, err);
458}
459
460void 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
485out:
486 error_propagate(errp, err);
487}
488
489void 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);
505out_obj:
506 visit_end_struct(v, (void **)obj);
507 if (err && visit_is_input(v)) {
508 qapi_free_IOThreadInfo(*obj);
509 *obj = NULL;
510 }
511out:
512 error_propagate(errp, err);
513}
514
515void 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 }
542out:
543 error_propagate(errp, err);
544}
545
546void 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
555out:
556 error_propagate(errp, err);
557}
558
559void 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);
575out_obj:
576 visit_end_struct(v, (void **)obj);
577 if (err && visit_is_input(v)) {
578 qapi_free_BalloonInfo(*obj);
579 *obj = NULL;
580 }
581out:
582 error_propagate(errp, err);
583}
584
585void 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
594out:
595 error_propagate(errp, err);
596}
597
598void 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
611out:
612 error_propagate(errp, err);
613}
614
615void 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);
631out_obj:
632 visit_end_struct(v, (void **)obj);
633 if (err && visit_is_input(v)) {
634 qapi_free_PciMemoryRange(*obj);
635 *obj = NULL;
636 }
637out:
638 error_propagate(errp, err);
639}
640
641void 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
674out:
675 error_propagate(errp, err);
676}
677
678void 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);
694out_obj:
695 visit_end_struct(v, (void **)obj);
696 if (err && visit_is_input(v)) {
697 qapi_free_PciMemoryRegion(*obj);
698 *obj = NULL;
699 }
700out:
701 error_propagate(errp, err);
702}
703
704void 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
733out:
734 error_propagate(errp, err);
735}
736
737void 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);
753out_obj:
754 visit_end_struct(v, (void **)obj);
755 if (err && visit_is_input(v)) {
756 qapi_free_PciBusInfo(*obj);
757 *obj = NULL;
758 }
759out:
760 error_propagate(errp, err);
761}
762
763void 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 }
790out:
791 error_propagate(errp, err);
792}
793
794void 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
809out:
810 error_propagate(errp, err);
811}
812
813void 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);
829out_obj:
830 visit_end_struct(v, (void **)obj);
831 if (err && visit_is_input(v)) {
832 qapi_free_PciBridgeInfo(*obj);
833 *obj = NULL;
834 }
835out:
836 error_propagate(errp, err);
837}
838
839void 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
854out:
855 error_propagate(errp, err);
856}
857
858void 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);
874out_obj:
875 visit_end_struct(v, (void **)obj);
876 if (err && visit_is_input(v)) {
877 qapi_free_PciDeviceClass(*obj);
878 *obj = NULL;
879 }
880out:
881 error_propagate(errp, err);
882}
883
884void 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
909out:
910 error_propagate(errp, err);
911}
912
913void 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);
929out_obj:
930 visit_end_struct(v, (void **)obj);
931 if (err && visit_is_input(v)) {
932 qapi_free_PciDeviceId(*obj);
933 *obj = NULL;
934 }
935out:
936 error_propagate(errp, err);
937}
938
939void 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 }
966out:
967 error_propagate(errp, err);
968}
969
970void 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
1015out:
1016 error_propagate(errp, err);
1017}
1018
1019void 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);
1035out_obj:
1036 visit_end_struct(v, (void **)obj);
1037 if (err && visit_is_input(v)) {
1038 qapi_free_PciDeviceInfo(*obj);
1039 *obj = NULL;
1040 }
1041out:
1042 error_propagate(errp, err);
1043}
1044
1045void 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
1058out:
1059 error_propagate(errp, err);
1060}
1061
1062void 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);
1078out_obj:
1079 visit_end_struct(v, (void **)obj);
1080 if (err && visit_is_input(v)) {
1081 qapi_free_PciInfo(*obj);
1082 *obj = NULL;
1083 }
1084out:
1085 error_propagate(errp, err);
1086}
1087
1088void 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 }
1115out:
1116 error_propagate(errp, err);
1117}
1118
1119void 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
1142out:
1143 error_propagate(errp, err);
1144}
1145
1146void 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
1163out:
1164 error_propagate(errp, err);
1165}
1166
1167void 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
1176out:
1177 error_propagate(errp, err);
1178}
1179
1180void 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
1195out:
1196 error_propagate(errp, err);
1197}
1198
1199void 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
1218out:
1219 error_propagate(errp, err);
1220}
1221
1222void 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
1231out:
1232 error_propagate(errp, err);
1233}
1234
1235void 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
1244out:
1245 error_propagate(errp, err);
1246}
1247
1248void 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
1257out:
1258 error_propagate(errp, err);
1259}
1260
1261void 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
1276out:
1277 error_propagate(errp, err);
1278}
1279
1280void 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);
1296out_obj:
1297 visit_end_struct(v, (void **)obj);
1298 if (err && visit_is_input(v)) {
1299 qapi_free_MemoryInfo(*obj);
1300 *obj = NULL;
1301 }
1302out:
1303 error_propagate(errp, err);
1304}
1305
1306void 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
1319out:
1320 error_propagate(errp, err);
1321}
1322
1323void 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);
1339out_obj:
1340 visit_end_struct(v, (void **)obj);
1341 if (err && visit_is_input(v)) {
1342 qapi_free_AddfdInfo(*obj);
1343 *obj = NULL;
1344 }
1345out:
1346 error_propagate(errp, err);
1347}
1348
1349void 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
1366out:
1367 error_propagate(errp, err);
1368}
1369
1370void 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
1385out:
1386 error_propagate(errp, err);
1387}
1388
1389void 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
1404out:
1405 error_propagate(errp, err);
1406}
1407
1408void 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);
1424out_obj:
1425 visit_end_struct(v, (void **)obj);
1426 if (err && visit_is_input(v)) {
1427 qapi_free_FdsetFdInfo(*obj);
1428 *obj = NULL;
1429 }
1430out:
1431 error_propagate(errp, err);
1432}
1433
1434void 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 }
1461out:
1462 error_propagate(errp, err);
1463}
1464
1465void 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
1478out:
1479 error_propagate(errp, err);
1480}
1481
1482void 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);
1498out_obj:
1499 visit_end_struct(v, (void **)obj);
1500 if (err && visit_is_input(v)) {
1501 qapi_free_FdsetInfo(*obj);
1502 *obj = NULL;
1503 }
1504out:
1505 error_propagate(errp, err);
1506}
1507
1508void 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 }
1535out:
1536 error_propagate(errp, err);
1537}
1538
1539void 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
1598out:
1599 error_propagate(errp, err);
1600}
1601
1602void 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);
1618out_obj:
1619 visit_end_struct(v, (void **)obj);
1620 if (err && visit_is_input(v)) {
1621 qapi_free_AcpiTableOptions(*obj);
1622 *obj = NULL;
1623 }
1624out:
1625 error_propagate(errp, err);
1626}
1627
1628void 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
1635void 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
1660out:
1661 error_propagate(errp, err);
1662}
1663
1664void 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);
1680out_obj:
1681 visit_end_struct(v, (void **)obj);
1682 if (err && visit_is_input(v)) {
1683 qapi_free_CommandLineParameterInfo(*obj);
1684 *obj = NULL;
1685 }
1686out:
1687 error_propagate(errp, err);
1688}
1689
1690void 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 }
1717out:
1718 error_propagate(errp, err);
1719}
1720
1721void 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
1734out:
1735 error_propagate(errp, err);
1736}
1737
1738void 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);
1754out_obj:
1755 visit_end_struct(v, (void **)obj);
1756 if (err && visit_is_input(v)) {
1757 qapi_free_CommandLineOptionInfo(*obj);
1758 *obj = NULL;
1759 }
1760out:
1761 error_propagate(errp, err);
1762}
1763
1764void 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
1775out:
1776 error_propagate(errp, err);
1777}
1778
1779void 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 }
1806out:
1807 error_propagate(errp, err);
1808}
1809
1810void 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
1849out:
1850 error_propagate(errp, err);
1851}
1852
1853void 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);
1869out_obj:
1870 visit_end_struct(v, (void **)obj);
1871 if (err && visit_is_input(v)) {
1872 qapi_free_PCDIMMDeviceInfo(*obj);
1873 *obj = NULL;
1874 }
1875out:
1876 error_propagate(errp, err);
1877}
1878
1879void 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
1902out:
1903 error_propagate(errp, err);
1904}
1905
1906void 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);
1922out_obj:
1923 visit_end_struct(v, (void **)obj);
1924 if (err && visit_is_input(v)) {
1925 qapi_free_VirtioPMEMDeviceInfo(*obj);
1926 *obj = NULL;
1927 }
1928out:
1929 error_propagate(errp, err);
1930}
1931
1932void 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
1941out:
1942 error_propagate(errp, err);
1943}
1944
1945void 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
1954out:
1955 error_propagate(errp, err);
1956}
1957
1958void 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
1965void 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
1987out:
1988 error_propagate(errp, err);
1989}
1990
1991void 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);
2007out_obj:
2008 visit_end_struct(v, (void **)obj);
2009 if (err && visit_is_input(v)) {
2010 qapi_free_MemoryDeviceInfo(*obj);
2011 *obj = NULL;
2012 }
2013out:
2014 error_propagate(errp, err);
2015}
2016
2017void 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 }
2044out:
2045 error_propagate(errp, err);
2046}
2047
2048void 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
2061out:
2062 error_propagate(errp, err);
2063}
2064
2065void 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
2072void 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
2099out:
2100 error_propagate(errp, err);
2101}
2102
2103void 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);
2119out_obj:
2120 visit_end_struct(v, (void **)obj);
2121 if (err && visit_is_input(v)) {
2122 qapi_free_ACPIOSTInfo(*obj);
2123 *obj = NULL;
2124 }
2125out:
2126 error_propagate(errp, err);
2127}
2128
2129void 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 }
2156out:
2157 error_propagate(errp, err);
2158}
2159
2160void 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
2169out:
2170 error_propagate(errp, err);
2171}
2172
2173void 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
2180void 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
2189out:
2190 error_propagate(errp, err);
2191}
2192
2193void 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
2202out:
2203 error_propagate(errp, err);
2204}
2205
2206void 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);
2222out_obj:
2223 visit_end_struct(v, (void **)obj);
2224 if (err && visit_is_input(v)) {
2225 qapi_free_GuidInfo(*obj);
2226 *obj = NULL;
2227 }
2228out:
2229 error_propagate(errp, err);
2230}
2231
2232/* Dummy declaration to prevent empty .o file */
2233char qapi_dummy_qapi_visit_misc_c;
2234