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 | |
18 | void 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 | |
25 | void 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 | |
32 | void 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 | |
67 | out: |
68 | error_propagate(errp, err); |
69 | } |
70 | |
71 | void 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 | |
107 | out: |
108 | error_propagate(errp, err); |
109 | } |
110 | |
111 | void 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); |
127 | out_obj: |
128 | visit_end_struct(v, (void **)obj); |
129 | if (err && visit_is_input(v)) { |
130 | qapi_free_CpuInfo(*obj); |
131 | *obj = NULL; |
132 | } |
133 | out: |
134 | error_propagate(errp, err); |
135 | } |
136 | |
137 | void 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 | |
146 | out: |
147 | error_propagate(errp, err); |
148 | } |
149 | |
150 | void 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); |
166 | out_obj: |
167 | visit_end_struct(v, (void **)obj); |
168 | if (err && visit_is_input(v)) { |
169 | qapi_free_CpuInfoX86(*obj); |
170 | *obj = NULL; |
171 | } |
172 | out: |
173 | error_propagate(errp, err); |
174 | } |
175 | |
176 | void 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 | |
189 | out: |
190 | error_propagate(errp, err); |
191 | } |
192 | |
193 | void 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); |
209 | out_obj: |
210 | visit_end_struct(v, (void **)obj); |
211 | if (err && visit_is_input(v)) { |
212 | qapi_free_CpuInfoSPARC(*obj); |
213 | *obj = NULL; |
214 | } |
215 | out: |
216 | error_propagate(errp, err); |
217 | } |
218 | |
219 | void 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 | |
228 | out: |
229 | error_propagate(errp, err); |
230 | } |
231 | |
232 | void 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); |
248 | out_obj: |
249 | visit_end_struct(v, (void **)obj); |
250 | if (err && visit_is_input(v)) { |
251 | qapi_free_CpuInfoPPC(*obj); |
252 | *obj = NULL; |
253 | } |
254 | out: |
255 | error_propagate(errp, err); |
256 | } |
257 | |
258 | void 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 | |
267 | out: |
268 | error_propagate(errp, err); |
269 | } |
270 | |
271 | void 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); |
287 | out_obj: |
288 | visit_end_struct(v, (void **)obj); |
289 | if (err && visit_is_input(v)) { |
290 | qapi_free_CpuInfoMIPS(*obj); |
291 | *obj = NULL; |
292 | } |
293 | out: |
294 | error_propagate(errp, err); |
295 | } |
296 | |
297 | void 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 | |
306 | out: |
307 | error_propagate(errp, err); |
308 | } |
309 | |
310 | void 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); |
326 | out_obj: |
327 | visit_end_struct(v, (void **)obj); |
328 | if (err && visit_is_input(v)) { |
329 | qapi_free_CpuInfoTricore(*obj); |
330 | *obj = NULL; |
331 | } |
332 | out: |
333 | error_propagate(errp, err); |
334 | } |
335 | |
336 | void 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 | |
345 | out: |
346 | error_propagate(errp, err); |
347 | } |
348 | |
349 | void 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); |
365 | out_obj: |
366 | visit_end_struct(v, (void **)obj); |
367 | if (err && visit_is_input(v)) { |
368 | qapi_free_CpuInfoRISCV(*obj); |
369 | *obj = NULL; |
370 | } |
371 | out: |
372 | error_propagate(errp, err); |
373 | } |
374 | |
375 | void 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 | |
382 | void 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 | |
391 | out: |
392 | error_propagate(errp, err); |
393 | } |
394 | |
395 | void 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); |
411 | out_obj: |
412 | visit_end_struct(v, (void **)obj); |
413 | if (err && visit_is_input(v)) { |
414 | qapi_free_CpuInfoS390(*obj); |
415 | *obj = NULL; |
416 | } |
417 | out: |
418 | error_propagate(errp, err); |
419 | } |
420 | |
421 | void 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 | } |
448 | out: |
449 | error_propagate(errp, err); |
450 | } |
451 | |
452 | void 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 | |
483 | out: |
484 | error_propagate(errp, err); |
485 | } |
486 | |
487 | void 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 | |
563 | out: |
564 | error_propagate(errp, err); |
565 | } |
566 | |
567 | void 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); |
583 | out_obj: |
584 | visit_end_struct(v, (void **)obj); |
585 | if (err && visit_is_input(v)) { |
586 | qapi_free_CpuInfoFast(*obj); |
587 | *obj = NULL; |
588 | } |
589 | out: |
590 | error_propagate(errp, err); |
591 | } |
592 | |
593 | void 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 | } |
620 | out: |
621 | error_propagate(errp, err); |
622 | } |
623 | |
624 | void 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 | |
633 | out: |
634 | error_propagate(errp, err); |
635 | } |
636 | |
637 | void 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 | |
680 | out: |
681 | error_propagate(errp, err); |
682 | } |
683 | |
684 | void 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); |
700 | out_obj: |
701 | visit_end_struct(v, (void **)obj); |
702 | if (err && visit_is_input(v)) { |
703 | qapi_free_MachineInfo(*obj); |
704 | *obj = NULL; |
705 | } |
706 | out: |
707 | error_propagate(errp, err); |
708 | } |
709 | |
710 | void 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 | } |
737 | out: |
738 | error_propagate(errp, err); |
739 | } |
740 | |
741 | void 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 | |
750 | out: |
751 | error_propagate(errp, err); |
752 | } |
753 | |
754 | void 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); |
770 | out_obj: |
771 | visit_end_struct(v, (void **)obj); |
772 | if (err && visit_is_input(v)) { |
773 | qapi_free_CurrentMachineParams(*obj); |
774 | *obj = NULL; |
775 | } |
776 | out: |
777 | error_propagate(errp, err); |
778 | } |
779 | |
780 | void 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 | |
789 | out: |
790 | error_propagate(errp, err); |
791 | } |
792 | |
793 | void 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); |
809 | out_obj: |
810 | visit_end_struct(v, (void **)obj); |
811 | if (err && visit_is_input(v)) { |
812 | qapi_free_TargetInfo(*obj); |
813 | *obj = NULL; |
814 | } |
815 | out: |
816 | error_propagate(errp, err); |
817 | } |
818 | |
819 | void 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 | |
826 | void 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 | |
835 | out: |
836 | error_propagate(errp, err); |
837 | } |
838 | |
839 | void 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 | |
861 | out: |
862 | error_propagate(errp, err); |
863 | } |
864 | |
865 | void 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); |
881 | out_obj: |
882 | visit_end_struct(v, (void **)obj); |
883 | if (err && visit_is_input(v)) { |
884 | qapi_free_NumaOptions(*obj); |
885 | *obj = NULL; |
886 | } |
887 | out: |
888 | error_propagate(errp, err); |
889 | } |
890 | |
891 | void 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 | |
920 | out: |
921 | error_propagate(errp, err); |
922 | } |
923 | |
924 | void 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); |
940 | out_obj: |
941 | visit_end_struct(v, (void **)obj); |
942 | if (err && visit_is_input(v)) { |
943 | qapi_free_NumaNodeOptions(*obj); |
944 | *obj = NULL; |
945 | } |
946 | out: |
947 | error_propagate(errp, err); |
948 | } |
949 | |
950 | void 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 | |
967 | out: |
968 | error_propagate(errp, err); |
969 | } |
970 | |
971 | void 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); |
987 | out_obj: |
988 | visit_end_struct(v, (void **)obj); |
989 | if (err && visit_is_input(v)) { |
990 | qapi_free_NumaDistOptions(*obj); |
991 | *obj = NULL; |
992 | } |
993 | out: |
994 | error_propagate(errp, err); |
995 | } |
996 | |
997 | void 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 | |
1004 | void 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 | |
1027 | out: |
1028 | error_propagate(errp, err); |
1029 | } |
1030 | |
1031 | void 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); |
1047 | out_obj: |
1048 | visit_end_struct(v, (void **)obj); |
1049 | if (err && visit_is_input(v)) { |
1050 | qapi_free_X86CPUFeatureWordInfo(*obj); |
1051 | *obj = NULL; |
1052 | } |
1053 | out: |
1054 | error_propagate(errp, err); |
1055 | } |
1056 | |
1057 | void 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 | } |
1084 | out: |
1085 | error_propagate(errp, err); |
1086 | } |
1087 | |
1088 | void 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 | |
1097 | out: |
1098 | error_propagate(errp, err); |
1099 | } |
1100 | |
1101 | void 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); |
1117 | out_obj: |
1118 | visit_end_struct(v, (void **)obj); |
1119 | if (err && visit_is_input(v)) { |
1120 | qapi_free_DummyForceArrays(*obj); |
1121 | *obj = NULL; |
1122 | } |
1123 | out: |
1124 | error_propagate(errp, err); |
1125 | } |
1126 | |
1127 | void 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 | |
1136 | out: |
1137 | error_propagate(errp, err); |
1138 | } |
1139 | |
1140 | void 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); |
1156 | out_obj: |
1157 | visit_end_struct(v, (void **)obj); |
1158 | if (err && visit_is_input(v)) { |
1159 | qapi_free_NumaCpuOptions(*obj); |
1160 | *obj = NULL; |
1161 | } |
1162 | out: |
1163 | error_propagate(errp, err); |
1164 | } |
1165 | |
1166 | void 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 | |
1173 | void 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 | |
1208 | out: |
1209 | error_propagate(errp, err); |
1210 | } |
1211 | |
1212 | void 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); |
1228 | out_obj: |
1229 | visit_end_struct(v, (void **)obj); |
1230 | if (err && visit_is_input(v)) { |
1231 | qapi_free_Memdev(*obj); |
1232 | *obj = NULL; |
1233 | } |
1234 | out: |
1235 | error_propagate(errp, err); |
1236 | } |
1237 | |
1238 | void 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 | } |
1265 | out: |
1266 | error_propagate(errp, err); |
1267 | } |
1268 | |
1269 | void 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 | |
1304 | out: |
1305 | error_propagate(errp, err); |
1306 | } |
1307 | |
1308 | void 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); |
1324 | out_obj: |
1325 | visit_end_struct(v, (void **)obj); |
1326 | if (err && visit_is_input(v)) { |
1327 | qapi_free_CpuInstanceProperties(*obj); |
1328 | *obj = NULL; |
1329 | } |
1330 | out: |
1331 | error_propagate(errp, err); |
1332 | } |
1333 | |
1334 | void 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 | |
1357 | out: |
1358 | error_propagate(errp, err); |
1359 | } |
1360 | |
1361 | void 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); |
1377 | out_obj: |
1378 | visit_end_struct(v, (void **)obj); |
1379 | if (err && visit_is_input(v)) { |
1380 | qapi_free_HotpluggableCPU(*obj); |
1381 | *obj = NULL; |
1382 | } |
1383 | out: |
1384 | error_propagate(errp, err); |
1385 | } |
1386 | |
1387 | void 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 | } |
1414 | out: |
1415 | error_propagate(errp, err); |
1416 | } |
1417 | |
1418 | /* Dummy declaration to prevent empty .o file */ |
1419 | char qapi_dummy_qapi_visit_machine_c; |
1420 | |