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-machine.h"
17
18void visit_type_SysEmuTarget(Visitor *v, const char *name, SysEmuTarget *obj, Error **errp)
19{
20 int value = *obj;
21 visit_type_enum(v, name, &value, &SysEmuTarget_lookup, errp);
22 *obj = value;
23}
24
25void visit_type_CpuInfoArch(Visitor *v, const char *name, CpuInfoArch *obj, Error **errp)
26{
27 int value = *obj;
28 visit_type_enum(v, name, &value, &CpuInfoArch_lookup, errp);
29 *obj = value;
30}
31
32void visit_type_q_obj_CpuInfo_base_members(Visitor *v, q_obj_CpuInfo_base *obj, Error **errp)
33{
34 Error *err = NULL;
35
36 visit_type_int(v, "CPU", &obj->CPU, &err);
37 if (err) {
38 goto out;
39 }
40 visit_type_bool(v, "current", &obj->current, &err);
41 if (err) {
42 goto out;
43 }
44 visit_type_bool(v, "halted", &obj->halted, &err);
45 if (err) {
46 goto out;
47 }
48 visit_type_str(v, "qom_path", &obj->qom_path, &err);
49 if (err) {
50 goto out;
51 }
52 visit_type_int(v, "thread_id", &obj->thread_id, &err);
53 if (err) {
54 goto out;
55 }
56 if (visit_optional(v, "props", &obj->has_props)) {
57 visit_type_CpuInstanceProperties(v, "props", &obj->props, &err);
58 if (err) {
59 goto out;
60 }
61 }
62 visit_type_CpuInfoArch(v, "arch", &obj->arch, &err);
63 if (err) {
64 goto out;
65 }
66
67out:
68 error_propagate(errp, err);
69}
70
71void visit_type_CpuInfo_members(Visitor *v, CpuInfo *obj, Error **errp)
72{
73 Error *err = NULL;
74
75 visit_type_q_obj_CpuInfo_base_members(v, (q_obj_CpuInfo_base *)obj, &err);
76 if (err) {
77 goto out;
78 }
79 switch (obj->arch) {
80 case CPU_INFO_ARCH_X86:
81 visit_type_CpuInfoX86_members(v, &obj->u.x86, &err);
82 break;
83 case CPU_INFO_ARCH_SPARC:
84 visit_type_CpuInfoSPARC_members(v, &obj->u.q_sparc, &err);
85 break;
86 case CPU_INFO_ARCH_PPC:
87 visit_type_CpuInfoPPC_members(v, &obj->u.ppc, &err);
88 break;
89 case CPU_INFO_ARCH_MIPS:
90 visit_type_CpuInfoMIPS_members(v, &obj->u.q_mips, &err);
91 break;
92 case CPU_INFO_ARCH_TRICORE:
93 visit_type_CpuInfoTricore_members(v, &obj->u.tricore, &err);
94 break;
95 case CPU_INFO_ARCH_S390:
96 visit_type_CpuInfoS390_members(v, &obj->u.s390, &err);
97 break;
98 case CPU_INFO_ARCH_RISCV:
99 visit_type_CpuInfoRISCV_members(v, &obj->u.riscv, &err);
100 break;
101 case CPU_INFO_ARCH_OTHER:
102 break;
103 default:
104 abort();
105 }
106
107out:
108 error_propagate(errp, err);
109}
110
111void visit_type_CpuInfo(Visitor *v, const char *name, CpuInfo **obj, Error **errp)
112{
113 Error *err = NULL;
114
115 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfo), &err);
116 if (err) {
117 goto out;
118 }
119 if (!*obj) {
120 goto out_obj;
121 }
122 visit_type_CpuInfo_members(v, *obj, &err);
123 if (err) {
124 goto out_obj;
125 }
126 visit_check_struct(v, &err);
127out_obj:
128 visit_end_struct(v, (void **)obj);
129 if (err && visit_is_input(v)) {
130 qapi_free_CpuInfo(*obj);
131 *obj = NULL;
132 }
133out:
134 error_propagate(errp, err);
135}
136
137void visit_type_CpuInfoX86_members(Visitor *v, CpuInfoX86 *obj, Error **errp)
138{
139 Error *err = NULL;
140
141 visit_type_int(v, "pc", &obj->pc, &err);
142 if (err) {
143 goto out;
144 }
145
146out:
147 error_propagate(errp, err);
148}
149
150void visit_type_CpuInfoX86(Visitor *v, const char *name, CpuInfoX86 **obj, Error **errp)
151{
152 Error *err = NULL;
153
154 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoX86), &err);
155 if (err) {
156 goto out;
157 }
158 if (!*obj) {
159 goto out_obj;
160 }
161 visit_type_CpuInfoX86_members(v, *obj, &err);
162 if (err) {
163 goto out_obj;
164 }
165 visit_check_struct(v, &err);
166out_obj:
167 visit_end_struct(v, (void **)obj);
168 if (err && visit_is_input(v)) {
169 qapi_free_CpuInfoX86(*obj);
170 *obj = NULL;
171 }
172out:
173 error_propagate(errp, err);
174}
175
176void visit_type_CpuInfoSPARC_members(Visitor *v, CpuInfoSPARC *obj, Error **errp)
177{
178 Error *err = NULL;
179
180 visit_type_int(v, "pc", &obj->pc, &err);
181 if (err) {
182 goto out;
183 }
184 visit_type_int(v, "npc", &obj->npc, &err);
185 if (err) {
186 goto out;
187 }
188
189out:
190 error_propagate(errp, err);
191}
192
193void visit_type_CpuInfoSPARC(Visitor *v, const char *name, CpuInfoSPARC **obj, Error **errp)
194{
195 Error *err = NULL;
196
197 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoSPARC), &err);
198 if (err) {
199 goto out;
200 }
201 if (!*obj) {
202 goto out_obj;
203 }
204 visit_type_CpuInfoSPARC_members(v, *obj, &err);
205 if (err) {
206 goto out_obj;
207 }
208 visit_check_struct(v, &err);
209out_obj:
210 visit_end_struct(v, (void **)obj);
211 if (err && visit_is_input(v)) {
212 qapi_free_CpuInfoSPARC(*obj);
213 *obj = NULL;
214 }
215out:
216 error_propagate(errp, err);
217}
218
219void visit_type_CpuInfoPPC_members(Visitor *v, CpuInfoPPC *obj, Error **errp)
220{
221 Error *err = NULL;
222
223 visit_type_int(v, "nip", &obj->nip, &err);
224 if (err) {
225 goto out;
226 }
227
228out:
229 error_propagate(errp, err);
230}
231
232void visit_type_CpuInfoPPC(Visitor *v, const char *name, CpuInfoPPC **obj, Error **errp)
233{
234 Error *err = NULL;
235
236 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoPPC), &err);
237 if (err) {
238 goto out;
239 }
240 if (!*obj) {
241 goto out_obj;
242 }
243 visit_type_CpuInfoPPC_members(v, *obj, &err);
244 if (err) {
245 goto out_obj;
246 }
247 visit_check_struct(v, &err);
248out_obj:
249 visit_end_struct(v, (void **)obj);
250 if (err && visit_is_input(v)) {
251 qapi_free_CpuInfoPPC(*obj);
252 *obj = NULL;
253 }
254out:
255 error_propagate(errp, err);
256}
257
258void visit_type_CpuInfoMIPS_members(Visitor *v, CpuInfoMIPS *obj, Error **errp)
259{
260 Error *err = NULL;
261
262 visit_type_int(v, "PC", &obj->PC, &err);
263 if (err) {
264 goto out;
265 }
266
267out:
268 error_propagate(errp, err);
269}
270
271void visit_type_CpuInfoMIPS(Visitor *v, const char *name, CpuInfoMIPS **obj, Error **errp)
272{
273 Error *err = NULL;
274
275 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoMIPS), &err);
276 if (err) {
277 goto out;
278 }
279 if (!*obj) {
280 goto out_obj;
281 }
282 visit_type_CpuInfoMIPS_members(v, *obj, &err);
283 if (err) {
284 goto out_obj;
285 }
286 visit_check_struct(v, &err);
287out_obj:
288 visit_end_struct(v, (void **)obj);
289 if (err && visit_is_input(v)) {
290 qapi_free_CpuInfoMIPS(*obj);
291 *obj = NULL;
292 }
293out:
294 error_propagate(errp, err);
295}
296
297void visit_type_CpuInfoTricore_members(Visitor *v, CpuInfoTricore *obj, Error **errp)
298{
299 Error *err = NULL;
300
301 visit_type_int(v, "PC", &obj->PC, &err);
302 if (err) {
303 goto out;
304 }
305
306out:
307 error_propagate(errp, err);
308}
309
310void visit_type_CpuInfoTricore(Visitor *v, const char *name, CpuInfoTricore **obj, Error **errp)
311{
312 Error *err = NULL;
313
314 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoTricore), &err);
315 if (err) {
316 goto out;
317 }
318 if (!*obj) {
319 goto out_obj;
320 }
321 visit_type_CpuInfoTricore_members(v, *obj, &err);
322 if (err) {
323 goto out_obj;
324 }
325 visit_check_struct(v, &err);
326out_obj:
327 visit_end_struct(v, (void **)obj);
328 if (err && visit_is_input(v)) {
329 qapi_free_CpuInfoTricore(*obj);
330 *obj = NULL;
331 }
332out:
333 error_propagate(errp, err);
334}
335
336void visit_type_CpuInfoRISCV_members(Visitor *v, CpuInfoRISCV *obj, Error **errp)
337{
338 Error *err = NULL;
339
340 visit_type_int(v, "pc", &obj->pc, &err);
341 if (err) {
342 goto out;
343 }
344
345out:
346 error_propagate(errp, err);
347}
348
349void visit_type_CpuInfoRISCV(Visitor *v, const char *name, CpuInfoRISCV **obj, Error **errp)
350{
351 Error *err = NULL;
352
353 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoRISCV), &err);
354 if (err) {
355 goto out;
356 }
357 if (!*obj) {
358 goto out_obj;
359 }
360 visit_type_CpuInfoRISCV_members(v, *obj, &err);
361 if (err) {
362 goto out_obj;
363 }
364 visit_check_struct(v, &err);
365out_obj:
366 visit_end_struct(v, (void **)obj);
367 if (err && visit_is_input(v)) {
368 qapi_free_CpuInfoRISCV(*obj);
369 *obj = NULL;
370 }
371out:
372 error_propagate(errp, err);
373}
374
375void visit_type_CpuS390State(Visitor *v, const char *name, CpuS390State *obj, Error **errp)
376{
377 int value = *obj;
378 visit_type_enum(v, name, &value, &CpuS390State_lookup, errp);
379 *obj = value;
380}
381
382void visit_type_CpuInfoS390_members(Visitor *v, CpuInfoS390 *obj, Error **errp)
383{
384 Error *err = NULL;
385
386 visit_type_CpuS390State(v, "cpu-state", &obj->cpu_state, &err);
387 if (err) {
388 goto out;
389 }
390
391out:
392 error_propagate(errp, err);
393}
394
395void visit_type_CpuInfoS390(Visitor *v, const char *name, CpuInfoS390 **obj, Error **errp)
396{
397 Error *err = NULL;
398
399 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoS390), &err);
400 if (err) {
401 goto out;
402 }
403 if (!*obj) {
404 goto out_obj;
405 }
406 visit_type_CpuInfoS390_members(v, *obj, &err);
407 if (err) {
408 goto out_obj;
409 }
410 visit_check_struct(v, &err);
411out_obj:
412 visit_end_struct(v, (void **)obj);
413 if (err && visit_is_input(v)) {
414 qapi_free_CpuInfoS390(*obj);
415 *obj = NULL;
416 }
417out:
418 error_propagate(errp, err);
419}
420
421void visit_type_CpuInfoList(Visitor *v, const char *name, CpuInfoList **obj, Error **errp)
422{
423 Error *err = NULL;
424 CpuInfoList *tail;
425 size_t size = sizeof(**obj);
426
427 visit_start_list(v, name, (GenericList **)obj, size, &err);
428 if (err) {
429 goto out;
430 }
431
432 for (tail = *obj; tail;
433 tail = (CpuInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
434 visit_type_CpuInfo(v, NULL, &tail->value, &err);
435 if (err) {
436 break;
437 }
438 }
439
440 if (!err) {
441 visit_check_list(v, &err);
442 }
443 visit_end_list(v, (void **)obj);
444 if (err && visit_is_input(v)) {
445 qapi_free_CpuInfoList(*obj);
446 *obj = NULL;
447 }
448out:
449 error_propagate(errp, err);
450}
451
452void visit_type_q_obj_CpuInfoFast_base_members(Visitor *v, q_obj_CpuInfoFast_base *obj, Error **errp)
453{
454 Error *err = NULL;
455
456 visit_type_int(v, "cpu-index", &obj->cpu_index, &err);
457 if (err) {
458 goto out;
459 }
460 visit_type_str(v, "qom-path", &obj->qom_path, &err);
461 if (err) {
462 goto out;
463 }
464 visit_type_int(v, "thread-id", &obj->thread_id, &err);
465 if (err) {
466 goto out;
467 }
468 if (visit_optional(v, "props", &obj->has_props)) {
469 visit_type_CpuInstanceProperties(v, "props", &obj->props, &err);
470 if (err) {
471 goto out;
472 }
473 }
474 visit_type_CpuInfoArch(v, "arch", &obj->arch, &err);
475 if (err) {
476 goto out;
477 }
478 visit_type_SysEmuTarget(v, "target", &obj->target, &err);
479 if (err) {
480 goto out;
481 }
482
483out:
484 error_propagate(errp, err);
485}
486
487void visit_type_CpuInfoFast_members(Visitor *v, CpuInfoFast *obj, Error **errp)
488{
489 Error *err = NULL;
490
491 visit_type_q_obj_CpuInfoFast_base_members(v, (q_obj_CpuInfoFast_base *)obj, &err);
492 if (err) {
493 goto out;
494 }
495 switch (obj->target) {
496 case SYS_EMU_TARGET_S390X:
497 visit_type_CpuInfoS390_members(v, &obj->u.s390x, &err);
498 break;
499 case SYS_EMU_TARGET_AARCH64:
500 break;
501 case SYS_EMU_TARGET_ALPHA:
502 break;
503 case SYS_EMU_TARGET_ARM:
504 break;
505 case SYS_EMU_TARGET_CRIS:
506 break;
507 case SYS_EMU_TARGET_HPPA:
508 break;
509 case SYS_EMU_TARGET_I386:
510 break;
511 case SYS_EMU_TARGET_LM32:
512 break;
513 case SYS_EMU_TARGET_M68K:
514 break;
515 case SYS_EMU_TARGET_MICROBLAZE:
516 break;
517 case SYS_EMU_TARGET_MICROBLAZEEL:
518 break;
519 case SYS_EMU_TARGET_MIPS:
520 break;
521 case SYS_EMU_TARGET_MIPS64:
522 break;
523 case SYS_EMU_TARGET_MIPS64EL:
524 break;
525 case SYS_EMU_TARGET_MIPSEL:
526 break;
527 case SYS_EMU_TARGET_MOXIE:
528 break;
529 case SYS_EMU_TARGET_NIOS2:
530 break;
531 case SYS_EMU_TARGET_OR1K:
532 break;
533 case SYS_EMU_TARGET_PPC:
534 break;
535 case SYS_EMU_TARGET_PPC64:
536 break;
537 case SYS_EMU_TARGET_RISCV32:
538 break;
539 case SYS_EMU_TARGET_RISCV64:
540 break;
541 case SYS_EMU_TARGET_SH4:
542 break;
543 case SYS_EMU_TARGET_SH4EB:
544 break;
545 case SYS_EMU_TARGET_SPARC:
546 break;
547 case SYS_EMU_TARGET_SPARC64:
548 break;
549 case SYS_EMU_TARGET_TRICORE:
550 break;
551 case SYS_EMU_TARGET_UNICORE32:
552 break;
553 case SYS_EMU_TARGET_X86_64:
554 break;
555 case SYS_EMU_TARGET_XTENSA:
556 break;
557 case SYS_EMU_TARGET_XTENSAEB:
558 break;
559 default:
560 abort();
561 }
562
563out:
564 error_propagate(errp, err);
565}
566
567void visit_type_CpuInfoFast(Visitor *v, const char *name, CpuInfoFast **obj, Error **errp)
568{
569 Error *err = NULL;
570
571 visit_start_struct(v, name, (void **)obj, sizeof(CpuInfoFast), &err);
572 if (err) {
573 goto out;
574 }
575 if (!*obj) {
576 goto out_obj;
577 }
578 visit_type_CpuInfoFast_members(v, *obj, &err);
579 if (err) {
580 goto out_obj;
581 }
582 visit_check_struct(v, &err);
583out_obj:
584 visit_end_struct(v, (void **)obj);
585 if (err && visit_is_input(v)) {
586 qapi_free_CpuInfoFast(*obj);
587 *obj = NULL;
588 }
589out:
590 error_propagate(errp, err);
591}
592
593void visit_type_CpuInfoFastList(Visitor *v, const char *name, CpuInfoFastList **obj, Error **errp)
594{
595 Error *err = NULL;
596 CpuInfoFastList *tail;
597 size_t size = sizeof(**obj);
598
599 visit_start_list(v, name, (GenericList **)obj, size, &err);
600 if (err) {
601 goto out;
602 }
603
604 for (tail = *obj; tail;
605 tail = (CpuInfoFastList *)visit_next_list(v, (GenericList *)tail, size)) {
606 visit_type_CpuInfoFast(v, NULL, &tail->value, &err);
607 if (err) {
608 break;
609 }
610 }
611
612 if (!err) {
613 visit_check_list(v, &err);
614 }
615 visit_end_list(v, (void **)obj);
616 if (err && visit_is_input(v)) {
617 qapi_free_CpuInfoFastList(*obj);
618 *obj = NULL;
619 }
620out:
621 error_propagate(errp, err);
622}
623
624void visit_type_q_obj_cpu_add_arg_members(Visitor *v, q_obj_cpu_add_arg *obj, Error **errp)
625{
626 Error *err = NULL;
627
628 visit_type_int(v, "id", &obj->id, &err);
629 if (err) {
630 goto out;
631 }
632
633out:
634 error_propagate(errp, err);
635}
636
637void visit_type_MachineInfo_members(Visitor *v, MachineInfo *obj, Error **errp)
638{
639 Error *err = NULL;
640
641 visit_type_str(v, "name", &obj->name, &err);
642 if (err) {
643 goto out;
644 }
645 if (visit_optional(v, "alias", &obj->has_alias)) {
646 visit_type_str(v, "alias", &obj->alias, &err);
647 if (err) {
648 goto out;
649 }
650 }
651 if (visit_optional(v, "is-default", &obj->has_is_default)) {
652 visit_type_bool(v, "is-default", &obj->is_default, &err);
653 if (err) {
654 goto out;
655 }
656 }
657 visit_type_int(v, "cpu-max", &obj->cpu_max, &err);
658 if (err) {
659 goto out;
660 }
661 visit_type_bool(v, "hotpluggable-cpus", &obj->hotpluggable_cpus, &err);
662 if (err) {
663 goto out;
664 }
665 visit_type_bool(v, "numa-mem-supported", &obj->numa_mem_supported, &err);
666 if (err) {
667 goto out;
668 }
669 visit_type_bool(v, "deprecated", &obj->deprecated, &err);
670 if (err) {
671 goto out;
672 }
673 if (visit_optional(v, "default-cpu-type", &obj->has_default_cpu_type)) {
674 visit_type_str(v, "default-cpu-type", &obj->default_cpu_type, &err);
675 if (err) {
676 goto out;
677 }
678 }
679
680out:
681 error_propagate(errp, err);
682}
683
684void visit_type_MachineInfo(Visitor *v, const char *name, MachineInfo **obj, Error **errp)
685{
686 Error *err = NULL;
687
688 visit_start_struct(v, name, (void **)obj, sizeof(MachineInfo), &err);
689 if (err) {
690 goto out;
691 }
692 if (!*obj) {
693 goto out_obj;
694 }
695 visit_type_MachineInfo_members(v, *obj, &err);
696 if (err) {
697 goto out_obj;
698 }
699 visit_check_struct(v, &err);
700out_obj:
701 visit_end_struct(v, (void **)obj);
702 if (err && visit_is_input(v)) {
703 qapi_free_MachineInfo(*obj);
704 *obj = NULL;
705 }
706out:
707 error_propagate(errp, err);
708}
709
710void visit_type_MachineInfoList(Visitor *v, const char *name, MachineInfoList **obj, Error **errp)
711{
712 Error *err = NULL;
713 MachineInfoList *tail;
714 size_t size = sizeof(**obj);
715
716 visit_start_list(v, name, (GenericList **)obj, size, &err);
717 if (err) {
718 goto out;
719 }
720
721 for (tail = *obj; tail;
722 tail = (MachineInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
723 visit_type_MachineInfo(v, NULL, &tail->value, &err);
724 if (err) {
725 break;
726 }
727 }
728
729 if (!err) {
730 visit_check_list(v, &err);
731 }
732 visit_end_list(v, (void **)obj);
733 if (err && visit_is_input(v)) {
734 qapi_free_MachineInfoList(*obj);
735 *obj = NULL;
736 }
737out:
738 error_propagate(errp, err);
739}
740
741void visit_type_CurrentMachineParams_members(Visitor *v, CurrentMachineParams *obj, Error **errp)
742{
743 Error *err = NULL;
744
745 visit_type_bool(v, "wakeup-suspend-support", &obj->wakeup_suspend_support, &err);
746 if (err) {
747 goto out;
748 }
749
750out:
751 error_propagate(errp, err);
752}
753
754void visit_type_CurrentMachineParams(Visitor *v, const char *name, CurrentMachineParams **obj, Error **errp)
755{
756 Error *err = NULL;
757
758 visit_start_struct(v, name, (void **)obj, sizeof(CurrentMachineParams), &err);
759 if (err) {
760 goto out;
761 }
762 if (!*obj) {
763 goto out_obj;
764 }
765 visit_type_CurrentMachineParams_members(v, *obj, &err);
766 if (err) {
767 goto out_obj;
768 }
769 visit_check_struct(v, &err);
770out_obj:
771 visit_end_struct(v, (void **)obj);
772 if (err && visit_is_input(v)) {
773 qapi_free_CurrentMachineParams(*obj);
774 *obj = NULL;
775 }
776out:
777 error_propagate(errp, err);
778}
779
780void visit_type_TargetInfo_members(Visitor *v, TargetInfo *obj, Error **errp)
781{
782 Error *err = NULL;
783
784 visit_type_SysEmuTarget(v, "arch", &obj->arch, &err);
785 if (err) {
786 goto out;
787 }
788
789out:
790 error_propagate(errp, err);
791}
792
793void visit_type_TargetInfo(Visitor *v, const char *name, TargetInfo **obj, Error **errp)
794{
795 Error *err = NULL;
796
797 visit_start_struct(v, name, (void **)obj, sizeof(TargetInfo), &err);
798 if (err) {
799 goto out;
800 }
801 if (!*obj) {
802 goto out_obj;
803 }
804 visit_type_TargetInfo_members(v, *obj, &err);
805 if (err) {
806 goto out_obj;
807 }
808 visit_check_struct(v, &err);
809out_obj:
810 visit_end_struct(v, (void **)obj);
811 if (err && visit_is_input(v)) {
812 qapi_free_TargetInfo(*obj);
813 *obj = NULL;
814 }
815out:
816 error_propagate(errp, err);
817}
818
819void visit_type_NumaOptionsType(Visitor *v, const char *name, NumaOptionsType *obj, Error **errp)
820{
821 int value = *obj;
822 visit_type_enum(v, name, &value, &NumaOptionsType_lookup, errp);
823 *obj = value;
824}
825
826void visit_type_q_obj_NumaOptions_base_members(Visitor *v, q_obj_NumaOptions_base *obj, Error **errp)
827{
828 Error *err = NULL;
829
830 visit_type_NumaOptionsType(v, "type", &obj->type, &err);
831 if (err) {
832 goto out;
833 }
834
835out:
836 error_propagate(errp, err);
837}
838
839void visit_type_NumaOptions_members(Visitor *v, NumaOptions *obj, Error **errp)
840{
841 Error *err = NULL;
842
843 visit_type_q_obj_NumaOptions_base_members(v, (q_obj_NumaOptions_base *)obj, &err);
844 if (err) {
845 goto out;
846 }
847 switch (obj->type) {
848 case NUMA_OPTIONS_TYPE_NODE:
849 visit_type_NumaNodeOptions_members(v, &obj->u.node, &err);
850 break;
851 case NUMA_OPTIONS_TYPE_DIST:
852 visit_type_NumaDistOptions_members(v, &obj->u.dist, &err);
853 break;
854 case NUMA_OPTIONS_TYPE_CPU:
855 visit_type_NumaCpuOptions_members(v, &obj->u.cpu, &err);
856 break;
857 default:
858 abort();
859 }
860
861out:
862 error_propagate(errp, err);
863}
864
865void visit_type_NumaOptions(Visitor *v, const char *name, NumaOptions **obj, Error **errp)
866{
867 Error *err = NULL;
868
869 visit_start_struct(v, name, (void **)obj, sizeof(NumaOptions), &err);
870 if (err) {
871 goto out;
872 }
873 if (!*obj) {
874 goto out_obj;
875 }
876 visit_type_NumaOptions_members(v, *obj, &err);
877 if (err) {
878 goto out_obj;
879 }
880 visit_check_struct(v, &err);
881out_obj:
882 visit_end_struct(v, (void **)obj);
883 if (err && visit_is_input(v)) {
884 qapi_free_NumaOptions(*obj);
885 *obj = NULL;
886 }
887out:
888 error_propagate(errp, err);
889}
890
891void visit_type_NumaNodeOptions_members(Visitor *v, NumaNodeOptions *obj, Error **errp)
892{
893 Error *err = NULL;
894
895 if (visit_optional(v, "nodeid", &obj->has_nodeid)) {
896 visit_type_uint16(v, "nodeid", &obj->nodeid, &err);
897 if (err) {
898 goto out;
899 }
900 }
901 if (visit_optional(v, "cpus", &obj->has_cpus)) {
902 visit_type_uint16List(v, "cpus", &obj->cpus, &err);
903 if (err) {
904 goto out;
905 }
906 }
907 if (visit_optional(v, "mem", &obj->has_mem)) {
908 visit_type_size(v, "mem", &obj->mem, &err);
909 if (err) {
910 goto out;
911 }
912 }
913 if (visit_optional(v, "memdev", &obj->has_memdev)) {
914 visit_type_str(v, "memdev", &obj->memdev, &err);
915 if (err) {
916 goto out;
917 }
918 }
919
920out:
921 error_propagate(errp, err);
922}
923
924void visit_type_NumaNodeOptions(Visitor *v, const char *name, NumaNodeOptions **obj, Error **errp)
925{
926 Error *err = NULL;
927
928 visit_start_struct(v, name, (void **)obj, sizeof(NumaNodeOptions), &err);
929 if (err) {
930 goto out;
931 }
932 if (!*obj) {
933 goto out_obj;
934 }
935 visit_type_NumaNodeOptions_members(v, *obj, &err);
936 if (err) {
937 goto out_obj;
938 }
939 visit_check_struct(v, &err);
940out_obj:
941 visit_end_struct(v, (void **)obj);
942 if (err && visit_is_input(v)) {
943 qapi_free_NumaNodeOptions(*obj);
944 *obj = NULL;
945 }
946out:
947 error_propagate(errp, err);
948}
949
950void visit_type_NumaDistOptions_members(Visitor *v, NumaDistOptions *obj, Error **errp)
951{
952 Error *err = NULL;
953
954 visit_type_uint16(v, "src", &obj->src, &err);
955 if (err) {
956 goto out;
957 }
958 visit_type_uint16(v, "dst", &obj->dst, &err);
959 if (err) {
960 goto out;
961 }
962 visit_type_uint8(v, "val", &obj->val, &err);
963 if (err) {
964 goto out;
965 }
966
967out:
968 error_propagate(errp, err);
969}
970
971void visit_type_NumaDistOptions(Visitor *v, const char *name, NumaDistOptions **obj, Error **errp)
972{
973 Error *err = NULL;
974
975 visit_start_struct(v, name, (void **)obj, sizeof(NumaDistOptions), &err);
976 if (err) {
977 goto out;
978 }
979 if (!*obj) {
980 goto out_obj;
981 }
982 visit_type_NumaDistOptions_members(v, *obj, &err);
983 if (err) {
984 goto out_obj;
985 }
986 visit_check_struct(v, &err);
987out_obj:
988 visit_end_struct(v, (void **)obj);
989 if (err && visit_is_input(v)) {
990 qapi_free_NumaDistOptions(*obj);
991 *obj = NULL;
992 }
993out:
994 error_propagate(errp, err);
995}
996
997void visit_type_X86CPURegister32(Visitor *v, const char *name, X86CPURegister32 *obj, Error **errp)
998{
999 int value = *obj;
1000 visit_type_enum(v, name, &value, &X86CPURegister32_lookup, errp);
1001 *obj = value;
1002}
1003
1004void visit_type_X86CPUFeatureWordInfo_members(Visitor *v, X86CPUFeatureWordInfo *obj, Error **errp)
1005{
1006 Error *err = NULL;
1007
1008 visit_type_int(v, "cpuid-input-eax", &obj->cpuid_input_eax, &err);
1009 if (err) {
1010 goto out;
1011 }
1012 if (visit_optional(v, "cpuid-input-ecx", &obj->has_cpuid_input_ecx)) {
1013 visit_type_int(v, "cpuid-input-ecx", &obj->cpuid_input_ecx, &err);
1014 if (err) {
1015 goto out;
1016 }
1017 }
1018 visit_type_X86CPURegister32(v, "cpuid-register", &obj->cpuid_register, &err);
1019 if (err) {
1020 goto out;
1021 }
1022 visit_type_int(v, "features", &obj->features, &err);
1023 if (err) {
1024 goto out;
1025 }
1026
1027out:
1028 error_propagate(errp, err);
1029}
1030
1031void visit_type_X86CPUFeatureWordInfo(Visitor *v, const char *name, X86CPUFeatureWordInfo **obj, Error **errp)
1032{
1033 Error *err = NULL;
1034
1035 visit_start_struct(v, name, (void **)obj, sizeof(X86CPUFeatureWordInfo), &err);
1036 if (err) {
1037 goto out;
1038 }
1039 if (!*obj) {
1040 goto out_obj;
1041 }
1042 visit_type_X86CPUFeatureWordInfo_members(v, *obj, &err);
1043 if (err) {
1044 goto out_obj;
1045 }
1046 visit_check_struct(v, &err);
1047out_obj:
1048 visit_end_struct(v, (void **)obj);
1049 if (err && visit_is_input(v)) {
1050 qapi_free_X86CPUFeatureWordInfo(*obj);
1051 *obj = NULL;
1052 }
1053out:
1054 error_propagate(errp, err);
1055}
1056
1057void visit_type_X86CPUFeatureWordInfoList(Visitor *v, const char *name, X86CPUFeatureWordInfoList **obj, Error **errp)
1058{
1059 Error *err = NULL;
1060 X86CPUFeatureWordInfoList *tail;
1061 size_t size = sizeof(**obj);
1062
1063 visit_start_list(v, name, (GenericList **)obj, size, &err);
1064 if (err) {
1065 goto out;
1066 }
1067
1068 for (tail = *obj; tail;
1069 tail = (X86CPUFeatureWordInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
1070 visit_type_X86CPUFeatureWordInfo(v, NULL, &tail->value, &err);
1071 if (err) {
1072 break;
1073 }
1074 }
1075
1076 if (!err) {
1077 visit_check_list(v, &err);
1078 }
1079 visit_end_list(v, (void **)obj);
1080 if (err && visit_is_input(v)) {
1081 qapi_free_X86CPUFeatureWordInfoList(*obj);
1082 *obj = NULL;
1083 }
1084out:
1085 error_propagate(errp, err);
1086}
1087
1088void visit_type_DummyForceArrays_members(Visitor *v, DummyForceArrays *obj, Error **errp)
1089{
1090 Error *err = NULL;
1091
1092 visit_type_X86CPUFeatureWordInfoList(v, "unused", &obj->unused, &err);
1093 if (err) {
1094 goto out;
1095 }
1096
1097out:
1098 error_propagate(errp, err);
1099}
1100
1101void visit_type_DummyForceArrays(Visitor *v, const char *name, DummyForceArrays **obj, Error **errp)
1102{
1103 Error *err = NULL;
1104
1105 visit_start_struct(v, name, (void **)obj, sizeof(DummyForceArrays), &err);
1106 if (err) {
1107 goto out;
1108 }
1109 if (!*obj) {
1110 goto out_obj;
1111 }
1112 visit_type_DummyForceArrays_members(v, *obj, &err);
1113 if (err) {
1114 goto out_obj;
1115 }
1116 visit_check_struct(v, &err);
1117out_obj:
1118 visit_end_struct(v, (void **)obj);
1119 if (err && visit_is_input(v)) {
1120 qapi_free_DummyForceArrays(*obj);
1121 *obj = NULL;
1122 }
1123out:
1124 error_propagate(errp, err);
1125}
1126
1127void visit_type_NumaCpuOptions_members(Visitor *v, NumaCpuOptions *obj, Error **errp)
1128{
1129 Error *err = NULL;
1130
1131 visit_type_CpuInstanceProperties_members(v, (CpuInstanceProperties *)obj, &err);
1132 if (err) {
1133 goto out;
1134 }
1135
1136out:
1137 error_propagate(errp, err);
1138}
1139
1140void visit_type_NumaCpuOptions(Visitor *v, const char *name, NumaCpuOptions **obj, Error **errp)
1141{
1142 Error *err = NULL;
1143
1144 visit_start_struct(v, name, (void **)obj, sizeof(NumaCpuOptions), &err);
1145 if (err) {
1146 goto out;
1147 }
1148 if (!*obj) {
1149 goto out_obj;
1150 }
1151 visit_type_NumaCpuOptions_members(v, *obj, &err);
1152 if (err) {
1153 goto out_obj;
1154 }
1155 visit_check_struct(v, &err);
1156out_obj:
1157 visit_end_struct(v, (void **)obj);
1158 if (err && visit_is_input(v)) {
1159 qapi_free_NumaCpuOptions(*obj);
1160 *obj = NULL;
1161 }
1162out:
1163 error_propagate(errp, err);
1164}
1165
1166void visit_type_HostMemPolicy(Visitor *v, const char *name, HostMemPolicy *obj, Error **errp)
1167{
1168 int value = *obj;
1169 visit_type_enum(v, name, &value, &HostMemPolicy_lookup, errp);
1170 *obj = value;
1171}
1172
1173void visit_type_Memdev_members(Visitor *v, Memdev *obj, Error **errp)
1174{
1175 Error *err = NULL;
1176
1177 if (visit_optional(v, "id", &obj->has_id)) {
1178 visit_type_str(v, "id", &obj->id, &err);
1179 if (err) {
1180 goto out;
1181 }
1182 }
1183 visit_type_size(v, "size", &obj->size, &err);
1184 if (err) {
1185 goto out;
1186 }
1187 visit_type_bool(v, "merge", &obj->merge, &err);
1188 if (err) {
1189 goto out;
1190 }
1191 visit_type_bool(v, "dump", &obj->dump, &err);
1192 if (err) {
1193 goto out;
1194 }
1195 visit_type_bool(v, "prealloc", &obj->prealloc, &err);
1196 if (err) {
1197 goto out;
1198 }
1199 visit_type_uint16List(v, "host-nodes", &obj->host_nodes, &err);
1200 if (err) {
1201 goto out;
1202 }
1203 visit_type_HostMemPolicy(v, "policy", &obj->policy, &err);
1204 if (err) {
1205 goto out;
1206 }
1207
1208out:
1209 error_propagate(errp, err);
1210}
1211
1212void visit_type_Memdev(Visitor *v, const char *name, Memdev **obj, Error **errp)
1213{
1214 Error *err = NULL;
1215
1216 visit_start_struct(v, name, (void **)obj, sizeof(Memdev), &err);
1217 if (err) {
1218 goto out;
1219 }
1220 if (!*obj) {
1221 goto out_obj;
1222 }
1223 visit_type_Memdev_members(v, *obj, &err);
1224 if (err) {
1225 goto out_obj;
1226 }
1227 visit_check_struct(v, &err);
1228out_obj:
1229 visit_end_struct(v, (void **)obj);
1230 if (err && visit_is_input(v)) {
1231 qapi_free_Memdev(*obj);
1232 *obj = NULL;
1233 }
1234out:
1235 error_propagate(errp, err);
1236}
1237
1238void visit_type_MemdevList(Visitor *v, const char *name, MemdevList **obj, Error **errp)
1239{
1240 Error *err = NULL;
1241 MemdevList *tail;
1242 size_t size = sizeof(**obj);
1243
1244 visit_start_list(v, name, (GenericList **)obj, size, &err);
1245 if (err) {
1246 goto out;
1247 }
1248
1249 for (tail = *obj; tail;
1250 tail = (MemdevList *)visit_next_list(v, (GenericList *)tail, size)) {
1251 visit_type_Memdev(v, NULL, &tail->value, &err);
1252 if (err) {
1253 break;
1254 }
1255 }
1256
1257 if (!err) {
1258 visit_check_list(v, &err);
1259 }
1260 visit_end_list(v, (void **)obj);
1261 if (err && visit_is_input(v)) {
1262 qapi_free_MemdevList(*obj);
1263 *obj = NULL;
1264 }
1265out:
1266 error_propagate(errp, err);
1267}
1268
1269void visit_type_CpuInstanceProperties_members(Visitor *v, CpuInstanceProperties *obj, Error **errp)
1270{
1271 Error *err = NULL;
1272
1273 if (visit_optional(v, "node-id", &obj->has_node_id)) {
1274 visit_type_int(v, "node-id", &obj->node_id, &err);
1275 if (err) {
1276 goto out;
1277 }
1278 }
1279 if (visit_optional(v, "socket-id", &obj->has_socket_id)) {
1280 visit_type_int(v, "socket-id", &obj->socket_id, &err);
1281 if (err) {
1282 goto out;
1283 }
1284 }
1285 if (visit_optional(v, "die-id", &obj->has_die_id)) {
1286 visit_type_int(v, "die-id", &obj->die_id, &err);
1287 if (err) {
1288 goto out;
1289 }
1290 }
1291 if (visit_optional(v, "core-id", &obj->has_core_id)) {
1292 visit_type_int(v, "core-id", &obj->core_id, &err);
1293 if (err) {
1294 goto out;
1295 }
1296 }
1297 if (visit_optional(v, "thread-id", &obj->has_thread_id)) {
1298 visit_type_int(v, "thread-id", &obj->thread_id, &err);
1299 if (err) {
1300 goto out;
1301 }
1302 }
1303
1304out:
1305 error_propagate(errp, err);
1306}
1307
1308void visit_type_CpuInstanceProperties(Visitor *v, const char *name, CpuInstanceProperties **obj, Error **errp)
1309{
1310 Error *err = NULL;
1311
1312 visit_start_struct(v, name, (void **)obj, sizeof(CpuInstanceProperties), &err);
1313 if (err) {
1314 goto out;
1315 }
1316 if (!*obj) {
1317 goto out_obj;
1318 }
1319 visit_type_CpuInstanceProperties_members(v, *obj, &err);
1320 if (err) {
1321 goto out_obj;
1322 }
1323 visit_check_struct(v, &err);
1324out_obj:
1325 visit_end_struct(v, (void **)obj);
1326 if (err && visit_is_input(v)) {
1327 qapi_free_CpuInstanceProperties(*obj);
1328 *obj = NULL;
1329 }
1330out:
1331 error_propagate(errp, err);
1332}
1333
1334void visit_type_HotpluggableCPU_members(Visitor *v, HotpluggableCPU *obj, Error **errp)
1335{
1336 Error *err = NULL;
1337
1338 visit_type_str(v, "type", &obj->type, &err);
1339 if (err) {
1340 goto out;
1341 }
1342 visit_type_int(v, "vcpus-count", &obj->vcpus_count, &err);
1343 if (err) {
1344 goto out;
1345 }
1346 visit_type_CpuInstanceProperties(v, "props", &obj->props, &err);
1347 if (err) {
1348 goto out;
1349 }
1350 if (visit_optional(v, "qom-path", &obj->has_qom_path)) {
1351 visit_type_str(v, "qom-path", &obj->qom_path, &err);
1352 if (err) {
1353 goto out;
1354 }
1355 }
1356
1357out:
1358 error_propagate(errp, err);
1359}
1360
1361void visit_type_HotpluggableCPU(Visitor *v, const char *name, HotpluggableCPU **obj, Error **errp)
1362{
1363 Error *err = NULL;
1364
1365 visit_start_struct(v, name, (void **)obj, sizeof(HotpluggableCPU), &err);
1366 if (err) {
1367 goto out;
1368 }
1369 if (!*obj) {
1370 goto out_obj;
1371 }
1372 visit_type_HotpluggableCPU_members(v, *obj, &err);
1373 if (err) {
1374 goto out_obj;
1375 }
1376 visit_check_struct(v, &err);
1377out_obj:
1378 visit_end_struct(v, (void **)obj);
1379 if (err && visit_is_input(v)) {
1380 qapi_free_HotpluggableCPU(*obj);
1381 *obj = NULL;
1382 }
1383out:
1384 error_propagate(errp, err);
1385}
1386
1387void visit_type_HotpluggableCPUList(Visitor *v, const char *name, HotpluggableCPUList **obj, Error **errp)
1388{
1389 Error *err = NULL;
1390 HotpluggableCPUList *tail;
1391 size_t size = sizeof(**obj);
1392
1393 visit_start_list(v, name, (GenericList **)obj, size, &err);
1394 if (err) {
1395 goto out;
1396 }
1397
1398 for (tail = *obj; tail;
1399 tail = (HotpluggableCPUList *)visit_next_list(v, (GenericList *)tail, size)) {
1400 visit_type_HotpluggableCPU(v, NULL, &tail->value, &err);
1401 if (err) {
1402 break;
1403 }
1404 }
1405
1406 if (!err) {
1407 visit_check_list(v, &err);
1408 }
1409 visit_end_list(v, (void **)obj);
1410 if (err && visit_is_input(v)) {
1411 qapi_free_HotpluggableCPUList(*obj);
1412 *obj = NULL;
1413 }
1414out:
1415 error_propagate(errp, err);
1416}
1417
1418/* Dummy declaration to prevent empty .o file */
1419char qapi_dummy_qapi_visit_machine_c;
1420