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-block-core.h"
17
18void visit_type_SnapshotInfo_members(Visitor *v, SnapshotInfo *obj, Error **errp)
19{
20 Error *err = NULL;
21
22 visit_type_str(v, "id", &obj->id, &err);
23 if (err) {
24 goto out;
25 }
26 visit_type_str(v, "name", &obj->name, &err);
27 if (err) {
28 goto out;
29 }
30 visit_type_int(v, "vm-state-size", &obj->vm_state_size, &err);
31 if (err) {
32 goto out;
33 }
34 visit_type_int(v, "date-sec", &obj->date_sec, &err);
35 if (err) {
36 goto out;
37 }
38 visit_type_int(v, "date-nsec", &obj->date_nsec, &err);
39 if (err) {
40 goto out;
41 }
42 visit_type_int(v, "vm-clock-sec", &obj->vm_clock_sec, &err);
43 if (err) {
44 goto out;
45 }
46 visit_type_int(v, "vm-clock-nsec", &obj->vm_clock_nsec, &err);
47 if (err) {
48 goto out;
49 }
50
51out:
52 error_propagate(errp, err);
53}
54
55void visit_type_SnapshotInfo(Visitor *v, const char *name, SnapshotInfo **obj, Error **errp)
56{
57 Error *err = NULL;
58
59 visit_start_struct(v, name, (void **)obj, sizeof(SnapshotInfo), &err);
60 if (err) {
61 goto out;
62 }
63 if (!*obj) {
64 goto out_obj;
65 }
66 visit_type_SnapshotInfo_members(v, *obj, &err);
67 if (err) {
68 goto out_obj;
69 }
70 visit_check_struct(v, &err);
71out_obj:
72 visit_end_struct(v, (void **)obj);
73 if (err && visit_is_input(v)) {
74 qapi_free_SnapshotInfo(*obj);
75 *obj = NULL;
76 }
77out:
78 error_propagate(errp, err);
79}
80
81void visit_type_ImageInfoSpecificQCow2EncryptionBase_members(Visitor *v, ImageInfoSpecificQCow2EncryptionBase *obj, Error **errp)
82{
83 Error *err = NULL;
84
85 visit_type_BlockdevQcow2EncryptionFormat(v, "format", &obj->format, &err);
86 if (err) {
87 goto out;
88 }
89
90out:
91 error_propagate(errp, err);
92}
93
94void visit_type_ImageInfoSpecificQCow2EncryptionBase(Visitor *v, const char *name, ImageInfoSpecificQCow2EncryptionBase **obj, Error **errp)
95{
96 Error *err = NULL;
97
98 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfoSpecificQCow2EncryptionBase), &err);
99 if (err) {
100 goto out;
101 }
102 if (!*obj) {
103 goto out_obj;
104 }
105 visit_type_ImageInfoSpecificQCow2EncryptionBase_members(v, *obj, &err);
106 if (err) {
107 goto out_obj;
108 }
109 visit_check_struct(v, &err);
110out_obj:
111 visit_end_struct(v, (void **)obj);
112 if (err && visit_is_input(v)) {
113 qapi_free_ImageInfoSpecificQCow2EncryptionBase(*obj);
114 *obj = NULL;
115 }
116out:
117 error_propagate(errp, err);
118}
119
120void visit_type_ImageInfoSpecificQCow2Encryption_members(Visitor *v, ImageInfoSpecificQCow2Encryption *obj, Error **errp)
121{
122 Error *err = NULL;
123
124 visit_type_ImageInfoSpecificQCow2EncryptionBase_members(v, (ImageInfoSpecificQCow2EncryptionBase *)obj, &err);
125 if (err) {
126 goto out;
127 }
128 switch (obj->format) {
129 case BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS:
130 visit_type_QCryptoBlockInfoLUKS_members(v, &obj->u.luks, &err);
131 break;
132 case BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES:
133 break;
134 default:
135 abort();
136 }
137
138out:
139 error_propagate(errp, err);
140}
141
142void visit_type_ImageInfoSpecificQCow2Encryption(Visitor *v, const char *name, ImageInfoSpecificQCow2Encryption **obj, Error **errp)
143{
144 Error *err = NULL;
145
146 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfoSpecificQCow2Encryption), &err);
147 if (err) {
148 goto out;
149 }
150 if (!*obj) {
151 goto out_obj;
152 }
153 visit_type_ImageInfoSpecificQCow2Encryption_members(v, *obj, &err);
154 if (err) {
155 goto out_obj;
156 }
157 visit_check_struct(v, &err);
158out_obj:
159 visit_end_struct(v, (void **)obj);
160 if (err && visit_is_input(v)) {
161 qapi_free_ImageInfoSpecificQCow2Encryption(*obj);
162 *obj = NULL;
163 }
164out:
165 error_propagate(errp, err);
166}
167
168void visit_type_Qcow2BitmapInfoList(Visitor *v, const char *name, Qcow2BitmapInfoList **obj, Error **errp)
169{
170 Error *err = NULL;
171 Qcow2BitmapInfoList *tail;
172 size_t size = sizeof(**obj);
173
174 visit_start_list(v, name, (GenericList **)obj, size, &err);
175 if (err) {
176 goto out;
177 }
178
179 for (tail = *obj; tail;
180 tail = (Qcow2BitmapInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
181 visit_type_Qcow2BitmapInfo(v, NULL, &tail->value, &err);
182 if (err) {
183 break;
184 }
185 }
186
187 if (!err) {
188 visit_check_list(v, &err);
189 }
190 visit_end_list(v, (void **)obj);
191 if (err && visit_is_input(v)) {
192 qapi_free_Qcow2BitmapInfoList(*obj);
193 *obj = NULL;
194 }
195out:
196 error_propagate(errp, err);
197}
198
199void visit_type_ImageInfoSpecificQCow2_members(Visitor *v, ImageInfoSpecificQCow2 *obj, Error **errp)
200{
201 Error *err = NULL;
202
203 visit_type_str(v, "compat", &obj->compat, &err);
204 if (err) {
205 goto out;
206 }
207 if (visit_optional(v, "data-file", &obj->has_data_file)) {
208 visit_type_str(v, "data-file", &obj->data_file, &err);
209 if (err) {
210 goto out;
211 }
212 }
213 if (visit_optional(v, "data-file-raw", &obj->has_data_file_raw)) {
214 visit_type_bool(v, "data-file-raw", &obj->data_file_raw, &err);
215 if (err) {
216 goto out;
217 }
218 }
219 if (visit_optional(v, "lazy-refcounts", &obj->has_lazy_refcounts)) {
220 visit_type_bool(v, "lazy-refcounts", &obj->lazy_refcounts, &err);
221 if (err) {
222 goto out;
223 }
224 }
225 if (visit_optional(v, "corrupt", &obj->has_corrupt)) {
226 visit_type_bool(v, "corrupt", &obj->corrupt, &err);
227 if (err) {
228 goto out;
229 }
230 }
231 visit_type_int(v, "refcount-bits", &obj->refcount_bits, &err);
232 if (err) {
233 goto out;
234 }
235 if (visit_optional(v, "encrypt", &obj->has_encrypt)) {
236 visit_type_ImageInfoSpecificQCow2Encryption(v, "encrypt", &obj->encrypt, &err);
237 if (err) {
238 goto out;
239 }
240 }
241 if (visit_optional(v, "bitmaps", &obj->has_bitmaps)) {
242 visit_type_Qcow2BitmapInfoList(v, "bitmaps", &obj->bitmaps, &err);
243 if (err) {
244 goto out;
245 }
246 }
247
248out:
249 error_propagate(errp, err);
250}
251
252void visit_type_ImageInfoSpecificQCow2(Visitor *v, const char *name, ImageInfoSpecificQCow2 **obj, Error **errp)
253{
254 Error *err = NULL;
255
256 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfoSpecificQCow2), &err);
257 if (err) {
258 goto out;
259 }
260 if (!*obj) {
261 goto out_obj;
262 }
263 visit_type_ImageInfoSpecificQCow2_members(v, *obj, &err);
264 if (err) {
265 goto out_obj;
266 }
267 visit_check_struct(v, &err);
268out_obj:
269 visit_end_struct(v, (void **)obj);
270 if (err && visit_is_input(v)) {
271 qapi_free_ImageInfoSpecificQCow2(*obj);
272 *obj = NULL;
273 }
274out:
275 error_propagate(errp, err);
276}
277
278void visit_type_ImageInfoList(Visitor *v, const char *name, ImageInfoList **obj, Error **errp)
279{
280 Error *err = NULL;
281 ImageInfoList *tail;
282 size_t size = sizeof(**obj);
283
284 visit_start_list(v, name, (GenericList **)obj, size, &err);
285 if (err) {
286 goto out;
287 }
288
289 for (tail = *obj; tail;
290 tail = (ImageInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
291 visit_type_ImageInfo(v, NULL, &tail->value, &err);
292 if (err) {
293 break;
294 }
295 }
296
297 if (!err) {
298 visit_check_list(v, &err);
299 }
300 visit_end_list(v, (void **)obj);
301 if (err && visit_is_input(v)) {
302 qapi_free_ImageInfoList(*obj);
303 *obj = NULL;
304 }
305out:
306 error_propagate(errp, err);
307}
308
309void visit_type_ImageInfoSpecificVmdk_members(Visitor *v, ImageInfoSpecificVmdk *obj, Error **errp)
310{
311 Error *err = NULL;
312
313 visit_type_str(v, "create-type", &obj->create_type, &err);
314 if (err) {
315 goto out;
316 }
317 visit_type_int(v, "cid", &obj->cid, &err);
318 if (err) {
319 goto out;
320 }
321 visit_type_int(v, "parent-cid", &obj->parent_cid, &err);
322 if (err) {
323 goto out;
324 }
325 visit_type_ImageInfoList(v, "extents", &obj->extents, &err);
326 if (err) {
327 goto out;
328 }
329
330out:
331 error_propagate(errp, err);
332}
333
334void visit_type_ImageInfoSpecificVmdk(Visitor *v, const char *name, ImageInfoSpecificVmdk **obj, Error **errp)
335{
336 Error *err = NULL;
337
338 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfoSpecificVmdk), &err);
339 if (err) {
340 goto out;
341 }
342 if (!*obj) {
343 goto out_obj;
344 }
345 visit_type_ImageInfoSpecificVmdk_members(v, *obj, &err);
346 if (err) {
347 goto out_obj;
348 }
349 visit_check_struct(v, &err);
350out_obj:
351 visit_end_struct(v, (void **)obj);
352 if (err && visit_is_input(v)) {
353 qapi_free_ImageInfoSpecificVmdk(*obj);
354 *obj = NULL;
355 }
356out:
357 error_propagate(errp, err);
358}
359
360void visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(Visitor *v, q_obj_ImageInfoSpecificQCow2_wrapper *obj, Error **errp)
361{
362 Error *err = NULL;
363
364 visit_type_ImageInfoSpecificQCow2(v, "data", &obj->data, &err);
365 if (err) {
366 goto out;
367 }
368
369out:
370 error_propagate(errp, err);
371}
372
373void visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(Visitor *v, q_obj_ImageInfoSpecificVmdk_wrapper *obj, Error **errp)
374{
375 Error *err = NULL;
376
377 visit_type_ImageInfoSpecificVmdk(v, "data", &obj->data, &err);
378 if (err) {
379 goto out;
380 }
381
382out:
383 error_propagate(errp, err);
384}
385
386void visit_type_q_obj_QCryptoBlockInfoLUKS_wrapper_members(Visitor *v, q_obj_QCryptoBlockInfoLUKS_wrapper *obj, Error **errp)
387{
388 Error *err = NULL;
389
390 visit_type_QCryptoBlockInfoLUKS(v, "data", &obj->data, &err);
391 if (err) {
392 goto out;
393 }
394
395out:
396 error_propagate(errp, err);
397}
398
399void visit_type_ImageInfoSpecificKind(Visitor *v, const char *name, ImageInfoSpecificKind *obj, Error **errp)
400{
401 int value = *obj;
402 visit_type_enum(v, name, &value, &ImageInfoSpecificKind_lookup, errp);
403 *obj = value;
404}
405
406void visit_type_ImageInfoSpecific_members(Visitor *v, ImageInfoSpecific *obj, Error **errp)
407{
408 Error *err = NULL;
409
410 visit_type_ImageInfoSpecificKind(v, "type", &obj->type, &err);
411 if (err) {
412 goto out;
413 }
414 switch (obj->type) {
415 case IMAGE_INFO_SPECIFIC_KIND_QCOW2:
416 visit_type_q_obj_ImageInfoSpecificQCow2_wrapper_members(v, &obj->u.qcow2, &err);
417 break;
418 case IMAGE_INFO_SPECIFIC_KIND_VMDK:
419 visit_type_q_obj_ImageInfoSpecificVmdk_wrapper_members(v, &obj->u.vmdk, &err);
420 break;
421 case IMAGE_INFO_SPECIFIC_KIND_LUKS:
422 visit_type_q_obj_QCryptoBlockInfoLUKS_wrapper_members(v, &obj->u.luks, &err);
423 break;
424 default:
425 abort();
426 }
427
428out:
429 error_propagate(errp, err);
430}
431
432void visit_type_ImageInfoSpecific(Visitor *v, const char *name, ImageInfoSpecific **obj, Error **errp)
433{
434 Error *err = NULL;
435
436 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfoSpecific), &err);
437 if (err) {
438 goto out;
439 }
440 if (!*obj) {
441 goto out_obj;
442 }
443 visit_type_ImageInfoSpecific_members(v, *obj, &err);
444 if (err) {
445 goto out_obj;
446 }
447 visit_check_struct(v, &err);
448out_obj:
449 visit_end_struct(v, (void **)obj);
450 if (err && visit_is_input(v)) {
451 qapi_free_ImageInfoSpecific(*obj);
452 *obj = NULL;
453 }
454out:
455 error_propagate(errp, err);
456}
457
458void visit_type_SnapshotInfoList(Visitor *v, const char *name, SnapshotInfoList **obj, Error **errp)
459{
460 Error *err = NULL;
461 SnapshotInfoList *tail;
462 size_t size = sizeof(**obj);
463
464 visit_start_list(v, name, (GenericList **)obj, size, &err);
465 if (err) {
466 goto out;
467 }
468
469 for (tail = *obj; tail;
470 tail = (SnapshotInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
471 visit_type_SnapshotInfo(v, NULL, &tail->value, &err);
472 if (err) {
473 break;
474 }
475 }
476
477 if (!err) {
478 visit_check_list(v, &err);
479 }
480 visit_end_list(v, (void **)obj);
481 if (err && visit_is_input(v)) {
482 qapi_free_SnapshotInfoList(*obj);
483 *obj = NULL;
484 }
485out:
486 error_propagate(errp, err);
487}
488
489void visit_type_ImageInfo_members(Visitor *v, ImageInfo *obj, Error **errp)
490{
491 Error *err = NULL;
492
493 visit_type_str(v, "filename", &obj->filename, &err);
494 if (err) {
495 goto out;
496 }
497 visit_type_str(v, "format", &obj->format, &err);
498 if (err) {
499 goto out;
500 }
501 if (visit_optional(v, "dirty-flag", &obj->has_dirty_flag)) {
502 visit_type_bool(v, "dirty-flag", &obj->dirty_flag, &err);
503 if (err) {
504 goto out;
505 }
506 }
507 if (visit_optional(v, "actual-size", &obj->has_actual_size)) {
508 visit_type_int(v, "actual-size", &obj->actual_size, &err);
509 if (err) {
510 goto out;
511 }
512 }
513 visit_type_int(v, "virtual-size", &obj->virtual_size, &err);
514 if (err) {
515 goto out;
516 }
517 if (visit_optional(v, "cluster-size", &obj->has_cluster_size)) {
518 visit_type_int(v, "cluster-size", &obj->cluster_size, &err);
519 if (err) {
520 goto out;
521 }
522 }
523 if (visit_optional(v, "encrypted", &obj->has_encrypted)) {
524 visit_type_bool(v, "encrypted", &obj->encrypted, &err);
525 if (err) {
526 goto out;
527 }
528 }
529 if (visit_optional(v, "compressed", &obj->has_compressed)) {
530 visit_type_bool(v, "compressed", &obj->compressed, &err);
531 if (err) {
532 goto out;
533 }
534 }
535 if (visit_optional(v, "backing-filename", &obj->has_backing_filename)) {
536 visit_type_str(v, "backing-filename", &obj->backing_filename, &err);
537 if (err) {
538 goto out;
539 }
540 }
541 if (visit_optional(v, "full-backing-filename", &obj->has_full_backing_filename)) {
542 visit_type_str(v, "full-backing-filename", &obj->full_backing_filename, &err);
543 if (err) {
544 goto out;
545 }
546 }
547 if (visit_optional(v, "backing-filename-format", &obj->has_backing_filename_format)) {
548 visit_type_str(v, "backing-filename-format", &obj->backing_filename_format, &err);
549 if (err) {
550 goto out;
551 }
552 }
553 if (visit_optional(v, "snapshots", &obj->has_snapshots)) {
554 visit_type_SnapshotInfoList(v, "snapshots", &obj->snapshots, &err);
555 if (err) {
556 goto out;
557 }
558 }
559 if (visit_optional(v, "backing-image", &obj->has_backing_image)) {
560 visit_type_ImageInfo(v, "backing-image", &obj->backing_image, &err);
561 if (err) {
562 goto out;
563 }
564 }
565 if (visit_optional(v, "format-specific", &obj->has_format_specific)) {
566 visit_type_ImageInfoSpecific(v, "format-specific", &obj->format_specific, &err);
567 if (err) {
568 goto out;
569 }
570 }
571
572out:
573 error_propagate(errp, err);
574}
575
576void visit_type_ImageInfo(Visitor *v, const char *name, ImageInfo **obj, Error **errp)
577{
578 Error *err = NULL;
579
580 visit_start_struct(v, name, (void **)obj, sizeof(ImageInfo), &err);
581 if (err) {
582 goto out;
583 }
584 if (!*obj) {
585 goto out_obj;
586 }
587 visit_type_ImageInfo_members(v, *obj, &err);
588 if (err) {
589 goto out_obj;
590 }
591 visit_check_struct(v, &err);
592out_obj:
593 visit_end_struct(v, (void **)obj);
594 if (err && visit_is_input(v)) {
595 qapi_free_ImageInfo(*obj);
596 *obj = NULL;
597 }
598out:
599 error_propagate(errp, err);
600}
601
602void visit_type_ImageCheck_members(Visitor *v, ImageCheck *obj, Error **errp)
603{
604 Error *err = NULL;
605
606 visit_type_str(v, "filename", &obj->filename, &err);
607 if (err) {
608 goto out;
609 }
610 visit_type_str(v, "format", &obj->format, &err);
611 if (err) {
612 goto out;
613 }
614 visit_type_int(v, "check-errors", &obj->check_errors, &err);
615 if (err) {
616 goto out;
617 }
618 if (visit_optional(v, "image-end-offset", &obj->has_image_end_offset)) {
619 visit_type_int(v, "image-end-offset", &obj->image_end_offset, &err);
620 if (err) {
621 goto out;
622 }
623 }
624 if (visit_optional(v, "corruptions", &obj->has_corruptions)) {
625 visit_type_int(v, "corruptions", &obj->corruptions, &err);
626 if (err) {
627 goto out;
628 }
629 }
630 if (visit_optional(v, "leaks", &obj->has_leaks)) {
631 visit_type_int(v, "leaks", &obj->leaks, &err);
632 if (err) {
633 goto out;
634 }
635 }
636 if (visit_optional(v, "corruptions-fixed", &obj->has_corruptions_fixed)) {
637 visit_type_int(v, "corruptions-fixed", &obj->corruptions_fixed, &err);
638 if (err) {
639 goto out;
640 }
641 }
642 if (visit_optional(v, "leaks-fixed", &obj->has_leaks_fixed)) {
643 visit_type_int(v, "leaks-fixed", &obj->leaks_fixed, &err);
644 if (err) {
645 goto out;
646 }
647 }
648 if (visit_optional(v, "total-clusters", &obj->has_total_clusters)) {
649 visit_type_int(v, "total-clusters", &obj->total_clusters, &err);
650 if (err) {
651 goto out;
652 }
653 }
654 if (visit_optional(v, "allocated-clusters", &obj->has_allocated_clusters)) {
655 visit_type_int(v, "allocated-clusters", &obj->allocated_clusters, &err);
656 if (err) {
657 goto out;
658 }
659 }
660 if (visit_optional(v, "fragmented-clusters", &obj->has_fragmented_clusters)) {
661 visit_type_int(v, "fragmented-clusters", &obj->fragmented_clusters, &err);
662 if (err) {
663 goto out;
664 }
665 }
666 if (visit_optional(v, "compressed-clusters", &obj->has_compressed_clusters)) {
667 visit_type_int(v, "compressed-clusters", &obj->compressed_clusters, &err);
668 if (err) {
669 goto out;
670 }
671 }
672
673out:
674 error_propagate(errp, err);
675}
676
677void visit_type_ImageCheck(Visitor *v, const char *name, ImageCheck **obj, Error **errp)
678{
679 Error *err = NULL;
680
681 visit_start_struct(v, name, (void **)obj, sizeof(ImageCheck), &err);
682 if (err) {
683 goto out;
684 }
685 if (!*obj) {
686 goto out_obj;
687 }
688 visit_type_ImageCheck_members(v, *obj, &err);
689 if (err) {
690 goto out_obj;
691 }
692 visit_check_struct(v, &err);
693out_obj:
694 visit_end_struct(v, (void **)obj);
695 if (err && visit_is_input(v)) {
696 qapi_free_ImageCheck(*obj);
697 *obj = NULL;
698 }
699out:
700 error_propagate(errp, err);
701}
702
703void visit_type_MapEntry_members(Visitor *v, MapEntry *obj, Error **errp)
704{
705 Error *err = NULL;
706
707 visit_type_int(v, "start", &obj->start, &err);
708 if (err) {
709 goto out;
710 }
711 visit_type_int(v, "length", &obj->length, &err);
712 if (err) {
713 goto out;
714 }
715 visit_type_bool(v, "data", &obj->data, &err);
716 if (err) {
717 goto out;
718 }
719 visit_type_bool(v, "zero", &obj->zero, &err);
720 if (err) {
721 goto out;
722 }
723 visit_type_int(v, "depth", &obj->depth, &err);
724 if (err) {
725 goto out;
726 }
727 if (visit_optional(v, "offset", &obj->has_offset)) {
728 visit_type_int(v, "offset", &obj->offset, &err);
729 if (err) {
730 goto out;
731 }
732 }
733 if (visit_optional(v, "filename", &obj->has_filename)) {
734 visit_type_str(v, "filename", &obj->filename, &err);
735 if (err) {
736 goto out;
737 }
738 }
739
740out:
741 error_propagate(errp, err);
742}
743
744void visit_type_MapEntry(Visitor *v, const char *name, MapEntry **obj, Error **errp)
745{
746 Error *err = NULL;
747
748 visit_start_struct(v, name, (void **)obj, sizeof(MapEntry), &err);
749 if (err) {
750 goto out;
751 }
752 if (!*obj) {
753 goto out_obj;
754 }
755 visit_type_MapEntry_members(v, *obj, &err);
756 if (err) {
757 goto out_obj;
758 }
759 visit_check_struct(v, &err);
760out_obj:
761 visit_end_struct(v, (void **)obj);
762 if (err && visit_is_input(v)) {
763 qapi_free_MapEntry(*obj);
764 *obj = NULL;
765 }
766out:
767 error_propagate(errp, err);
768}
769
770void visit_type_BlockdevCacheInfo_members(Visitor *v, BlockdevCacheInfo *obj, Error **errp)
771{
772 Error *err = NULL;
773
774 visit_type_bool(v, "writeback", &obj->writeback, &err);
775 if (err) {
776 goto out;
777 }
778 visit_type_bool(v, "direct", &obj->direct, &err);
779 if (err) {
780 goto out;
781 }
782 visit_type_bool(v, "no-flush", &obj->no_flush, &err);
783 if (err) {
784 goto out;
785 }
786
787out:
788 error_propagate(errp, err);
789}
790
791void visit_type_BlockdevCacheInfo(Visitor *v, const char *name, BlockdevCacheInfo **obj, Error **errp)
792{
793 Error *err = NULL;
794
795 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCacheInfo), &err);
796 if (err) {
797 goto out;
798 }
799 if (!*obj) {
800 goto out_obj;
801 }
802 visit_type_BlockdevCacheInfo_members(v, *obj, &err);
803 if (err) {
804 goto out_obj;
805 }
806 visit_check_struct(v, &err);
807out_obj:
808 visit_end_struct(v, (void **)obj);
809 if (err && visit_is_input(v)) {
810 qapi_free_BlockdevCacheInfo(*obj);
811 *obj = NULL;
812 }
813out:
814 error_propagate(errp, err);
815}
816
817void visit_type_BlockDirtyInfoList(Visitor *v, const char *name, BlockDirtyInfoList **obj, Error **errp)
818{
819 Error *err = NULL;
820 BlockDirtyInfoList *tail;
821 size_t size = sizeof(**obj);
822
823 visit_start_list(v, name, (GenericList **)obj, size, &err);
824 if (err) {
825 goto out;
826 }
827
828 for (tail = *obj; tail;
829 tail = (BlockDirtyInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
830 visit_type_BlockDirtyInfo(v, NULL, &tail->value, &err);
831 if (err) {
832 break;
833 }
834 }
835
836 if (!err) {
837 visit_check_list(v, &err);
838 }
839 visit_end_list(v, (void **)obj);
840 if (err && visit_is_input(v)) {
841 qapi_free_BlockDirtyInfoList(*obj);
842 *obj = NULL;
843 }
844out:
845 error_propagate(errp, err);
846}
847
848void visit_type_BlockDeviceInfo_members(Visitor *v, BlockDeviceInfo *obj, Error **errp)
849{
850 Error *err = NULL;
851
852 visit_type_str(v, "file", &obj->file, &err);
853 if (err) {
854 goto out;
855 }
856 if (visit_optional(v, "node-name", &obj->has_node_name)) {
857 visit_type_str(v, "node-name", &obj->node_name, &err);
858 if (err) {
859 goto out;
860 }
861 }
862 visit_type_bool(v, "ro", &obj->ro, &err);
863 if (err) {
864 goto out;
865 }
866 visit_type_str(v, "drv", &obj->drv, &err);
867 if (err) {
868 goto out;
869 }
870 if (visit_optional(v, "backing_file", &obj->has_backing_file)) {
871 visit_type_str(v, "backing_file", &obj->backing_file, &err);
872 if (err) {
873 goto out;
874 }
875 }
876 visit_type_int(v, "backing_file_depth", &obj->backing_file_depth, &err);
877 if (err) {
878 goto out;
879 }
880 visit_type_bool(v, "encrypted", &obj->encrypted, &err);
881 if (err) {
882 goto out;
883 }
884 visit_type_bool(v, "encryption_key_missing", &obj->encryption_key_missing, &err);
885 if (err) {
886 goto out;
887 }
888 visit_type_BlockdevDetectZeroesOptions(v, "detect_zeroes", &obj->detect_zeroes, &err);
889 if (err) {
890 goto out;
891 }
892 visit_type_int(v, "bps", &obj->bps, &err);
893 if (err) {
894 goto out;
895 }
896 visit_type_int(v, "bps_rd", &obj->bps_rd, &err);
897 if (err) {
898 goto out;
899 }
900 visit_type_int(v, "bps_wr", &obj->bps_wr, &err);
901 if (err) {
902 goto out;
903 }
904 visit_type_int(v, "iops", &obj->iops, &err);
905 if (err) {
906 goto out;
907 }
908 visit_type_int(v, "iops_rd", &obj->iops_rd, &err);
909 if (err) {
910 goto out;
911 }
912 visit_type_int(v, "iops_wr", &obj->iops_wr, &err);
913 if (err) {
914 goto out;
915 }
916 visit_type_ImageInfo(v, "image", &obj->image, &err);
917 if (err) {
918 goto out;
919 }
920 if (visit_optional(v, "bps_max", &obj->has_bps_max)) {
921 visit_type_int(v, "bps_max", &obj->bps_max, &err);
922 if (err) {
923 goto out;
924 }
925 }
926 if (visit_optional(v, "bps_rd_max", &obj->has_bps_rd_max)) {
927 visit_type_int(v, "bps_rd_max", &obj->bps_rd_max, &err);
928 if (err) {
929 goto out;
930 }
931 }
932 if (visit_optional(v, "bps_wr_max", &obj->has_bps_wr_max)) {
933 visit_type_int(v, "bps_wr_max", &obj->bps_wr_max, &err);
934 if (err) {
935 goto out;
936 }
937 }
938 if (visit_optional(v, "iops_max", &obj->has_iops_max)) {
939 visit_type_int(v, "iops_max", &obj->iops_max, &err);
940 if (err) {
941 goto out;
942 }
943 }
944 if (visit_optional(v, "iops_rd_max", &obj->has_iops_rd_max)) {
945 visit_type_int(v, "iops_rd_max", &obj->iops_rd_max, &err);
946 if (err) {
947 goto out;
948 }
949 }
950 if (visit_optional(v, "iops_wr_max", &obj->has_iops_wr_max)) {
951 visit_type_int(v, "iops_wr_max", &obj->iops_wr_max, &err);
952 if (err) {
953 goto out;
954 }
955 }
956 if (visit_optional(v, "bps_max_length", &obj->has_bps_max_length)) {
957 visit_type_int(v, "bps_max_length", &obj->bps_max_length, &err);
958 if (err) {
959 goto out;
960 }
961 }
962 if (visit_optional(v, "bps_rd_max_length", &obj->has_bps_rd_max_length)) {
963 visit_type_int(v, "bps_rd_max_length", &obj->bps_rd_max_length, &err);
964 if (err) {
965 goto out;
966 }
967 }
968 if (visit_optional(v, "bps_wr_max_length", &obj->has_bps_wr_max_length)) {
969 visit_type_int(v, "bps_wr_max_length", &obj->bps_wr_max_length, &err);
970 if (err) {
971 goto out;
972 }
973 }
974 if (visit_optional(v, "iops_max_length", &obj->has_iops_max_length)) {
975 visit_type_int(v, "iops_max_length", &obj->iops_max_length, &err);
976 if (err) {
977 goto out;
978 }
979 }
980 if (visit_optional(v, "iops_rd_max_length", &obj->has_iops_rd_max_length)) {
981 visit_type_int(v, "iops_rd_max_length", &obj->iops_rd_max_length, &err);
982 if (err) {
983 goto out;
984 }
985 }
986 if (visit_optional(v, "iops_wr_max_length", &obj->has_iops_wr_max_length)) {
987 visit_type_int(v, "iops_wr_max_length", &obj->iops_wr_max_length, &err);
988 if (err) {
989 goto out;
990 }
991 }
992 if (visit_optional(v, "iops_size", &obj->has_iops_size)) {
993 visit_type_int(v, "iops_size", &obj->iops_size, &err);
994 if (err) {
995 goto out;
996 }
997 }
998 if (visit_optional(v, "group", &obj->has_group)) {
999 visit_type_str(v, "group", &obj->group, &err);
1000 if (err) {
1001 goto out;
1002 }
1003 }
1004 visit_type_BlockdevCacheInfo(v, "cache", &obj->cache, &err);
1005 if (err) {
1006 goto out;
1007 }
1008 visit_type_int(v, "write_threshold", &obj->write_threshold, &err);
1009 if (err) {
1010 goto out;
1011 }
1012 if (visit_optional(v, "dirty-bitmaps", &obj->has_dirty_bitmaps)) {
1013 visit_type_BlockDirtyInfoList(v, "dirty-bitmaps", &obj->dirty_bitmaps, &err);
1014 if (err) {
1015 goto out;
1016 }
1017 }
1018
1019out:
1020 error_propagate(errp, err);
1021}
1022
1023void visit_type_BlockDeviceInfo(Visitor *v, const char *name, BlockDeviceInfo **obj, Error **errp)
1024{
1025 Error *err = NULL;
1026
1027 visit_start_struct(v, name, (void **)obj, sizeof(BlockDeviceInfo), &err);
1028 if (err) {
1029 goto out;
1030 }
1031 if (!*obj) {
1032 goto out_obj;
1033 }
1034 visit_type_BlockDeviceInfo_members(v, *obj, &err);
1035 if (err) {
1036 goto out_obj;
1037 }
1038 visit_check_struct(v, &err);
1039out_obj:
1040 visit_end_struct(v, (void **)obj);
1041 if (err && visit_is_input(v)) {
1042 qapi_free_BlockDeviceInfo(*obj);
1043 *obj = NULL;
1044 }
1045out:
1046 error_propagate(errp, err);
1047}
1048
1049void visit_type_BlockDeviceIoStatus(Visitor *v, const char *name, BlockDeviceIoStatus *obj, Error **errp)
1050{
1051 int value = *obj;
1052 visit_type_enum(v, name, &value, &BlockDeviceIoStatus_lookup, errp);
1053 *obj = value;
1054}
1055
1056void visit_type_BlockDeviceMapEntry_members(Visitor *v, BlockDeviceMapEntry *obj, Error **errp)
1057{
1058 Error *err = NULL;
1059
1060 visit_type_int(v, "start", &obj->start, &err);
1061 if (err) {
1062 goto out;
1063 }
1064 visit_type_int(v, "length", &obj->length, &err);
1065 if (err) {
1066 goto out;
1067 }
1068 visit_type_int(v, "depth", &obj->depth, &err);
1069 if (err) {
1070 goto out;
1071 }
1072 visit_type_bool(v, "zero", &obj->zero, &err);
1073 if (err) {
1074 goto out;
1075 }
1076 visit_type_bool(v, "data", &obj->data, &err);
1077 if (err) {
1078 goto out;
1079 }
1080 if (visit_optional(v, "offset", &obj->has_offset)) {
1081 visit_type_int(v, "offset", &obj->offset, &err);
1082 if (err) {
1083 goto out;
1084 }
1085 }
1086
1087out:
1088 error_propagate(errp, err);
1089}
1090
1091void visit_type_BlockDeviceMapEntry(Visitor *v, const char *name, BlockDeviceMapEntry **obj, Error **errp)
1092{
1093 Error *err = NULL;
1094
1095 visit_start_struct(v, name, (void **)obj, sizeof(BlockDeviceMapEntry), &err);
1096 if (err) {
1097 goto out;
1098 }
1099 if (!*obj) {
1100 goto out_obj;
1101 }
1102 visit_type_BlockDeviceMapEntry_members(v, *obj, &err);
1103 if (err) {
1104 goto out_obj;
1105 }
1106 visit_check_struct(v, &err);
1107out_obj:
1108 visit_end_struct(v, (void **)obj);
1109 if (err && visit_is_input(v)) {
1110 qapi_free_BlockDeviceMapEntry(*obj);
1111 *obj = NULL;
1112 }
1113out:
1114 error_propagate(errp, err);
1115}
1116
1117void visit_type_DirtyBitmapStatus(Visitor *v, const char *name, DirtyBitmapStatus *obj, Error **errp)
1118{
1119 int value = *obj;
1120 visit_type_enum(v, name, &value, &DirtyBitmapStatus_lookup, errp);
1121 *obj = value;
1122}
1123
1124void visit_type_BlockDirtyInfo_members(Visitor *v, BlockDirtyInfo *obj, Error **errp)
1125{
1126 Error *err = NULL;
1127
1128 if (visit_optional(v, "name", &obj->has_name)) {
1129 visit_type_str(v, "name", &obj->name, &err);
1130 if (err) {
1131 goto out;
1132 }
1133 }
1134 visit_type_int(v, "count", &obj->count, &err);
1135 if (err) {
1136 goto out;
1137 }
1138 visit_type_uint32(v, "granularity", &obj->granularity, &err);
1139 if (err) {
1140 goto out;
1141 }
1142 visit_type_bool(v, "recording", &obj->recording, &err);
1143 if (err) {
1144 goto out;
1145 }
1146 visit_type_bool(v, "busy", &obj->busy, &err);
1147 if (err) {
1148 goto out;
1149 }
1150 visit_type_DirtyBitmapStatus(v, "status", &obj->status, &err);
1151 if (err) {
1152 goto out;
1153 }
1154 visit_type_bool(v, "persistent", &obj->persistent, &err);
1155 if (err) {
1156 goto out;
1157 }
1158 if (visit_optional(v, "inconsistent", &obj->has_inconsistent)) {
1159 visit_type_bool(v, "inconsistent", &obj->inconsistent, &err);
1160 if (err) {
1161 goto out;
1162 }
1163 }
1164
1165out:
1166 error_propagate(errp, err);
1167}
1168
1169void visit_type_BlockDirtyInfo(Visitor *v, const char *name, BlockDirtyInfo **obj, Error **errp)
1170{
1171 Error *err = NULL;
1172
1173 visit_start_struct(v, name, (void **)obj, sizeof(BlockDirtyInfo), &err);
1174 if (err) {
1175 goto out;
1176 }
1177 if (!*obj) {
1178 goto out_obj;
1179 }
1180 visit_type_BlockDirtyInfo_members(v, *obj, &err);
1181 if (err) {
1182 goto out_obj;
1183 }
1184 visit_check_struct(v, &err);
1185out_obj:
1186 visit_end_struct(v, (void **)obj);
1187 if (err && visit_is_input(v)) {
1188 qapi_free_BlockDirtyInfo(*obj);
1189 *obj = NULL;
1190 }
1191out:
1192 error_propagate(errp, err);
1193}
1194
1195void visit_type_Qcow2BitmapInfoFlags(Visitor *v, const char *name, Qcow2BitmapInfoFlags *obj, Error **errp)
1196{
1197 int value = *obj;
1198 visit_type_enum(v, name, &value, &Qcow2BitmapInfoFlags_lookup, errp);
1199 *obj = value;
1200}
1201
1202void visit_type_Qcow2BitmapInfoFlagsList(Visitor *v, const char *name, Qcow2BitmapInfoFlagsList **obj, Error **errp)
1203{
1204 Error *err = NULL;
1205 Qcow2BitmapInfoFlagsList *tail;
1206 size_t size = sizeof(**obj);
1207
1208 visit_start_list(v, name, (GenericList **)obj, size, &err);
1209 if (err) {
1210 goto out;
1211 }
1212
1213 for (tail = *obj; tail;
1214 tail = (Qcow2BitmapInfoFlagsList *)visit_next_list(v, (GenericList *)tail, size)) {
1215 visit_type_Qcow2BitmapInfoFlags(v, NULL, &tail->value, &err);
1216 if (err) {
1217 break;
1218 }
1219 }
1220
1221 if (!err) {
1222 visit_check_list(v, &err);
1223 }
1224 visit_end_list(v, (void **)obj);
1225 if (err && visit_is_input(v)) {
1226 qapi_free_Qcow2BitmapInfoFlagsList(*obj);
1227 *obj = NULL;
1228 }
1229out:
1230 error_propagate(errp, err);
1231}
1232
1233void visit_type_Qcow2BitmapInfo_members(Visitor *v, Qcow2BitmapInfo *obj, Error **errp)
1234{
1235 Error *err = NULL;
1236
1237 visit_type_str(v, "name", &obj->name, &err);
1238 if (err) {
1239 goto out;
1240 }
1241 visit_type_uint32(v, "granularity", &obj->granularity, &err);
1242 if (err) {
1243 goto out;
1244 }
1245 visit_type_Qcow2BitmapInfoFlagsList(v, "flags", &obj->flags, &err);
1246 if (err) {
1247 goto out;
1248 }
1249
1250out:
1251 error_propagate(errp, err);
1252}
1253
1254void visit_type_Qcow2BitmapInfo(Visitor *v, const char *name, Qcow2BitmapInfo **obj, Error **errp)
1255{
1256 Error *err = NULL;
1257
1258 visit_start_struct(v, name, (void **)obj, sizeof(Qcow2BitmapInfo), &err);
1259 if (err) {
1260 goto out;
1261 }
1262 if (!*obj) {
1263 goto out_obj;
1264 }
1265 visit_type_Qcow2BitmapInfo_members(v, *obj, &err);
1266 if (err) {
1267 goto out_obj;
1268 }
1269 visit_check_struct(v, &err);
1270out_obj:
1271 visit_end_struct(v, (void **)obj);
1272 if (err && visit_is_input(v)) {
1273 qapi_free_Qcow2BitmapInfo(*obj);
1274 *obj = NULL;
1275 }
1276out:
1277 error_propagate(errp, err);
1278}
1279
1280void visit_type_BlockLatencyHistogramInfo_members(Visitor *v, BlockLatencyHistogramInfo *obj, Error **errp)
1281{
1282 Error *err = NULL;
1283
1284 visit_type_uint64List(v, "boundaries", &obj->boundaries, &err);
1285 if (err) {
1286 goto out;
1287 }
1288 visit_type_uint64List(v, "bins", &obj->bins, &err);
1289 if (err) {
1290 goto out;
1291 }
1292
1293out:
1294 error_propagate(errp, err);
1295}
1296
1297void visit_type_BlockLatencyHistogramInfo(Visitor *v, const char *name, BlockLatencyHistogramInfo **obj, Error **errp)
1298{
1299 Error *err = NULL;
1300
1301 visit_start_struct(v, name, (void **)obj, sizeof(BlockLatencyHistogramInfo), &err);
1302 if (err) {
1303 goto out;
1304 }
1305 if (!*obj) {
1306 goto out_obj;
1307 }
1308 visit_type_BlockLatencyHistogramInfo_members(v, *obj, &err);
1309 if (err) {
1310 goto out_obj;
1311 }
1312 visit_check_struct(v, &err);
1313out_obj:
1314 visit_end_struct(v, (void **)obj);
1315 if (err && visit_is_input(v)) {
1316 qapi_free_BlockLatencyHistogramInfo(*obj);
1317 *obj = NULL;
1318 }
1319out:
1320 error_propagate(errp, err);
1321}
1322
1323void visit_type_q_obj_block_latency_histogram_set_arg_members(Visitor *v, q_obj_block_latency_histogram_set_arg *obj, Error **errp)
1324{
1325 Error *err = NULL;
1326
1327 visit_type_str(v, "id", &obj->id, &err);
1328 if (err) {
1329 goto out;
1330 }
1331 if (visit_optional(v, "boundaries", &obj->has_boundaries)) {
1332 visit_type_uint64List(v, "boundaries", &obj->boundaries, &err);
1333 if (err) {
1334 goto out;
1335 }
1336 }
1337 if (visit_optional(v, "boundaries-read", &obj->has_boundaries_read)) {
1338 visit_type_uint64List(v, "boundaries-read", &obj->boundaries_read, &err);
1339 if (err) {
1340 goto out;
1341 }
1342 }
1343 if (visit_optional(v, "boundaries-write", &obj->has_boundaries_write)) {
1344 visit_type_uint64List(v, "boundaries-write", &obj->boundaries_write, &err);
1345 if (err) {
1346 goto out;
1347 }
1348 }
1349 if (visit_optional(v, "boundaries-flush", &obj->has_boundaries_flush)) {
1350 visit_type_uint64List(v, "boundaries-flush", &obj->boundaries_flush, &err);
1351 if (err) {
1352 goto out;
1353 }
1354 }
1355
1356out:
1357 error_propagate(errp, err);
1358}
1359
1360void visit_type_BlockInfo_members(Visitor *v, BlockInfo *obj, Error **errp)
1361{
1362 Error *err = NULL;
1363
1364 visit_type_str(v, "device", &obj->device, &err);
1365 if (err) {
1366 goto out;
1367 }
1368 if (visit_optional(v, "qdev", &obj->has_qdev)) {
1369 visit_type_str(v, "qdev", &obj->qdev, &err);
1370 if (err) {
1371 goto out;
1372 }
1373 }
1374 visit_type_str(v, "type", &obj->type, &err);
1375 if (err) {
1376 goto out;
1377 }
1378 visit_type_bool(v, "removable", &obj->removable, &err);
1379 if (err) {
1380 goto out;
1381 }
1382 visit_type_bool(v, "locked", &obj->locked, &err);
1383 if (err) {
1384 goto out;
1385 }
1386 if (visit_optional(v, "inserted", &obj->has_inserted)) {
1387 visit_type_BlockDeviceInfo(v, "inserted", &obj->inserted, &err);
1388 if (err) {
1389 goto out;
1390 }
1391 }
1392 if (visit_optional(v, "tray_open", &obj->has_tray_open)) {
1393 visit_type_bool(v, "tray_open", &obj->tray_open, &err);
1394 if (err) {
1395 goto out;
1396 }
1397 }
1398 if (visit_optional(v, "io-status", &obj->has_io_status)) {
1399 visit_type_BlockDeviceIoStatus(v, "io-status", &obj->io_status, &err);
1400 if (err) {
1401 goto out;
1402 }
1403 }
1404 if (visit_optional(v, "dirty-bitmaps", &obj->has_dirty_bitmaps)) {
1405 visit_type_BlockDirtyInfoList(v, "dirty-bitmaps", &obj->dirty_bitmaps, &err);
1406 if (err) {
1407 goto out;
1408 }
1409 }
1410
1411out:
1412 error_propagate(errp, err);
1413}
1414
1415void visit_type_BlockInfo(Visitor *v, const char *name, BlockInfo **obj, Error **errp)
1416{
1417 Error *err = NULL;
1418
1419 visit_start_struct(v, name, (void **)obj, sizeof(BlockInfo), &err);
1420 if (err) {
1421 goto out;
1422 }
1423 if (!*obj) {
1424 goto out_obj;
1425 }
1426 visit_type_BlockInfo_members(v, *obj, &err);
1427 if (err) {
1428 goto out_obj;
1429 }
1430 visit_check_struct(v, &err);
1431out_obj:
1432 visit_end_struct(v, (void **)obj);
1433 if (err && visit_is_input(v)) {
1434 qapi_free_BlockInfo(*obj);
1435 *obj = NULL;
1436 }
1437out:
1438 error_propagate(errp, err);
1439}
1440
1441void visit_type_BlockMeasureInfo_members(Visitor *v, BlockMeasureInfo *obj, Error **errp)
1442{
1443 Error *err = NULL;
1444
1445 visit_type_int(v, "required", &obj->required, &err);
1446 if (err) {
1447 goto out;
1448 }
1449 visit_type_int(v, "fully-allocated", &obj->fully_allocated, &err);
1450 if (err) {
1451 goto out;
1452 }
1453
1454out:
1455 error_propagate(errp, err);
1456}
1457
1458void visit_type_BlockMeasureInfo(Visitor *v, const char *name, BlockMeasureInfo **obj, Error **errp)
1459{
1460 Error *err = NULL;
1461
1462 visit_start_struct(v, name, (void **)obj, sizeof(BlockMeasureInfo), &err);
1463 if (err) {
1464 goto out;
1465 }
1466 if (!*obj) {
1467 goto out_obj;
1468 }
1469 visit_type_BlockMeasureInfo_members(v, *obj, &err);
1470 if (err) {
1471 goto out_obj;
1472 }
1473 visit_check_struct(v, &err);
1474out_obj:
1475 visit_end_struct(v, (void **)obj);
1476 if (err && visit_is_input(v)) {
1477 qapi_free_BlockMeasureInfo(*obj);
1478 *obj = NULL;
1479 }
1480out:
1481 error_propagate(errp, err);
1482}
1483
1484void visit_type_BlockInfoList(Visitor *v, const char *name, BlockInfoList **obj, Error **errp)
1485{
1486 Error *err = NULL;
1487 BlockInfoList *tail;
1488 size_t size = sizeof(**obj);
1489
1490 visit_start_list(v, name, (GenericList **)obj, size, &err);
1491 if (err) {
1492 goto out;
1493 }
1494
1495 for (tail = *obj; tail;
1496 tail = (BlockInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
1497 visit_type_BlockInfo(v, NULL, &tail->value, &err);
1498 if (err) {
1499 break;
1500 }
1501 }
1502
1503 if (!err) {
1504 visit_check_list(v, &err);
1505 }
1506 visit_end_list(v, (void **)obj);
1507 if (err && visit_is_input(v)) {
1508 qapi_free_BlockInfoList(*obj);
1509 *obj = NULL;
1510 }
1511out:
1512 error_propagate(errp, err);
1513}
1514
1515void visit_type_BlockDeviceTimedStats_members(Visitor *v, BlockDeviceTimedStats *obj, Error **errp)
1516{
1517 Error *err = NULL;
1518
1519 visit_type_int(v, "interval_length", &obj->interval_length, &err);
1520 if (err) {
1521 goto out;
1522 }
1523 visit_type_int(v, "min_rd_latency_ns", &obj->min_rd_latency_ns, &err);
1524 if (err) {
1525 goto out;
1526 }
1527 visit_type_int(v, "max_rd_latency_ns", &obj->max_rd_latency_ns, &err);
1528 if (err) {
1529 goto out;
1530 }
1531 visit_type_int(v, "avg_rd_latency_ns", &obj->avg_rd_latency_ns, &err);
1532 if (err) {
1533 goto out;
1534 }
1535 visit_type_int(v, "min_wr_latency_ns", &obj->min_wr_latency_ns, &err);
1536 if (err) {
1537 goto out;
1538 }
1539 visit_type_int(v, "max_wr_latency_ns", &obj->max_wr_latency_ns, &err);
1540 if (err) {
1541 goto out;
1542 }
1543 visit_type_int(v, "avg_wr_latency_ns", &obj->avg_wr_latency_ns, &err);
1544 if (err) {
1545 goto out;
1546 }
1547 visit_type_int(v, "min_flush_latency_ns", &obj->min_flush_latency_ns, &err);
1548 if (err) {
1549 goto out;
1550 }
1551 visit_type_int(v, "max_flush_latency_ns", &obj->max_flush_latency_ns, &err);
1552 if (err) {
1553 goto out;
1554 }
1555 visit_type_int(v, "avg_flush_latency_ns", &obj->avg_flush_latency_ns, &err);
1556 if (err) {
1557 goto out;
1558 }
1559 visit_type_number(v, "avg_rd_queue_depth", &obj->avg_rd_queue_depth, &err);
1560 if (err) {
1561 goto out;
1562 }
1563 visit_type_number(v, "avg_wr_queue_depth", &obj->avg_wr_queue_depth, &err);
1564 if (err) {
1565 goto out;
1566 }
1567
1568out:
1569 error_propagate(errp, err);
1570}
1571
1572void visit_type_BlockDeviceTimedStats(Visitor *v, const char *name, BlockDeviceTimedStats **obj, Error **errp)
1573{
1574 Error *err = NULL;
1575
1576 visit_start_struct(v, name, (void **)obj, sizeof(BlockDeviceTimedStats), &err);
1577 if (err) {
1578 goto out;
1579 }
1580 if (!*obj) {
1581 goto out_obj;
1582 }
1583 visit_type_BlockDeviceTimedStats_members(v, *obj, &err);
1584 if (err) {
1585 goto out_obj;
1586 }
1587 visit_check_struct(v, &err);
1588out_obj:
1589 visit_end_struct(v, (void **)obj);
1590 if (err && visit_is_input(v)) {
1591 qapi_free_BlockDeviceTimedStats(*obj);
1592 *obj = NULL;
1593 }
1594out:
1595 error_propagate(errp, err);
1596}
1597
1598void visit_type_BlockDeviceTimedStatsList(Visitor *v, const char *name, BlockDeviceTimedStatsList **obj, Error **errp)
1599{
1600 Error *err = NULL;
1601 BlockDeviceTimedStatsList *tail;
1602 size_t size = sizeof(**obj);
1603
1604 visit_start_list(v, name, (GenericList **)obj, size, &err);
1605 if (err) {
1606 goto out;
1607 }
1608
1609 for (tail = *obj; tail;
1610 tail = (BlockDeviceTimedStatsList *)visit_next_list(v, (GenericList *)tail, size)) {
1611 visit_type_BlockDeviceTimedStats(v, NULL, &tail->value, &err);
1612 if (err) {
1613 break;
1614 }
1615 }
1616
1617 if (!err) {
1618 visit_check_list(v, &err);
1619 }
1620 visit_end_list(v, (void **)obj);
1621 if (err && visit_is_input(v)) {
1622 qapi_free_BlockDeviceTimedStatsList(*obj);
1623 *obj = NULL;
1624 }
1625out:
1626 error_propagate(errp, err);
1627}
1628
1629void visit_type_BlockDeviceStats_members(Visitor *v, BlockDeviceStats *obj, Error **errp)
1630{
1631 Error *err = NULL;
1632
1633 visit_type_int(v, "rd_bytes", &obj->rd_bytes, &err);
1634 if (err) {
1635 goto out;
1636 }
1637 visit_type_int(v, "wr_bytes", &obj->wr_bytes, &err);
1638 if (err) {
1639 goto out;
1640 }
1641 visit_type_int(v, "rd_operations", &obj->rd_operations, &err);
1642 if (err) {
1643 goto out;
1644 }
1645 visit_type_int(v, "wr_operations", &obj->wr_operations, &err);
1646 if (err) {
1647 goto out;
1648 }
1649 visit_type_int(v, "flush_operations", &obj->flush_operations, &err);
1650 if (err) {
1651 goto out;
1652 }
1653 visit_type_int(v, "flush_total_time_ns", &obj->flush_total_time_ns, &err);
1654 if (err) {
1655 goto out;
1656 }
1657 visit_type_int(v, "wr_total_time_ns", &obj->wr_total_time_ns, &err);
1658 if (err) {
1659 goto out;
1660 }
1661 visit_type_int(v, "rd_total_time_ns", &obj->rd_total_time_ns, &err);
1662 if (err) {
1663 goto out;
1664 }
1665 visit_type_int(v, "wr_highest_offset", &obj->wr_highest_offset, &err);
1666 if (err) {
1667 goto out;
1668 }
1669 visit_type_int(v, "rd_merged", &obj->rd_merged, &err);
1670 if (err) {
1671 goto out;
1672 }
1673 visit_type_int(v, "wr_merged", &obj->wr_merged, &err);
1674 if (err) {
1675 goto out;
1676 }
1677 if (visit_optional(v, "idle_time_ns", &obj->has_idle_time_ns)) {
1678 visit_type_int(v, "idle_time_ns", &obj->idle_time_ns, &err);
1679 if (err) {
1680 goto out;
1681 }
1682 }
1683 visit_type_int(v, "failed_rd_operations", &obj->failed_rd_operations, &err);
1684 if (err) {
1685 goto out;
1686 }
1687 visit_type_int(v, "failed_wr_operations", &obj->failed_wr_operations, &err);
1688 if (err) {
1689 goto out;
1690 }
1691 visit_type_int(v, "failed_flush_operations", &obj->failed_flush_operations, &err);
1692 if (err) {
1693 goto out;
1694 }
1695 visit_type_int(v, "invalid_rd_operations", &obj->invalid_rd_operations, &err);
1696 if (err) {
1697 goto out;
1698 }
1699 visit_type_int(v, "invalid_wr_operations", &obj->invalid_wr_operations, &err);
1700 if (err) {
1701 goto out;
1702 }
1703 visit_type_int(v, "invalid_flush_operations", &obj->invalid_flush_operations, &err);
1704 if (err) {
1705 goto out;
1706 }
1707 visit_type_bool(v, "account_invalid", &obj->account_invalid, &err);
1708 if (err) {
1709 goto out;
1710 }
1711 visit_type_bool(v, "account_failed", &obj->account_failed, &err);
1712 if (err) {
1713 goto out;
1714 }
1715 visit_type_BlockDeviceTimedStatsList(v, "timed_stats", &obj->timed_stats, &err);
1716 if (err) {
1717 goto out;
1718 }
1719 if (visit_optional(v, "rd_latency_histogram", &obj->has_rd_latency_histogram)) {
1720 visit_type_BlockLatencyHistogramInfo(v, "rd_latency_histogram", &obj->rd_latency_histogram, &err);
1721 if (err) {
1722 goto out;
1723 }
1724 }
1725 if (visit_optional(v, "wr_latency_histogram", &obj->has_wr_latency_histogram)) {
1726 visit_type_BlockLatencyHistogramInfo(v, "wr_latency_histogram", &obj->wr_latency_histogram, &err);
1727 if (err) {
1728 goto out;
1729 }
1730 }
1731 if (visit_optional(v, "flush_latency_histogram", &obj->has_flush_latency_histogram)) {
1732 visit_type_BlockLatencyHistogramInfo(v, "flush_latency_histogram", &obj->flush_latency_histogram, &err);
1733 if (err) {
1734 goto out;
1735 }
1736 }
1737
1738out:
1739 error_propagate(errp, err);
1740}
1741
1742void visit_type_BlockDeviceStats(Visitor *v, const char *name, BlockDeviceStats **obj, Error **errp)
1743{
1744 Error *err = NULL;
1745
1746 visit_start_struct(v, name, (void **)obj, sizeof(BlockDeviceStats), &err);
1747 if (err) {
1748 goto out;
1749 }
1750 if (!*obj) {
1751 goto out_obj;
1752 }
1753 visit_type_BlockDeviceStats_members(v, *obj, &err);
1754 if (err) {
1755 goto out_obj;
1756 }
1757 visit_check_struct(v, &err);
1758out_obj:
1759 visit_end_struct(v, (void **)obj);
1760 if (err && visit_is_input(v)) {
1761 qapi_free_BlockDeviceStats(*obj);
1762 *obj = NULL;
1763 }
1764out:
1765 error_propagate(errp, err);
1766}
1767
1768void visit_type_BlockStats_members(Visitor *v, BlockStats *obj, Error **errp)
1769{
1770 Error *err = NULL;
1771
1772 if (visit_optional(v, "device", &obj->has_device)) {
1773 visit_type_str(v, "device", &obj->device, &err);
1774 if (err) {
1775 goto out;
1776 }
1777 }
1778 if (visit_optional(v, "qdev", &obj->has_qdev)) {
1779 visit_type_str(v, "qdev", &obj->qdev, &err);
1780 if (err) {
1781 goto out;
1782 }
1783 }
1784 if (visit_optional(v, "node-name", &obj->has_node_name)) {
1785 visit_type_str(v, "node-name", &obj->node_name, &err);
1786 if (err) {
1787 goto out;
1788 }
1789 }
1790 visit_type_BlockDeviceStats(v, "stats", &obj->stats, &err);
1791 if (err) {
1792 goto out;
1793 }
1794 if (visit_optional(v, "parent", &obj->has_parent)) {
1795 visit_type_BlockStats(v, "parent", &obj->parent, &err);
1796 if (err) {
1797 goto out;
1798 }
1799 }
1800 if (visit_optional(v, "backing", &obj->has_backing)) {
1801 visit_type_BlockStats(v, "backing", &obj->backing, &err);
1802 if (err) {
1803 goto out;
1804 }
1805 }
1806
1807out:
1808 error_propagate(errp, err);
1809}
1810
1811void visit_type_BlockStats(Visitor *v, const char *name, BlockStats **obj, Error **errp)
1812{
1813 Error *err = NULL;
1814
1815 visit_start_struct(v, name, (void **)obj, sizeof(BlockStats), &err);
1816 if (err) {
1817 goto out;
1818 }
1819 if (!*obj) {
1820 goto out_obj;
1821 }
1822 visit_type_BlockStats_members(v, *obj, &err);
1823 if (err) {
1824 goto out_obj;
1825 }
1826 visit_check_struct(v, &err);
1827out_obj:
1828 visit_end_struct(v, (void **)obj);
1829 if (err && visit_is_input(v)) {
1830 qapi_free_BlockStats(*obj);
1831 *obj = NULL;
1832 }
1833out:
1834 error_propagate(errp, err);
1835}
1836
1837void visit_type_q_obj_query_blockstats_arg_members(Visitor *v, q_obj_query_blockstats_arg *obj, Error **errp)
1838{
1839 Error *err = NULL;
1840
1841 if (visit_optional(v, "query-nodes", &obj->has_query_nodes)) {
1842 visit_type_bool(v, "query-nodes", &obj->query_nodes, &err);
1843 if (err) {
1844 goto out;
1845 }
1846 }
1847
1848out:
1849 error_propagate(errp, err);
1850}
1851
1852void visit_type_BlockStatsList(Visitor *v, const char *name, BlockStatsList **obj, Error **errp)
1853{
1854 Error *err = NULL;
1855 BlockStatsList *tail;
1856 size_t size = sizeof(**obj);
1857
1858 visit_start_list(v, name, (GenericList **)obj, size, &err);
1859 if (err) {
1860 goto out;
1861 }
1862
1863 for (tail = *obj; tail;
1864 tail = (BlockStatsList *)visit_next_list(v, (GenericList *)tail, size)) {
1865 visit_type_BlockStats(v, NULL, &tail->value, &err);
1866 if (err) {
1867 break;
1868 }
1869 }
1870
1871 if (!err) {
1872 visit_check_list(v, &err);
1873 }
1874 visit_end_list(v, (void **)obj);
1875 if (err && visit_is_input(v)) {
1876 qapi_free_BlockStatsList(*obj);
1877 *obj = NULL;
1878 }
1879out:
1880 error_propagate(errp, err);
1881}
1882
1883void visit_type_BlockdevOnError(Visitor *v, const char *name, BlockdevOnError *obj, Error **errp)
1884{
1885 int value = *obj;
1886 visit_type_enum(v, name, &value, &BlockdevOnError_lookup, errp);
1887 *obj = value;
1888}
1889
1890void visit_type_MirrorSyncMode(Visitor *v, const char *name, MirrorSyncMode *obj, Error **errp)
1891{
1892 int value = *obj;
1893 visit_type_enum(v, name, &value, &MirrorSyncMode_lookup, errp);
1894 *obj = value;
1895}
1896
1897void visit_type_BitmapSyncMode(Visitor *v, const char *name, BitmapSyncMode *obj, Error **errp)
1898{
1899 int value = *obj;
1900 visit_type_enum(v, name, &value, &BitmapSyncMode_lookup, errp);
1901 *obj = value;
1902}
1903
1904void visit_type_MirrorCopyMode(Visitor *v, const char *name, MirrorCopyMode *obj, Error **errp)
1905{
1906 int value = *obj;
1907 visit_type_enum(v, name, &value, &MirrorCopyMode_lookup, errp);
1908 *obj = value;
1909}
1910
1911void visit_type_BlockJobInfo_members(Visitor *v, BlockJobInfo *obj, Error **errp)
1912{
1913 Error *err = NULL;
1914
1915 visit_type_str(v, "type", &obj->type, &err);
1916 if (err) {
1917 goto out;
1918 }
1919 visit_type_str(v, "device", &obj->device, &err);
1920 if (err) {
1921 goto out;
1922 }
1923 visit_type_int(v, "len", &obj->len, &err);
1924 if (err) {
1925 goto out;
1926 }
1927 visit_type_int(v, "offset", &obj->offset, &err);
1928 if (err) {
1929 goto out;
1930 }
1931 visit_type_bool(v, "busy", &obj->busy, &err);
1932 if (err) {
1933 goto out;
1934 }
1935 visit_type_bool(v, "paused", &obj->paused, &err);
1936 if (err) {
1937 goto out;
1938 }
1939 visit_type_int(v, "speed", &obj->speed, &err);
1940 if (err) {
1941 goto out;
1942 }
1943 visit_type_BlockDeviceIoStatus(v, "io-status", &obj->io_status, &err);
1944 if (err) {
1945 goto out;
1946 }
1947 visit_type_bool(v, "ready", &obj->ready, &err);
1948 if (err) {
1949 goto out;
1950 }
1951 visit_type_JobStatus(v, "status", &obj->status, &err);
1952 if (err) {
1953 goto out;
1954 }
1955 visit_type_bool(v, "auto-finalize", &obj->auto_finalize, &err);
1956 if (err) {
1957 goto out;
1958 }
1959 visit_type_bool(v, "auto-dismiss", &obj->auto_dismiss, &err);
1960 if (err) {
1961 goto out;
1962 }
1963 if (visit_optional(v, "error", &obj->has_error)) {
1964 visit_type_str(v, "error", &obj->error, &err);
1965 if (err) {
1966 goto out;
1967 }
1968 }
1969
1970out:
1971 error_propagate(errp, err);
1972}
1973
1974void visit_type_BlockJobInfo(Visitor *v, const char *name, BlockJobInfo **obj, Error **errp)
1975{
1976 Error *err = NULL;
1977
1978 visit_start_struct(v, name, (void **)obj, sizeof(BlockJobInfo), &err);
1979 if (err) {
1980 goto out;
1981 }
1982 if (!*obj) {
1983 goto out_obj;
1984 }
1985 visit_type_BlockJobInfo_members(v, *obj, &err);
1986 if (err) {
1987 goto out_obj;
1988 }
1989 visit_check_struct(v, &err);
1990out_obj:
1991 visit_end_struct(v, (void **)obj);
1992 if (err && visit_is_input(v)) {
1993 qapi_free_BlockJobInfo(*obj);
1994 *obj = NULL;
1995 }
1996out:
1997 error_propagate(errp, err);
1998}
1999
2000void visit_type_BlockJobInfoList(Visitor *v, const char *name, BlockJobInfoList **obj, Error **errp)
2001{
2002 Error *err = NULL;
2003 BlockJobInfoList *tail;
2004 size_t size = sizeof(**obj);
2005
2006 visit_start_list(v, name, (GenericList **)obj, size, &err);
2007 if (err) {
2008 goto out;
2009 }
2010
2011 for (tail = *obj; tail;
2012 tail = (BlockJobInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
2013 visit_type_BlockJobInfo(v, NULL, &tail->value, &err);
2014 if (err) {
2015 break;
2016 }
2017 }
2018
2019 if (!err) {
2020 visit_check_list(v, &err);
2021 }
2022 visit_end_list(v, (void **)obj);
2023 if (err && visit_is_input(v)) {
2024 qapi_free_BlockJobInfoList(*obj);
2025 *obj = NULL;
2026 }
2027out:
2028 error_propagate(errp, err);
2029}
2030
2031void visit_type_q_obj_block_passwd_arg_members(Visitor *v, q_obj_block_passwd_arg *obj, Error **errp)
2032{
2033 Error *err = NULL;
2034
2035 if (visit_optional(v, "device", &obj->has_device)) {
2036 visit_type_str(v, "device", &obj->device, &err);
2037 if (err) {
2038 goto out;
2039 }
2040 }
2041 if (visit_optional(v, "node-name", &obj->has_node_name)) {
2042 visit_type_str(v, "node-name", &obj->node_name, &err);
2043 if (err) {
2044 goto out;
2045 }
2046 }
2047 visit_type_str(v, "password", &obj->password, &err);
2048 if (err) {
2049 goto out;
2050 }
2051
2052out:
2053 error_propagate(errp, err);
2054}
2055
2056void visit_type_q_obj_block_resize_arg_members(Visitor *v, q_obj_block_resize_arg *obj, Error **errp)
2057{
2058 Error *err = NULL;
2059
2060 if (visit_optional(v, "device", &obj->has_device)) {
2061 visit_type_str(v, "device", &obj->device, &err);
2062 if (err) {
2063 goto out;
2064 }
2065 }
2066 if (visit_optional(v, "node-name", &obj->has_node_name)) {
2067 visit_type_str(v, "node-name", &obj->node_name, &err);
2068 if (err) {
2069 goto out;
2070 }
2071 }
2072 visit_type_int(v, "size", &obj->size, &err);
2073 if (err) {
2074 goto out;
2075 }
2076
2077out:
2078 error_propagate(errp, err);
2079}
2080
2081void visit_type_NewImageMode(Visitor *v, const char *name, NewImageMode *obj, Error **errp)
2082{
2083 int value = *obj;
2084 visit_type_enum(v, name, &value, &NewImageMode_lookup, errp);
2085 *obj = value;
2086}
2087
2088void visit_type_BlockdevSnapshotSync_members(Visitor *v, BlockdevSnapshotSync *obj, Error **errp)
2089{
2090 Error *err = NULL;
2091
2092 if (visit_optional(v, "device", &obj->has_device)) {
2093 visit_type_str(v, "device", &obj->device, &err);
2094 if (err) {
2095 goto out;
2096 }
2097 }
2098 if (visit_optional(v, "node-name", &obj->has_node_name)) {
2099 visit_type_str(v, "node-name", &obj->node_name, &err);
2100 if (err) {
2101 goto out;
2102 }
2103 }
2104 visit_type_str(v, "snapshot-file", &obj->snapshot_file, &err);
2105 if (err) {
2106 goto out;
2107 }
2108 if (visit_optional(v, "snapshot-node-name", &obj->has_snapshot_node_name)) {
2109 visit_type_str(v, "snapshot-node-name", &obj->snapshot_node_name, &err);
2110 if (err) {
2111 goto out;
2112 }
2113 }
2114 if (visit_optional(v, "format", &obj->has_format)) {
2115 visit_type_str(v, "format", &obj->format, &err);
2116 if (err) {
2117 goto out;
2118 }
2119 }
2120 if (visit_optional(v, "mode", &obj->has_mode)) {
2121 visit_type_NewImageMode(v, "mode", &obj->mode, &err);
2122 if (err) {
2123 goto out;
2124 }
2125 }
2126
2127out:
2128 error_propagate(errp, err);
2129}
2130
2131void visit_type_BlockdevSnapshotSync(Visitor *v, const char *name, BlockdevSnapshotSync **obj, Error **errp)
2132{
2133 Error *err = NULL;
2134
2135 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevSnapshotSync), &err);
2136 if (err) {
2137 goto out;
2138 }
2139 if (!*obj) {
2140 goto out_obj;
2141 }
2142 visit_type_BlockdevSnapshotSync_members(v, *obj, &err);
2143 if (err) {
2144 goto out_obj;
2145 }
2146 visit_check_struct(v, &err);
2147out_obj:
2148 visit_end_struct(v, (void **)obj);
2149 if (err && visit_is_input(v)) {
2150 qapi_free_BlockdevSnapshotSync(*obj);
2151 *obj = NULL;
2152 }
2153out:
2154 error_propagate(errp, err);
2155}
2156
2157void visit_type_BlockdevSnapshot_members(Visitor *v, BlockdevSnapshot *obj, Error **errp)
2158{
2159 Error *err = NULL;
2160
2161 visit_type_str(v, "node", &obj->node, &err);
2162 if (err) {
2163 goto out;
2164 }
2165 visit_type_str(v, "overlay", &obj->overlay, &err);
2166 if (err) {
2167 goto out;
2168 }
2169
2170out:
2171 error_propagate(errp, err);
2172}
2173
2174void visit_type_BlockdevSnapshot(Visitor *v, const char *name, BlockdevSnapshot **obj, Error **errp)
2175{
2176 Error *err = NULL;
2177
2178 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevSnapshot), &err);
2179 if (err) {
2180 goto out;
2181 }
2182 if (!*obj) {
2183 goto out_obj;
2184 }
2185 visit_type_BlockdevSnapshot_members(v, *obj, &err);
2186 if (err) {
2187 goto out_obj;
2188 }
2189 visit_check_struct(v, &err);
2190out_obj:
2191 visit_end_struct(v, (void **)obj);
2192 if (err && visit_is_input(v)) {
2193 qapi_free_BlockdevSnapshot(*obj);
2194 *obj = NULL;
2195 }
2196out:
2197 error_propagate(errp, err);
2198}
2199
2200void visit_type_BackupCommon_members(Visitor *v, BackupCommon *obj, Error **errp)
2201{
2202 Error *err = NULL;
2203
2204 if (visit_optional(v, "job-id", &obj->has_job_id)) {
2205 visit_type_str(v, "job-id", &obj->job_id, &err);
2206 if (err) {
2207 goto out;
2208 }
2209 }
2210 visit_type_str(v, "device", &obj->device, &err);
2211 if (err) {
2212 goto out;
2213 }
2214 visit_type_MirrorSyncMode(v, "sync", &obj->sync, &err);
2215 if (err) {
2216 goto out;
2217 }
2218 if (visit_optional(v, "speed", &obj->has_speed)) {
2219 visit_type_int(v, "speed", &obj->speed, &err);
2220 if (err) {
2221 goto out;
2222 }
2223 }
2224 if (visit_optional(v, "bitmap", &obj->has_bitmap)) {
2225 visit_type_str(v, "bitmap", &obj->bitmap, &err);
2226 if (err) {
2227 goto out;
2228 }
2229 }
2230 if (visit_optional(v, "bitmap-mode", &obj->has_bitmap_mode)) {
2231 visit_type_BitmapSyncMode(v, "bitmap-mode", &obj->bitmap_mode, &err);
2232 if (err) {
2233 goto out;
2234 }
2235 }
2236 if (visit_optional(v, "compress", &obj->has_compress)) {
2237 visit_type_bool(v, "compress", &obj->compress, &err);
2238 if (err) {
2239 goto out;
2240 }
2241 }
2242 if (visit_optional(v, "on-source-error", &obj->has_on_source_error)) {
2243 visit_type_BlockdevOnError(v, "on-source-error", &obj->on_source_error, &err);
2244 if (err) {
2245 goto out;
2246 }
2247 }
2248 if (visit_optional(v, "on-target-error", &obj->has_on_target_error)) {
2249 visit_type_BlockdevOnError(v, "on-target-error", &obj->on_target_error, &err);
2250 if (err) {
2251 goto out;
2252 }
2253 }
2254 if (visit_optional(v, "auto-finalize", &obj->has_auto_finalize)) {
2255 visit_type_bool(v, "auto-finalize", &obj->auto_finalize, &err);
2256 if (err) {
2257 goto out;
2258 }
2259 }
2260 if (visit_optional(v, "auto-dismiss", &obj->has_auto_dismiss)) {
2261 visit_type_bool(v, "auto-dismiss", &obj->auto_dismiss, &err);
2262 if (err) {
2263 goto out;
2264 }
2265 }
2266
2267out:
2268 error_propagate(errp, err);
2269}
2270
2271void visit_type_BackupCommon(Visitor *v, const char *name, BackupCommon **obj, Error **errp)
2272{
2273 Error *err = NULL;
2274
2275 visit_start_struct(v, name, (void **)obj, sizeof(BackupCommon), &err);
2276 if (err) {
2277 goto out;
2278 }
2279 if (!*obj) {
2280 goto out_obj;
2281 }
2282 visit_type_BackupCommon_members(v, *obj, &err);
2283 if (err) {
2284 goto out_obj;
2285 }
2286 visit_check_struct(v, &err);
2287out_obj:
2288 visit_end_struct(v, (void **)obj);
2289 if (err && visit_is_input(v)) {
2290 qapi_free_BackupCommon(*obj);
2291 *obj = NULL;
2292 }
2293out:
2294 error_propagate(errp, err);
2295}
2296
2297void visit_type_DriveBackup_members(Visitor *v, DriveBackup *obj, Error **errp)
2298{
2299 Error *err = NULL;
2300
2301 visit_type_BackupCommon_members(v, (BackupCommon *)obj, &err);
2302 if (err) {
2303 goto out;
2304 }
2305 visit_type_str(v, "target", &obj->target, &err);
2306 if (err) {
2307 goto out;
2308 }
2309 if (visit_optional(v, "format", &obj->has_format)) {
2310 visit_type_str(v, "format", &obj->format, &err);
2311 if (err) {
2312 goto out;
2313 }
2314 }
2315 if (visit_optional(v, "mode", &obj->has_mode)) {
2316 visit_type_NewImageMode(v, "mode", &obj->mode, &err);
2317 if (err) {
2318 goto out;
2319 }
2320 }
2321
2322out:
2323 error_propagate(errp, err);
2324}
2325
2326void visit_type_DriveBackup(Visitor *v, const char *name, DriveBackup **obj, Error **errp)
2327{
2328 Error *err = NULL;
2329
2330 visit_start_struct(v, name, (void **)obj, sizeof(DriveBackup), &err);
2331 if (err) {
2332 goto out;
2333 }
2334 if (!*obj) {
2335 goto out_obj;
2336 }
2337 visit_type_DriveBackup_members(v, *obj, &err);
2338 if (err) {
2339 goto out_obj;
2340 }
2341 visit_check_struct(v, &err);
2342out_obj:
2343 visit_end_struct(v, (void **)obj);
2344 if (err && visit_is_input(v)) {
2345 qapi_free_DriveBackup(*obj);
2346 *obj = NULL;
2347 }
2348out:
2349 error_propagate(errp, err);
2350}
2351
2352void visit_type_BlockdevBackup_members(Visitor *v, BlockdevBackup *obj, Error **errp)
2353{
2354 Error *err = NULL;
2355
2356 visit_type_BackupCommon_members(v, (BackupCommon *)obj, &err);
2357 if (err) {
2358 goto out;
2359 }
2360 visit_type_str(v, "target", &obj->target, &err);
2361 if (err) {
2362 goto out;
2363 }
2364
2365out:
2366 error_propagate(errp, err);
2367}
2368
2369void visit_type_BlockdevBackup(Visitor *v, const char *name, BlockdevBackup **obj, Error **errp)
2370{
2371 Error *err = NULL;
2372
2373 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevBackup), &err);
2374 if (err) {
2375 goto out;
2376 }
2377 if (!*obj) {
2378 goto out_obj;
2379 }
2380 visit_type_BlockdevBackup_members(v, *obj, &err);
2381 if (err) {
2382 goto out_obj;
2383 }
2384 visit_check_struct(v, &err);
2385out_obj:
2386 visit_end_struct(v, (void **)obj);
2387 if (err && visit_is_input(v)) {
2388 qapi_free_BlockdevBackup(*obj);
2389 *obj = NULL;
2390 }
2391out:
2392 error_propagate(errp, err);
2393}
2394
2395void visit_type_q_obj_change_backing_file_arg_members(Visitor *v, q_obj_change_backing_file_arg *obj, Error **errp)
2396{
2397 Error *err = NULL;
2398
2399 visit_type_str(v, "device", &obj->device, &err);
2400 if (err) {
2401 goto out;
2402 }
2403 visit_type_str(v, "image-node-name", &obj->image_node_name, &err);
2404 if (err) {
2405 goto out;
2406 }
2407 visit_type_str(v, "backing-file", &obj->backing_file, &err);
2408 if (err) {
2409 goto out;
2410 }
2411
2412out:
2413 error_propagate(errp, err);
2414}
2415
2416void visit_type_q_obj_block_commit_arg_members(Visitor *v, q_obj_block_commit_arg *obj, Error **errp)
2417{
2418 Error *err = NULL;
2419
2420 if (visit_optional(v, "job-id", &obj->has_job_id)) {
2421 visit_type_str(v, "job-id", &obj->job_id, &err);
2422 if (err) {
2423 goto out;
2424 }
2425 }
2426 visit_type_str(v, "device", &obj->device, &err);
2427 if (err) {
2428 goto out;
2429 }
2430 if (visit_optional(v, "base-node", &obj->has_base_node)) {
2431 visit_type_str(v, "base-node", &obj->base_node, &err);
2432 if (err) {
2433 goto out;
2434 }
2435 }
2436 if (visit_optional(v, "base", &obj->has_base)) {
2437 visit_type_str(v, "base", &obj->base, &err);
2438 if (err) {
2439 goto out;
2440 }
2441 }
2442 if (visit_optional(v, "top-node", &obj->has_top_node)) {
2443 visit_type_str(v, "top-node", &obj->top_node, &err);
2444 if (err) {
2445 goto out;
2446 }
2447 }
2448 if (visit_optional(v, "top", &obj->has_top)) {
2449 visit_type_str(v, "top", &obj->top, &err);
2450 if (err) {
2451 goto out;
2452 }
2453 }
2454 if (visit_optional(v, "backing-file", &obj->has_backing_file)) {
2455 visit_type_str(v, "backing-file", &obj->backing_file, &err);
2456 if (err) {
2457 goto out;
2458 }
2459 }
2460 if (visit_optional(v, "speed", &obj->has_speed)) {
2461 visit_type_int(v, "speed", &obj->speed, &err);
2462 if (err) {
2463 goto out;
2464 }
2465 }
2466 if (visit_optional(v, "filter-node-name", &obj->has_filter_node_name)) {
2467 visit_type_str(v, "filter-node-name", &obj->filter_node_name, &err);
2468 if (err) {
2469 goto out;
2470 }
2471 }
2472 if (visit_optional(v, "auto-finalize", &obj->has_auto_finalize)) {
2473 visit_type_bool(v, "auto-finalize", &obj->auto_finalize, &err);
2474 if (err) {
2475 goto out;
2476 }
2477 }
2478 if (visit_optional(v, "auto-dismiss", &obj->has_auto_dismiss)) {
2479 visit_type_bool(v, "auto-dismiss", &obj->auto_dismiss, &err);
2480 if (err) {
2481 goto out;
2482 }
2483 }
2484
2485out:
2486 error_propagate(errp, err);
2487}
2488
2489void visit_type_BlockDeviceInfoList(Visitor *v, const char *name, BlockDeviceInfoList **obj, Error **errp)
2490{
2491 Error *err = NULL;
2492 BlockDeviceInfoList *tail;
2493 size_t size = sizeof(**obj);
2494
2495 visit_start_list(v, name, (GenericList **)obj, size, &err);
2496 if (err) {
2497 goto out;
2498 }
2499
2500 for (tail = *obj; tail;
2501 tail = (BlockDeviceInfoList *)visit_next_list(v, (GenericList *)tail, size)) {
2502 visit_type_BlockDeviceInfo(v, NULL, &tail->value, &err);
2503 if (err) {
2504 break;
2505 }
2506 }
2507
2508 if (!err) {
2509 visit_check_list(v, &err);
2510 }
2511 visit_end_list(v, (void **)obj);
2512 if (err && visit_is_input(v)) {
2513 qapi_free_BlockDeviceInfoList(*obj);
2514 *obj = NULL;
2515 }
2516out:
2517 error_propagate(errp, err);
2518}
2519
2520void visit_type_XDbgBlockGraphNodeType(Visitor *v, const char *name, XDbgBlockGraphNodeType *obj, Error **errp)
2521{
2522 int value = *obj;
2523 visit_type_enum(v, name, &value, &XDbgBlockGraphNodeType_lookup, errp);
2524 *obj = value;
2525}
2526
2527void visit_type_XDbgBlockGraphNode_members(Visitor *v, XDbgBlockGraphNode *obj, Error **errp)
2528{
2529 Error *err = NULL;
2530
2531 visit_type_uint64(v, "id", &obj->id, &err);
2532 if (err) {
2533 goto out;
2534 }
2535 visit_type_XDbgBlockGraphNodeType(v, "type", &obj->type, &err);
2536 if (err) {
2537 goto out;
2538 }
2539 visit_type_str(v, "name", &obj->name, &err);
2540 if (err) {
2541 goto out;
2542 }
2543
2544out:
2545 error_propagate(errp, err);
2546}
2547
2548void visit_type_XDbgBlockGraphNode(Visitor *v, const char *name, XDbgBlockGraphNode **obj, Error **errp)
2549{
2550 Error *err = NULL;
2551
2552 visit_start_struct(v, name, (void **)obj, sizeof(XDbgBlockGraphNode), &err);
2553 if (err) {
2554 goto out;
2555 }
2556 if (!*obj) {
2557 goto out_obj;
2558 }
2559 visit_type_XDbgBlockGraphNode_members(v, *obj, &err);
2560 if (err) {
2561 goto out_obj;
2562 }
2563 visit_check_struct(v, &err);
2564out_obj:
2565 visit_end_struct(v, (void **)obj);
2566 if (err && visit_is_input(v)) {
2567 qapi_free_XDbgBlockGraphNode(*obj);
2568 *obj = NULL;
2569 }
2570out:
2571 error_propagate(errp, err);
2572}
2573
2574void visit_type_BlockPermission(Visitor *v, const char *name, BlockPermission *obj, Error **errp)
2575{
2576 int value = *obj;
2577 visit_type_enum(v, name, &value, &BlockPermission_lookup, errp);
2578 *obj = value;
2579}
2580
2581void visit_type_BlockPermissionList(Visitor *v, const char *name, BlockPermissionList **obj, Error **errp)
2582{
2583 Error *err = NULL;
2584 BlockPermissionList *tail;
2585 size_t size = sizeof(**obj);
2586
2587 visit_start_list(v, name, (GenericList **)obj, size, &err);
2588 if (err) {
2589 goto out;
2590 }
2591
2592 for (tail = *obj; tail;
2593 tail = (BlockPermissionList *)visit_next_list(v, (GenericList *)tail, size)) {
2594 visit_type_BlockPermission(v, NULL, &tail->value, &err);
2595 if (err) {
2596 break;
2597 }
2598 }
2599
2600 if (!err) {
2601 visit_check_list(v, &err);
2602 }
2603 visit_end_list(v, (void **)obj);
2604 if (err && visit_is_input(v)) {
2605 qapi_free_BlockPermissionList(*obj);
2606 *obj = NULL;
2607 }
2608out:
2609 error_propagate(errp, err);
2610}
2611
2612void visit_type_XDbgBlockGraphEdge_members(Visitor *v, XDbgBlockGraphEdge *obj, Error **errp)
2613{
2614 Error *err = NULL;
2615
2616 visit_type_uint64(v, "parent", &obj->parent, &err);
2617 if (err) {
2618 goto out;
2619 }
2620 visit_type_uint64(v, "child", &obj->child, &err);
2621 if (err) {
2622 goto out;
2623 }
2624 visit_type_str(v, "name", &obj->name, &err);
2625 if (err) {
2626 goto out;
2627 }
2628 visit_type_BlockPermissionList(v, "perm", &obj->perm, &err);
2629 if (err) {
2630 goto out;
2631 }
2632 visit_type_BlockPermissionList(v, "shared-perm", &obj->shared_perm, &err);
2633 if (err) {
2634 goto out;
2635 }
2636
2637out:
2638 error_propagate(errp, err);
2639}
2640
2641void visit_type_XDbgBlockGraphEdge(Visitor *v, const char *name, XDbgBlockGraphEdge **obj, Error **errp)
2642{
2643 Error *err = NULL;
2644
2645 visit_start_struct(v, name, (void **)obj, sizeof(XDbgBlockGraphEdge), &err);
2646 if (err) {
2647 goto out;
2648 }
2649 if (!*obj) {
2650 goto out_obj;
2651 }
2652 visit_type_XDbgBlockGraphEdge_members(v, *obj, &err);
2653 if (err) {
2654 goto out_obj;
2655 }
2656 visit_check_struct(v, &err);
2657out_obj:
2658 visit_end_struct(v, (void **)obj);
2659 if (err && visit_is_input(v)) {
2660 qapi_free_XDbgBlockGraphEdge(*obj);
2661 *obj = NULL;
2662 }
2663out:
2664 error_propagate(errp, err);
2665}
2666
2667void visit_type_XDbgBlockGraphNodeList(Visitor *v, const char *name, XDbgBlockGraphNodeList **obj, Error **errp)
2668{
2669 Error *err = NULL;
2670 XDbgBlockGraphNodeList *tail;
2671 size_t size = sizeof(**obj);
2672
2673 visit_start_list(v, name, (GenericList **)obj, size, &err);
2674 if (err) {
2675 goto out;
2676 }
2677
2678 for (tail = *obj; tail;
2679 tail = (XDbgBlockGraphNodeList *)visit_next_list(v, (GenericList *)tail, size)) {
2680 visit_type_XDbgBlockGraphNode(v, NULL, &tail->value, &err);
2681 if (err) {
2682 break;
2683 }
2684 }
2685
2686 if (!err) {
2687 visit_check_list(v, &err);
2688 }
2689 visit_end_list(v, (void **)obj);
2690 if (err && visit_is_input(v)) {
2691 qapi_free_XDbgBlockGraphNodeList(*obj);
2692 *obj = NULL;
2693 }
2694out:
2695 error_propagate(errp, err);
2696}
2697
2698void visit_type_XDbgBlockGraphEdgeList(Visitor *v, const char *name, XDbgBlockGraphEdgeList **obj, Error **errp)
2699{
2700 Error *err = NULL;
2701 XDbgBlockGraphEdgeList *tail;
2702 size_t size = sizeof(**obj);
2703
2704 visit_start_list(v, name, (GenericList **)obj, size, &err);
2705 if (err) {
2706 goto out;
2707 }
2708
2709 for (tail = *obj; tail;
2710 tail = (XDbgBlockGraphEdgeList *)visit_next_list(v, (GenericList *)tail, size)) {
2711 visit_type_XDbgBlockGraphEdge(v, NULL, &tail->value, &err);
2712 if (err) {
2713 break;
2714 }
2715 }
2716
2717 if (!err) {
2718 visit_check_list(v, &err);
2719 }
2720 visit_end_list(v, (void **)obj);
2721 if (err && visit_is_input(v)) {
2722 qapi_free_XDbgBlockGraphEdgeList(*obj);
2723 *obj = NULL;
2724 }
2725out:
2726 error_propagate(errp, err);
2727}
2728
2729void visit_type_XDbgBlockGraph_members(Visitor *v, XDbgBlockGraph *obj, Error **errp)
2730{
2731 Error *err = NULL;
2732
2733 visit_type_XDbgBlockGraphNodeList(v, "nodes", &obj->nodes, &err);
2734 if (err) {
2735 goto out;
2736 }
2737 visit_type_XDbgBlockGraphEdgeList(v, "edges", &obj->edges, &err);
2738 if (err) {
2739 goto out;
2740 }
2741
2742out:
2743 error_propagate(errp, err);
2744}
2745
2746void visit_type_XDbgBlockGraph(Visitor *v, const char *name, XDbgBlockGraph **obj, Error **errp)
2747{
2748 Error *err = NULL;
2749
2750 visit_start_struct(v, name, (void **)obj, sizeof(XDbgBlockGraph), &err);
2751 if (err) {
2752 goto out;
2753 }
2754 if (!*obj) {
2755 goto out_obj;
2756 }
2757 visit_type_XDbgBlockGraph_members(v, *obj, &err);
2758 if (err) {
2759 goto out_obj;
2760 }
2761 visit_check_struct(v, &err);
2762out_obj:
2763 visit_end_struct(v, (void **)obj);
2764 if (err && visit_is_input(v)) {
2765 qapi_free_XDbgBlockGraph(*obj);
2766 *obj = NULL;
2767 }
2768out:
2769 error_propagate(errp, err);
2770}
2771
2772void visit_type_DriveMirror_members(Visitor *v, DriveMirror *obj, Error **errp)
2773{
2774 Error *err = NULL;
2775
2776 if (visit_optional(v, "job-id", &obj->has_job_id)) {
2777 visit_type_str(v, "job-id", &obj->job_id, &err);
2778 if (err) {
2779 goto out;
2780 }
2781 }
2782 visit_type_str(v, "device", &obj->device, &err);
2783 if (err) {
2784 goto out;
2785 }
2786 visit_type_str(v, "target", &obj->target, &err);
2787 if (err) {
2788 goto out;
2789 }
2790 if (visit_optional(v, "format", &obj->has_format)) {
2791 visit_type_str(v, "format", &obj->format, &err);
2792 if (err) {
2793 goto out;
2794 }
2795 }
2796 if (visit_optional(v, "node-name", &obj->has_node_name)) {
2797 visit_type_str(v, "node-name", &obj->node_name, &err);
2798 if (err) {
2799 goto out;
2800 }
2801 }
2802 if (visit_optional(v, "replaces", &obj->has_replaces)) {
2803 visit_type_str(v, "replaces", &obj->replaces, &err);
2804 if (err) {
2805 goto out;
2806 }
2807 }
2808 visit_type_MirrorSyncMode(v, "sync", &obj->sync, &err);
2809 if (err) {
2810 goto out;
2811 }
2812 if (visit_optional(v, "mode", &obj->has_mode)) {
2813 visit_type_NewImageMode(v, "mode", &obj->mode, &err);
2814 if (err) {
2815 goto out;
2816 }
2817 }
2818 if (visit_optional(v, "speed", &obj->has_speed)) {
2819 visit_type_int(v, "speed", &obj->speed, &err);
2820 if (err) {
2821 goto out;
2822 }
2823 }
2824 if (visit_optional(v, "granularity", &obj->has_granularity)) {
2825 visit_type_uint32(v, "granularity", &obj->granularity, &err);
2826 if (err) {
2827 goto out;
2828 }
2829 }
2830 if (visit_optional(v, "buf-size", &obj->has_buf_size)) {
2831 visit_type_int(v, "buf-size", &obj->buf_size, &err);
2832 if (err) {
2833 goto out;
2834 }
2835 }
2836 if (visit_optional(v, "on-source-error", &obj->has_on_source_error)) {
2837 visit_type_BlockdevOnError(v, "on-source-error", &obj->on_source_error, &err);
2838 if (err) {
2839 goto out;
2840 }
2841 }
2842 if (visit_optional(v, "on-target-error", &obj->has_on_target_error)) {
2843 visit_type_BlockdevOnError(v, "on-target-error", &obj->on_target_error, &err);
2844 if (err) {
2845 goto out;
2846 }
2847 }
2848 if (visit_optional(v, "unmap", &obj->has_unmap)) {
2849 visit_type_bool(v, "unmap", &obj->unmap, &err);
2850 if (err) {
2851 goto out;
2852 }
2853 }
2854 if (visit_optional(v, "copy-mode", &obj->has_copy_mode)) {
2855 visit_type_MirrorCopyMode(v, "copy-mode", &obj->copy_mode, &err);
2856 if (err) {
2857 goto out;
2858 }
2859 }
2860 if (visit_optional(v, "auto-finalize", &obj->has_auto_finalize)) {
2861 visit_type_bool(v, "auto-finalize", &obj->auto_finalize, &err);
2862 if (err) {
2863 goto out;
2864 }
2865 }
2866 if (visit_optional(v, "auto-dismiss", &obj->has_auto_dismiss)) {
2867 visit_type_bool(v, "auto-dismiss", &obj->auto_dismiss, &err);
2868 if (err) {
2869 goto out;
2870 }
2871 }
2872
2873out:
2874 error_propagate(errp, err);
2875}
2876
2877void visit_type_DriveMirror(Visitor *v, const char *name, DriveMirror **obj, Error **errp)
2878{
2879 Error *err = NULL;
2880
2881 visit_start_struct(v, name, (void **)obj, sizeof(DriveMirror), &err);
2882 if (err) {
2883 goto out;
2884 }
2885 if (!*obj) {
2886 goto out_obj;
2887 }
2888 visit_type_DriveMirror_members(v, *obj, &err);
2889 if (err) {
2890 goto out_obj;
2891 }
2892 visit_check_struct(v, &err);
2893out_obj:
2894 visit_end_struct(v, (void **)obj);
2895 if (err && visit_is_input(v)) {
2896 qapi_free_DriveMirror(*obj);
2897 *obj = NULL;
2898 }
2899out:
2900 error_propagate(errp, err);
2901}
2902
2903void visit_type_BlockDirtyBitmap_members(Visitor *v, BlockDirtyBitmap *obj, Error **errp)
2904{
2905 Error *err = NULL;
2906
2907 visit_type_str(v, "node", &obj->node, &err);
2908 if (err) {
2909 goto out;
2910 }
2911 visit_type_str(v, "name", &obj->name, &err);
2912 if (err) {
2913 goto out;
2914 }
2915
2916out:
2917 error_propagate(errp, err);
2918}
2919
2920void visit_type_BlockDirtyBitmap(Visitor *v, const char *name, BlockDirtyBitmap **obj, Error **errp)
2921{
2922 Error *err = NULL;
2923
2924 visit_start_struct(v, name, (void **)obj, sizeof(BlockDirtyBitmap), &err);
2925 if (err) {
2926 goto out;
2927 }
2928 if (!*obj) {
2929 goto out_obj;
2930 }
2931 visit_type_BlockDirtyBitmap_members(v, *obj, &err);
2932 if (err) {
2933 goto out_obj;
2934 }
2935 visit_check_struct(v, &err);
2936out_obj:
2937 visit_end_struct(v, (void **)obj);
2938 if (err && visit_is_input(v)) {
2939 qapi_free_BlockDirtyBitmap(*obj);
2940 *obj = NULL;
2941 }
2942out:
2943 error_propagate(errp, err);
2944}
2945
2946void visit_type_BlockDirtyBitmapAdd_members(Visitor *v, BlockDirtyBitmapAdd *obj, Error **errp)
2947{
2948 Error *err = NULL;
2949
2950 visit_type_str(v, "node", &obj->node, &err);
2951 if (err) {
2952 goto out;
2953 }
2954 visit_type_str(v, "name", &obj->name, &err);
2955 if (err) {
2956 goto out;
2957 }
2958 if (visit_optional(v, "granularity", &obj->has_granularity)) {
2959 visit_type_uint32(v, "granularity", &obj->granularity, &err);
2960 if (err) {
2961 goto out;
2962 }
2963 }
2964 if (visit_optional(v, "persistent", &obj->has_persistent)) {
2965 visit_type_bool(v, "persistent", &obj->persistent, &err);
2966 if (err) {
2967 goto out;
2968 }
2969 }
2970 if (visit_optional(v, "autoload", &obj->has_autoload)) {
2971 visit_type_bool(v, "autoload", &obj->autoload, &err);
2972 if (err) {
2973 goto out;
2974 }
2975 }
2976 if (visit_optional(v, "disabled", &obj->has_disabled)) {
2977 visit_type_bool(v, "disabled", &obj->disabled, &err);
2978 if (err) {
2979 goto out;
2980 }
2981 }
2982
2983out:
2984 error_propagate(errp, err);
2985}
2986
2987void visit_type_BlockDirtyBitmapAdd(Visitor *v, const char *name, BlockDirtyBitmapAdd **obj, Error **errp)
2988{
2989 Error *err = NULL;
2990
2991 visit_start_struct(v, name, (void **)obj, sizeof(BlockDirtyBitmapAdd), &err);
2992 if (err) {
2993 goto out;
2994 }
2995 if (!*obj) {
2996 goto out_obj;
2997 }
2998 visit_type_BlockDirtyBitmapAdd_members(v, *obj, &err);
2999 if (err) {
3000 goto out_obj;
3001 }
3002 visit_check_struct(v, &err);
3003out_obj:
3004 visit_end_struct(v, (void **)obj);
3005 if (err && visit_is_input(v)) {
3006 qapi_free_BlockDirtyBitmapAdd(*obj);
3007 *obj = NULL;
3008 }
3009out:
3010 error_propagate(errp, err);
3011}
3012
3013void visit_type_BlockDirtyBitmapMergeSource(Visitor *v, const char *name, BlockDirtyBitmapMergeSource **obj, Error **errp)
3014{
3015 Error *err = NULL;
3016
3017 visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
3018 &err);
3019 if (err) {
3020 goto out;
3021 }
3022 if (!*obj) {
3023 goto out_obj;
3024 }
3025 switch ((*obj)->type) {
3026 case QTYPE_QSTRING:
3027 visit_type_str(v, name, &(*obj)->u.local, &err);
3028 break;
3029 case QTYPE_QDICT:
3030 visit_start_struct(v, name, NULL, 0, &err);
3031 if (err) {
3032 break;
3033 }
3034 visit_type_BlockDirtyBitmap_members(v, &(*obj)->u.external, &err);
3035 if (!err) {
3036 visit_check_struct(v, &err);
3037 }
3038 visit_end_struct(v, NULL);
3039 break;
3040 case QTYPE_NONE:
3041 abort();
3042 default:
3043 error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
3044 "BlockDirtyBitmapMergeSource");
3045 }
3046out_obj:
3047 visit_end_alternate(v, (void **)obj);
3048 if (err && visit_is_input(v)) {
3049 qapi_free_BlockDirtyBitmapMergeSource(*obj);
3050 *obj = NULL;
3051 }
3052out:
3053 error_propagate(errp, err);
3054}
3055
3056void visit_type_BlockDirtyBitmapMergeSourceList(Visitor *v, const char *name, BlockDirtyBitmapMergeSourceList **obj, Error **errp)
3057{
3058 Error *err = NULL;
3059 BlockDirtyBitmapMergeSourceList *tail;
3060 size_t size = sizeof(**obj);
3061
3062 visit_start_list(v, name, (GenericList **)obj, size, &err);
3063 if (err) {
3064 goto out;
3065 }
3066
3067 for (tail = *obj; tail;
3068 tail = (BlockDirtyBitmapMergeSourceList *)visit_next_list(v, (GenericList *)tail, size)) {
3069 visit_type_BlockDirtyBitmapMergeSource(v, NULL, &tail->value, &err);
3070 if (err) {
3071 break;
3072 }
3073 }
3074
3075 if (!err) {
3076 visit_check_list(v, &err);
3077 }
3078 visit_end_list(v, (void **)obj);
3079 if (err && visit_is_input(v)) {
3080 qapi_free_BlockDirtyBitmapMergeSourceList(*obj);
3081 *obj = NULL;
3082 }
3083out:
3084 error_propagate(errp, err);
3085}
3086
3087void visit_type_BlockDirtyBitmapMerge_members(Visitor *v, BlockDirtyBitmapMerge *obj, Error **errp)
3088{
3089 Error *err = NULL;
3090
3091 visit_type_str(v, "node", &obj->node, &err);
3092 if (err) {
3093 goto out;
3094 }
3095 visit_type_str(v, "target", &obj->target, &err);
3096 if (err) {
3097 goto out;
3098 }
3099 visit_type_BlockDirtyBitmapMergeSourceList(v, "bitmaps", &obj->bitmaps, &err);
3100 if (err) {
3101 goto out;
3102 }
3103
3104out:
3105 error_propagate(errp, err);
3106}
3107
3108void visit_type_BlockDirtyBitmapMerge(Visitor *v, const char *name, BlockDirtyBitmapMerge **obj, Error **errp)
3109{
3110 Error *err = NULL;
3111
3112 visit_start_struct(v, name, (void **)obj, sizeof(BlockDirtyBitmapMerge), &err);
3113 if (err) {
3114 goto out;
3115 }
3116 if (!*obj) {
3117 goto out_obj;
3118 }
3119 visit_type_BlockDirtyBitmapMerge_members(v, *obj, &err);
3120 if (err) {
3121 goto out_obj;
3122 }
3123 visit_check_struct(v, &err);
3124out_obj:
3125 visit_end_struct(v, (void **)obj);
3126 if (err && visit_is_input(v)) {
3127 qapi_free_BlockDirtyBitmapMerge(*obj);
3128 *obj = NULL;
3129 }
3130out:
3131 error_propagate(errp, err);
3132}
3133
3134void visit_type_BlockDirtyBitmapSha256_members(Visitor *v, BlockDirtyBitmapSha256 *obj, Error **errp)
3135{
3136 Error *err = NULL;
3137
3138 visit_type_str(v, "sha256", &obj->sha256, &err);
3139 if (err) {
3140 goto out;
3141 }
3142
3143out:
3144 error_propagate(errp, err);
3145}
3146
3147void visit_type_BlockDirtyBitmapSha256(Visitor *v, const char *name, BlockDirtyBitmapSha256 **obj, Error **errp)
3148{
3149 Error *err = NULL;
3150
3151 visit_start_struct(v, name, (void **)obj, sizeof(BlockDirtyBitmapSha256), &err);
3152 if (err) {
3153 goto out;
3154 }
3155 if (!*obj) {
3156 goto out_obj;
3157 }
3158 visit_type_BlockDirtyBitmapSha256_members(v, *obj, &err);
3159 if (err) {
3160 goto out_obj;
3161 }
3162 visit_check_struct(v, &err);
3163out_obj:
3164 visit_end_struct(v, (void **)obj);
3165 if (err && visit_is_input(v)) {
3166 qapi_free_BlockDirtyBitmapSha256(*obj);
3167 *obj = NULL;
3168 }
3169out:
3170 error_propagate(errp, err);
3171}
3172
3173void visit_type_q_obj_blockdev_mirror_arg_members(Visitor *v, q_obj_blockdev_mirror_arg *obj, Error **errp)
3174{
3175 Error *err = NULL;
3176
3177 if (visit_optional(v, "job-id", &obj->has_job_id)) {
3178 visit_type_str(v, "job-id", &obj->job_id, &err);
3179 if (err) {
3180 goto out;
3181 }
3182 }
3183 visit_type_str(v, "device", &obj->device, &err);
3184 if (err) {
3185 goto out;
3186 }
3187 visit_type_str(v, "target", &obj->target, &err);
3188 if (err) {
3189 goto out;
3190 }
3191 if (visit_optional(v, "replaces", &obj->has_replaces)) {
3192 visit_type_str(v, "replaces", &obj->replaces, &err);
3193 if (err) {
3194 goto out;
3195 }
3196 }
3197 visit_type_MirrorSyncMode(v, "sync", &obj->sync, &err);
3198 if (err) {
3199 goto out;
3200 }
3201 if (visit_optional(v, "speed", &obj->has_speed)) {
3202 visit_type_int(v, "speed", &obj->speed, &err);
3203 if (err) {
3204 goto out;
3205 }
3206 }
3207 if (visit_optional(v, "granularity", &obj->has_granularity)) {
3208 visit_type_uint32(v, "granularity", &obj->granularity, &err);
3209 if (err) {
3210 goto out;
3211 }
3212 }
3213 if (visit_optional(v, "buf-size", &obj->has_buf_size)) {
3214 visit_type_int(v, "buf-size", &obj->buf_size, &err);
3215 if (err) {
3216 goto out;
3217 }
3218 }
3219 if (visit_optional(v, "on-source-error", &obj->has_on_source_error)) {
3220 visit_type_BlockdevOnError(v, "on-source-error", &obj->on_source_error, &err);
3221 if (err) {
3222 goto out;
3223 }
3224 }
3225 if (visit_optional(v, "on-target-error", &obj->has_on_target_error)) {
3226 visit_type_BlockdevOnError(v, "on-target-error", &obj->on_target_error, &err);
3227 if (err) {
3228 goto out;
3229 }
3230 }
3231 if (visit_optional(v, "filter-node-name", &obj->has_filter_node_name)) {
3232 visit_type_str(v, "filter-node-name", &obj->filter_node_name, &err);
3233 if (err) {
3234 goto out;
3235 }
3236 }
3237 if (visit_optional(v, "copy-mode", &obj->has_copy_mode)) {
3238 visit_type_MirrorCopyMode(v, "copy-mode", &obj->copy_mode, &err);
3239 if (err) {
3240 goto out;
3241 }
3242 }
3243 if (visit_optional(v, "auto-finalize", &obj->has_auto_finalize)) {
3244 visit_type_bool(v, "auto-finalize", &obj->auto_finalize, &err);
3245 if (err) {
3246 goto out;
3247 }
3248 }
3249 if (visit_optional(v, "auto-dismiss", &obj->has_auto_dismiss)) {
3250 visit_type_bool(v, "auto-dismiss", &obj->auto_dismiss, &err);
3251 if (err) {
3252 goto out;
3253 }
3254 }
3255
3256out:
3257 error_propagate(errp, err);
3258}
3259
3260void visit_type_BlockIOThrottle_members(Visitor *v, BlockIOThrottle *obj, Error **errp)
3261{
3262 Error *err = NULL;
3263
3264 if (visit_optional(v, "device", &obj->has_device)) {
3265 visit_type_str(v, "device", &obj->device, &err);
3266 if (err) {
3267 goto out;
3268 }
3269 }
3270 if (visit_optional(v, "id", &obj->has_id)) {
3271 visit_type_str(v, "id", &obj->id, &err);
3272 if (err) {
3273 goto out;
3274 }
3275 }
3276 visit_type_int(v, "bps", &obj->bps, &err);
3277 if (err) {
3278 goto out;
3279 }
3280 visit_type_int(v, "bps_rd", &obj->bps_rd, &err);
3281 if (err) {
3282 goto out;
3283 }
3284 visit_type_int(v, "bps_wr", &obj->bps_wr, &err);
3285 if (err) {
3286 goto out;
3287 }
3288 visit_type_int(v, "iops", &obj->iops, &err);
3289 if (err) {
3290 goto out;
3291 }
3292 visit_type_int(v, "iops_rd", &obj->iops_rd, &err);
3293 if (err) {
3294 goto out;
3295 }
3296 visit_type_int(v, "iops_wr", &obj->iops_wr, &err);
3297 if (err) {
3298 goto out;
3299 }
3300 if (visit_optional(v, "bps_max", &obj->has_bps_max)) {
3301 visit_type_int(v, "bps_max", &obj->bps_max, &err);
3302 if (err) {
3303 goto out;
3304 }
3305 }
3306 if (visit_optional(v, "bps_rd_max", &obj->has_bps_rd_max)) {
3307 visit_type_int(v, "bps_rd_max", &obj->bps_rd_max, &err);
3308 if (err) {
3309 goto out;
3310 }
3311 }
3312 if (visit_optional(v, "bps_wr_max", &obj->has_bps_wr_max)) {
3313 visit_type_int(v, "bps_wr_max", &obj->bps_wr_max, &err);
3314 if (err) {
3315 goto out;
3316 }
3317 }
3318 if (visit_optional(v, "iops_max", &obj->has_iops_max)) {
3319 visit_type_int(v, "iops_max", &obj->iops_max, &err);
3320 if (err) {
3321 goto out;
3322 }
3323 }
3324 if (visit_optional(v, "iops_rd_max", &obj->has_iops_rd_max)) {
3325 visit_type_int(v, "iops_rd_max", &obj->iops_rd_max, &err);
3326 if (err) {
3327 goto out;
3328 }
3329 }
3330 if (visit_optional(v, "iops_wr_max", &obj->has_iops_wr_max)) {
3331 visit_type_int(v, "iops_wr_max", &obj->iops_wr_max, &err);
3332 if (err) {
3333 goto out;
3334 }
3335 }
3336 if (visit_optional(v, "bps_max_length", &obj->has_bps_max_length)) {
3337 visit_type_int(v, "bps_max_length", &obj->bps_max_length, &err);
3338 if (err) {
3339 goto out;
3340 }
3341 }
3342 if (visit_optional(v, "bps_rd_max_length", &obj->has_bps_rd_max_length)) {
3343 visit_type_int(v, "bps_rd_max_length", &obj->bps_rd_max_length, &err);
3344 if (err) {
3345 goto out;
3346 }
3347 }
3348 if (visit_optional(v, "bps_wr_max_length", &obj->has_bps_wr_max_length)) {
3349 visit_type_int(v, "bps_wr_max_length", &obj->bps_wr_max_length, &err);
3350 if (err) {
3351 goto out;
3352 }
3353 }
3354 if (visit_optional(v, "iops_max_length", &obj->has_iops_max_length)) {
3355 visit_type_int(v, "iops_max_length", &obj->iops_max_length, &err);
3356 if (err) {
3357 goto out;
3358 }
3359 }
3360 if (visit_optional(v, "iops_rd_max_length", &obj->has_iops_rd_max_length)) {
3361 visit_type_int(v, "iops_rd_max_length", &obj->iops_rd_max_length, &err);
3362 if (err) {
3363 goto out;
3364 }
3365 }
3366 if (visit_optional(v, "iops_wr_max_length", &obj->has_iops_wr_max_length)) {
3367 visit_type_int(v, "iops_wr_max_length", &obj->iops_wr_max_length, &err);
3368 if (err) {
3369 goto out;
3370 }
3371 }
3372 if (visit_optional(v, "iops_size", &obj->has_iops_size)) {
3373 visit_type_int(v, "iops_size", &obj->iops_size, &err);
3374 if (err) {
3375 goto out;
3376 }
3377 }
3378 if (visit_optional(v, "group", &obj->has_group)) {
3379 visit_type_str(v, "group", &obj->group, &err);
3380 if (err) {
3381 goto out;
3382 }
3383 }
3384
3385out:
3386 error_propagate(errp, err);
3387}
3388
3389void visit_type_BlockIOThrottle(Visitor *v, const char *name, BlockIOThrottle **obj, Error **errp)
3390{
3391 Error *err = NULL;
3392
3393 visit_start_struct(v, name, (void **)obj, sizeof(BlockIOThrottle), &err);
3394 if (err) {
3395 goto out;
3396 }
3397 if (!*obj) {
3398 goto out_obj;
3399 }
3400 visit_type_BlockIOThrottle_members(v, *obj, &err);
3401 if (err) {
3402 goto out_obj;
3403 }
3404 visit_check_struct(v, &err);
3405out_obj:
3406 visit_end_struct(v, (void **)obj);
3407 if (err && visit_is_input(v)) {
3408 qapi_free_BlockIOThrottle(*obj);
3409 *obj = NULL;
3410 }
3411out:
3412 error_propagate(errp, err);
3413}
3414
3415void visit_type_ThrottleLimits_members(Visitor *v, ThrottleLimits *obj, Error **errp)
3416{
3417 Error *err = NULL;
3418
3419 if (visit_optional(v, "iops-total", &obj->has_iops_total)) {
3420 visit_type_int(v, "iops-total", &obj->iops_total, &err);
3421 if (err) {
3422 goto out;
3423 }
3424 }
3425 if (visit_optional(v, "iops-total-max", &obj->has_iops_total_max)) {
3426 visit_type_int(v, "iops-total-max", &obj->iops_total_max, &err);
3427 if (err) {
3428 goto out;
3429 }
3430 }
3431 if (visit_optional(v, "iops-total-max-length", &obj->has_iops_total_max_length)) {
3432 visit_type_int(v, "iops-total-max-length", &obj->iops_total_max_length, &err);
3433 if (err) {
3434 goto out;
3435 }
3436 }
3437 if (visit_optional(v, "iops-read", &obj->has_iops_read)) {
3438 visit_type_int(v, "iops-read", &obj->iops_read, &err);
3439 if (err) {
3440 goto out;
3441 }
3442 }
3443 if (visit_optional(v, "iops-read-max", &obj->has_iops_read_max)) {
3444 visit_type_int(v, "iops-read-max", &obj->iops_read_max, &err);
3445 if (err) {
3446 goto out;
3447 }
3448 }
3449 if (visit_optional(v, "iops-read-max-length", &obj->has_iops_read_max_length)) {
3450 visit_type_int(v, "iops-read-max-length", &obj->iops_read_max_length, &err);
3451 if (err) {
3452 goto out;
3453 }
3454 }
3455 if (visit_optional(v, "iops-write", &obj->has_iops_write)) {
3456 visit_type_int(v, "iops-write", &obj->iops_write, &err);
3457 if (err) {
3458 goto out;
3459 }
3460 }
3461 if (visit_optional(v, "iops-write-max", &obj->has_iops_write_max)) {
3462 visit_type_int(v, "iops-write-max", &obj->iops_write_max, &err);
3463 if (err) {
3464 goto out;
3465 }
3466 }
3467 if (visit_optional(v, "iops-write-max-length", &obj->has_iops_write_max_length)) {
3468 visit_type_int(v, "iops-write-max-length", &obj->iops_write_max_length, &err);
3469 if (err) {
3470 goto out;
3471 }
3472 }
3473 if (visit_optional(v, "bps-total", &obj->has_bps_total)) {
3474 visit_type_int(v, "bps-total", &obj->bps_total, &err);
3475 if (err) {
3476 goto out;
3477 }
3478 }
3479 if (visit_optional(v, "bps-total-max", &obj->has_bps_total_max)) {
3480 visit_type_int(v, "bps-total-max", &obj->bps_total_max, &err);
3481 if (err) {
3482 goto out;
3483 }
3484 }
3485 if (visit_optional(v, "bps-total-max-length", &obj->has_bps_total_max_length)) {
3486 visit_type_int(v, "bps-total-max-length", &obj->bps_total_max_length, &err);
3487 if (err) {
3488 goto out;
3489 }
3490 }
3491 if (visit_optional(v, "bps-read", &obj->has_bps_read)) {
3492 visit_type_int(v, "bps-read", &obj->bps_read, &err);
3493 if (err) {
3494 goto out;
3495 }
3496 }
3497 if (visit_optional(v, "bps-read-max", &obj->has_bps_read_max)) {
3498 visit_type_int(v, "bps-read-max", &obj->bps_read_max, &err);
3499 if (err) {
3500 goto out;
3501 }
3502 }
3503 if (visit_optional(v, "bps-read-max-length", &obj->has_bps_read_max_length)) {
3504 visit_type_int(v, "bps-read-max-length", &obj->bps_read_max_length, &err);
3505 if (err) {
3506 goto out;
3507 }
3508 }
3509 if (visit_optional(v, "bps-write", &obj->has_bps_write)) {
3510 visit_type_int(v, "bps-write", &obj->bps_write, &err);
3511 if (err) {
3512 goto out;
3513 }
3514 }
3515 if (visit_optional(v, "bps-write-max", &obj->has_bps_write_max)) {
3516 visit_type_int(v, "bps-write-max", &obj->bps_write_max, &err);
3517 if (err) {
3518 goto out;
3519 }
3520 }
3521 if (visit_optional(v, "bps-write-max-length", &obj->has_bps_write_max_length)) {
3522 visit_type_int(v, "bps-write-max-length", &obj->bps_write_max_length, &err);
3523 if (err) {
3524 goto out;
3525 }
3526 }
3527 if (visit_optional(v, "iops-size", &obj->has_iops_size)) {
3528 visit_type_int(v, "iops-size", &obj->iops_size, &err);
3529 if (err) {
3530 goto out;
3531 }
3532 }
3533
3534out:
3535 error_propagate(errp, err);
3536}
3537
3538void visit_type_ThrottleLimits(Visitor *v, const char *name, ThrottleLimits **obj, Error **errp)
3539{
3540 Error *err = NULL;
3541
3542 visit_start_struct(v, name, (void **)obj, sizeof(ThrottleLimits), &err);
3543 if (err) {
3544 goto out;
3545 }
3546 if (!*obj) {
3547 goto out_obj;
3548 }
3549 visit_type_ThrottleLimits_members(v, *obj, &err);
3550 if (err) {
3551 goto out_obj;
3552 }
3553 visit_check_struct(v, &err);
3554out_obj:
3555 visit_end_struct(v, (void **)obj);
3556 if (err && visit_is_input(v)) {
3557 qapi_free_ThrottleLimits(*obj);
3558 *obj = NULL;
3559 }
3560out:
3561 error_propagate(errp, err);
3562}
3563
3564void visit_type_q_obj_block_stream_arg_members(Visitor *v, q_obj_block_stream_arg *obj, Error **errp)
3565{
3566 Error *err = NULL;
3567
3568 if (visit_optional(v, "job-id", &obj->has_job_id)) {
3569 visit_type_str(v, "job-id", &obj->job_id, &err);
3570 if (err) {
3571 goto out;
3572 }
3573 }
3574 visit_type_str(v, "device", &obj->device, &err);
3575 if (err) {
3576 goto out;
3577 }
3578 if (visit_optional(v, "base", &obj->has_base)) {
3579 visit_type_str(v, "base", &obj->base, &err);
3580 if (err) {
3581 goto out;
3582 }
3583 }
3584 if (visit_optional(v, "base-node", &obj->has_base_node)) {
3585 visit_type_str(v, "base-node", &obj->base_node, &err);
3586 if (err) {
3587 goto out;
3588 }
3589 }
3590 if (visit_optional(v, "backing-file", &obj->has_backing_file)) {
3591 visit_type_str(v, "backing-file", &obj->backing_file, &err);
3592 if (err) {
3593 goto out;
3594 }
3595 }
3596 if (visit_optional(v, "speed", &obj->has_speed)) {
3597 visit_type_int(v, "speed", &obj->speed, &err);
3598 if (err) {
3599 goto out;
3600 }
3601 }
3602 if (visit_optional(v, "on-error", &obj->has_on_error)) {
3603 visit_type_BlockdevOnError(v, "on-error", &obj->on_error, &err);
3604 if (err) {
3605 goto out;
3606 }
3607 }
3608 if (visit_optional(v, "auto-finalize", &obj->has_auto_finalize)) {
3609 visit_type_bool(v, "auto-finalize", &obj->auto_finalize, &err);
3610 if (err) {
3611 goto out;
3612 }
3613 }
3614 if (visit_optional(v, "auto-dismiss", &obj->has_auto_dismiss)) {
3615 visit_type_bool(v, "auto-dismiss", &obj->auto_dismiss, &err);
3616 if (err) {
3617 goto out;
3618 }
3619 }
3620
3621out:
3622 error_propagate(errp, err);
3623}
3624
3625void visit_type_q_obj_block_job_set_speed_arg_members(Visitor *v, q_obj_block_job_set_speed_arg *obj, Error **errp)
3626{
3627 Error *err = NULL;
3628
3629 visit_type_str(v, "device", &obj->device, &err);
3630 if (err) {
3631 goto out;
3632 }
3633 visit_type_int(v, "speed", &obj->speed, &err);
3634 if (err) {
3635 goto out;
3636 }
3637
3638out:
3639 error_propagate(errp, err);
3640}
3641
3642void visit_type_q_obj_block_job_cancel_arg_members(Visitor *v, q_obj_block_job_cancel_arg *obj, Error **errp)
3643{
3644 Error *err = NULL;
3645
3646 visit_type_str(v, "device", &obj->device, &err);
3647 if (err) {
3648 goto out;
3649 }
3650 if (visit_optional(v, "force", &obj->has_force)) {
3651 visit_type_bool(v, "force", &obj->force, &err);
3652 if (err) {
3653 goto out;
3654 }
3655 }
3656
3657out:
3658 error_propagate(errp, err);
3659}
3660
3661void visit_type_q_obj_block_job_pause_arg_members(Visitor *v, q_obj_block_job_pause_arg *obj, Error **errp)
3662{
3663 Error *err = NULL;
3664
3665 visit_type_str(v, "device", &obj->device, &err);
3666 if (err) {
3667 goto out;
3668 }
3669
3670out:
3671 error_propagate(errp, err);
3672}
3673
3674void visit_type_q_obj_block_job_resume_arg_members(Visitor *v, q_obj_block_job_resume_arg *obj, Error **errp)
3675{
3676 Error *err = NULL;
3677
3678 visit_type_str(v, "device", &obj->device, &err);
3679 if (err) {
3680 goto out;
3681 }
3682
3683out:
3684 error_propagate(errp, err);
3685}
3686
3687void visit_type_q_obj_block_job_complete_arg_members(Visitor *v, q_obj_block_job_complete_arg *obj, Error **errp)
3688{
3689 Error *err = NULL;
3690
3691 visit_type_str(v, "device", &obj->device, &err);
3692 if (err) {
3693 goto out;
3694 }
3695
3696out:
3697 error_propagate(errp, err);
3698}
3699
3700void visit_type_q_obj_block_job_dismiss_arg_members(Visitor *v, q_obj_block_job_dismiss_arg *obj, Error **errp)
3701{
3702 Error *err = NULL;
3703
3704 visit_type_str(v, "id", &obj->id, &err);
3705 if (err) {
3706 goto out;
3707 }
3708
3709out:
3710 error_propagate(errp, err);
3711}
3712
3713void visit_type_q_obj_block_job_finalize_arg_members(Visitor *v, q_obj_block_job_finalize_arg *obj, Error **errp)
3714{
3715 Error *err = NULL;
3716
3717 visit_type_str(v, "id", &obj->id, &err);
3718 if (err) {
3719 goto out;
3720 }
3721
3722out:
3723 error_propagate(errp, err);
3724}
3725
3726void visit_type_BlockdevDiscardOptions(Visitor *v, const char *name, BlockdevDiscardOptions *obj, Error **errp)
3727{
3728 int value = *obj;
3729 visit_type_enum(v, name, &value, &BlockdevDiscardOptions_lookup, errp);
3730 *obj = value;
3731}
3732
3733void visit_type_BlockdevDetectZeroesOptions(Visitor *v, const char *name, BlockdevDetectZeroesOptions *obj, Error **errp)
3734{
3735 int value = *obj;
3736 visit_type_enum(v, name, &value, &BlockdevDetectZeroesOptions_lookup, errp);
3737 *obj = value;
3738}
3739
3740void visit_type_BlockdevAioOptions(Visitor *v, const char *name, BlockdevAioOptions *obj, Error **errp)
3741{
3742 int value = *obj;
3743 visit_type_enum(v, name, &value, &BlockdevAioOptions_lookup, errp);
3744 *obj = value;
3745}
3746
3747void visit_type_BlockdevCacheOptions_members(Visitor *v, BlockdevCacheOptions *obj, Error **errp)
3748{
3749 Error *err = NULL;
3750
3751 if (visit_optional(v, "direct", &obj->has_direct)) {
3752 visit_type_bool(v, "direct", &obj->direct, &err);
3753 if (err) {
3754 goto out;
3755 }
3756 }
3757 if (visit_optional(v, "no-flush", &obj->has_no_flush)) {
3758 visit_type_bool(v, "no-flush", &obj->no_flush, &err);
3759 if (err) {
3760 goto out;
3761 }
3762 }
3763
3764out:
3765 error_propagate(errp, err);
3766}
3767
3768void visit_type_BlockdevCacheOptions(Visitor *v, const char *name, BlockdevCacheOptions **obj, Error **errp)
3769{
3770 Error *err = NULL;
3771
3772 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCacheOptions), &err);
3773 if (err) {
3774 goto out;
3775 }
3776 if (!*obj) {
3777 goto out_obj;
3778 }
3779 visit_type_BlockdevCacheOptions_members(v, *obj, &err);
3780 if (err) {
3781 goto out_obj;
3782 }
3783 visit_check_struct(v, &err);
3784out_obj:
3785 visit_end_struct(v, (void **)obj);
3786 if (err && visit_is_input(v)) {
3787 qapi_free_BlockdevCacheOptions(*obj);
3788 *obj = NULL;
3789 }
3790out:
3791 error_propagate(errp, err);
3792}
3793
3794void visit_type_BlockdevDriver(Visitor *v, const char *name, BlockdevDriver *obj, Error **errp)
3795{
3796 int value = *obj;
3797 visit_type_enum(v, name, &value, &BlockdevDriver_lookup, errp);
3798 *obj = value;
3799}
3800
3801void visit_type_BlockdevOptionsFile_members(Visitor *v, BlockdevOptionsFile *obj, Error **errp)
3802{
3803 Error *err = NULL;
3804
3805 visit_type_str(v, "filename", &obj->filename, &err);
3806 if (err) {
3807 goto out;
3808 }
3809 if (visit_optional(v, "pr-manager", &obj->has_pr_manager)) {
3810 visit_type_str(v, "pr-manager", &obj->pr_manager, &err);
3811 if (err) {
3812 goto out;
3813 }
3814 }
3815 if (visit_optional(v, "locking", &obj->has_locking)) {
3816 visit_type_OnOffAuto(v, "locking", &obj->locking, &err);
3817 if (err) {
3818 goto out;
3819 }
3820 }
3821 if (visit_optional(v, "aio", &obj->has_aio)) {
3822 visit_type_BlockdevAioOptions(v, "aio", &obj->aio, &err);
3823 if (err) {
3824 goto out;
3825 }
3826 }
3827#if defined(CONFIG_LINUX)
3828 if (visit_optional(v, "drop-cache", &obj->has_drop_cache)) {
3829 visit_type_bool(v, "drop-cache", &obj->drop_cache, &err);
3830 if (err) {
3831 goto out;
3832 }
3833 }
3834#endif /* defined(CONFIG_LINUX) */
3835 if (visit_optional(v, "x-check-cache-dropped", &obj->has_x_check_cache_dropped)) {
3836 visit_type_bool(v, "x-check-cache-dropped", &obj->x_check_cache_dropped, &err);
3837 if (err) {
3838 goto out;
3839 }
3840 }
3841
3842out:
3843 error_propagate(errp, err);
3844}
3845
3846void visit_type_BlockdevOptionsFile(Visitor *v, const char *name, BlockdevOptionsFile **obj, Error **errp)
3847{
3848 Error *err = NULL;
3849
3850 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsFile), &err);
3851 if (err) {
3852 goto out;
3853 }
3854 if (!*obj) {
3855 goto out_obj;
3856 }
3857 visit_type_BlockdevOptionsFile_members(v, *obj, &err);
3858 if (err) {
3859 goto out_obj;
3860 }
3861 visit_check_struct(v, &err);
3862out_obj:
3863 visit_end_struct(v, (void **)obj);
3864 if (err && visit_is_input(v)) {
3865 qapi_free_BlockdevOptionsFile(*obj);
3866 *obj = NULL;
3867 }
3868out:
3869 error_propagate(errp, err);
3870}
3871
3872void visit_type_BlockdevOptionsNull_members(Visitor *v, BlockdevOptionsNull *obj, Error **errp)
3873{
3874 Error *err = NULL;
3875
3876 if (visit_optional(v, "size", &obj->has_size)) {
3877 visit_type_int(v, "size", &obj->size, &err);
3878 if (err) {
3879 goto out;
3880 }
3881 }
3882 if (visit_optional(v, "latency-ns", &obj->has_latency_ns)) {
3883 visit_type_uint64(v, "latency-ns", &obj->latency_ns, &err);
3884 if (err) {
3885 goto out;
3886 }
3887 }
3888 if (visit_optional(v, "read-zeroes", &obj->has_read_zeroes)) {
3889 visit_type_bool(v, "read-zeroes", &obj->read_zeroes, &err);
3890 if (err) {
3891 goto out;
3892 }
3893 }
3894
3895out:
3896 error_propagate(errp, err);
3897}
3898
3899void visit_type_BlockdevOptionsNull(Visitor *v, const char *name, BlockdevOptionsNull **obj, Error **errp)
3900{
3901 Error *err = NULL;
3902
3903 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsNull), &err);
3904 if (err) {
3905 goto out;
3906 }
3907 if (!*obj) {
3908 goto out_obj;
3909 }
3910 visit_type_BlockdevOptionsNull_members(v, *obj, &err);
3911 if (err) {
3912 goto out_obj;
3913 }
3914 visit_check_struct(v, &err);
3915out_obj:
3916 visit_end_struct(v, (void **)obj);
3917 if (err && visit_is_input(v)) {
3918 qapi_free_BlockdevOptionsNull(*obj);
3919 *obj = NULL;
3920 }
3921out:
3922 error_propagate(errp, err);
3923}
3924
3925void visit_type_BlockdevOptionsNVMe_members(Visitor *v, BlockdevOptionsNVMe *obj, Error **errp)
3926{
3927 Error *err = NULL;
3928
3929 visit_type_str(v, "device", &obj->device, &err);
3930 if (err) {
3931 goto out;
3932 }
3933 visit_type_int(v, "namespace", &obj->q_namespace, &err);
3934 if (err) {
3935 goto out;
3936 }
3937
3938out:
3939 error_propagate(errp, err);
3940}
3941
3942void visit_type_BlockdevOptionsNVMe(Visitor *v, const char *name, BlockdevOptionsNVMe **obj, Error **errp)
3943{
3944 Error *err = NULL;
3945
3946 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsNVMe), &err);
3947 if (err) {
3948 goto out;
3949 }
3950 if (!*obj) {
3951 goto out_obj;
3952 }
3953 visit_type_BlockdevOptionsNVMe_members(v, *obj, &err);
3954 if (err) {
3955 goto out_obj;
3956 }
3957 visit_check_struct(v, &err);
3958out_obj:
3959 visit_end_struct(v, (void **)obj);
3960 if (err && visit_is_input(v)) {
3961 qapi_free_BlockdevOptionsNVMe(*obj);
3962 *obj = NULL;
3963 }
3964out:
3965 error_propagate(errp, err);
3966}
3967
3968void visit_type_BlockdevOptionsVVFAT_members(Visitor *v, BlockdevOptionsVVFAT *obj, Error **errp)
3969{
3970 Error *err = NULL;
3971
3972 visit_type_str(v, "dir", &obj->dir, &err);
3973 if (err) {
3974 goto out;
3975 }
3976 if (visit_optional(v, "fat-type", &obj->has_fat_type)) {
3977 visit_type_int(v, "fat-type", &obj->fat_type, &err);
3978 if (err) {
3979 goto out;
3980 }
3981 }
3982 if (visit_optional(v, "floppy", &obj->has_floppy)) {
3983 visit_type_bool(v, "floppy", &obj->floppy, &err);
3984 if (err) {
3985 goto out;
3986 }
3987 }
3988 if (visit_optional(v, "label", &obj->has_label)) {
3989 visit_type_str(v, "label", &obj->label, &err);
3990 if (err) {
3991 goto out;
3992 }
3993 }
3994 if (visit_optional(v, "rw", &obj->has_rw)) {
3995 visit_type_bool(v, "rw", &obj->rw, &err);
3996 if (err) {
3997 goto out;
3998 }
3999 }
4000
4001out:
4002 error_propagate(errp, err);
4003}
4004
4005void visit_type_BlockdevOptionsVVFAT(Visitor *v, const char *name, BlockdevOptionsVVFAT **obj, Error **errp)
4006{
4007 Error *err = NULL;
4008
4009 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsVVFAT), &err);
4010 if (err) {
4011 goto out;
4012 }
4013 if (!*obj) {
4014 goto out_obj;
4015 }
4016 visit_type_BlockdevOptionsVVFAT_members(v, *obj, &err);
4017 if (err) {
4018 goto out_obj;
4019 }
4020 visit_check_struct(v, &err);
4021out_obj:
4022 visit_end_struct(v, (void **)obj);
4023 if (err && visit_is_input(v)) {
4024 qapi_free_BlockdevOptionsVVFAT(*obj);
4025 *obj = NULL;
4026 }
4027out:
4028 error_propagate(errp, err);
4029}
4030
4031void visit_type_BlockdevOptionsGenericFormat_members(Visitor *v, BlockdevOptionsGenericFormat *obj, Error **errp)
4032{
4033 Error *err = NULL;
4034
4035 visit_type_BlockdevRef(v, "file", &obj->file, &err);
4036 if (err) {
4037 goto out;
4038 }
4039
4040out:
4041 error_propagate(errp, err);
4042}
4043
4044void visit_type_BlockdevOptionsGenericFormat(Visitor *v, const char *name, BlockdevOptionsGenericFormat **obj, Error **errp)
4045{
4046 Error *err = NULL;
4047
4048 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsGenericFormat), &err);
4049 if (err) {
4050 goto out;
4051 }
4052 if (!*obj) {
4053 goto out_obj;
4054 }
4055 visit_type_BlockdevOptionsGenericFormat_members(v, *obj, &err);
4056 if (err) {
4057 goto out_obj;
4058 }
4059 visit_check_struct(v, &err);
4060out_obj:
4061 visit_end_struct(v, (void **)obj);
4062 if (err && visit_is_input(v)) {
4063 qapi_free_BlockdevOptionsGenericFormat(*obj);
4064 *obj = NULL;
4065 }
4066out:
4067 error_propagate(errp, err);
4068}
4069
4070void visit_type_BlockdevOptionsLUKS_members(Visitor *v, BlockdevOptionsLUKS *obj, Error **errp)
4071{
4072 Error *err = NULL;
4073
4074 visit_type_BlockdevOptionsGenericFormat_members(v, (BlockdevOptionsGenericFormat *)obj, &err);
4075 if (err) {
4076 goto out;
4077 }
4078 if (visit_optional(v, "key-secret", &obj->has_key_secret)) {
4079 visit_type_str(v, "key-secret", &obj->key_secret, &err);
4080 if (err) {
4081 goto out;
4082 }
4083 }
4084
4085out:
4086 error_propagate(errp, err);
4087}
4088
4089void visit_type_BlockdevOptionsLUKS(Visitor *v, const char *name, BlockdevOptionsLUKS **obj, Error **errp)
4090{
4091 Error *err = NULL;
4092
4093 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsLUKS), &err);
4094 if (err) {
4095 goto out;
4096 }
4097 if (!*obj) {
4098 goto out_obj;
4099 }
4100 visit_type_BlockdevOptionsLUKS_members(v, *obj, &err);
4101 if (err) {
4102 goto out_obj;
4103 }
4104 visit_check_struct(v, &err);
4105out_obj:
4106 visit_end_struct(v, (void **)obj);
4107 if (err && visit_is_input(v)) {
4108 qapi_free_BlockdevOptionsLUKS(*obj);
4109 *obj = NULL;
4110 }
4111out:
4112 error_propagate(errp, err);
4113}
4114
4115void visit_type_BlockdevOptionsGenericCOWFormat_members(Visitor *v, BlockdevOptionsGenericCOWFormat *obj, Error **errp)
4116{
4117 Error *err = NULL;
4118
4119 visit_type_BlockdevOptionsGenericFormat_members(v, (BlockdevOptionsGenericFormat *)obj, &err);
4120 if (err) {
4121 goto out;
4122 }
4123 if (visit_optional(v, "backing", &obj->has_backing)) {
4124 visit_type_BlockdevRefOrNull(v, "backing", &obj->backing, &err);
4125 if (err) {
4126 goto out;
4127 }
4128 }
4129
4130out:
4131 error_propagate(errp, err);
4132}
4133
4134void visit_type_BlockdevOptionsGenericCOWFormat(Visitor *v, const char *name, BlockdevOptionsGenericCOWFormat **obj, Error **errp)
4135{
4136 Error *err = NULL;
4137
4138 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsGenericCOWFormat), &err);
4139 if (err) {
4140 goto out;
4141 }
4142 if (!*obj) {
4143 goto out_obj;
4144 }
4145 visit_type_BlockdevOptionsGenericCOWFormat_members(v, *obj, &err);
4146 if (err) {
4147 goto out_obj;
4148 }
4149 visit_check_struct(v, &err);
4150out_obj:
4151 visit_end_struct(v, (void **)obj);
4152 if (err && visit_is_input(v)) {
4153 qapi_free_BlockdevOptionsGenericCOWFormat(*obj);
4154 *obj = NULL;
4155 }
4156out:
4157 error_propagate(errp, err);
4158}
4159
4160void visit_type_Qcow2OverlapCheckMode(Visitor *v, const char *name, Qcow2OverlapCheckMode *obj, Error **errp)
4161{
4162 int value = *obj;
4163 visit_type_enum(v, name, &value, &Qcow2OverlapCheckMode_lookup, errp);
4164 *obj = value;
4165}
4166
4167void visit_type_Qcow2OverlapCheckFlags_members(Visitor *v, Qcow2OverlapCheckFlags *obj, Error **errp)
4168{
4169 Error *err = NULL;
4170
4171 if (visit_optional(v, "template", &obj->has_q_template)) {
4172 visit_type_Qcow2OverlapCheckMode(v, "template", &obj->q_template, &err);
4173 if (err) {
4174 goto out;
4175 }
4176 }
4177 if (visit_optional(v, "main-header", &obj->has_main_header)) {
4178 visit_type_bool(v, "main-header", &obj->main_header, &err);
4179 if (err) {
4180 goto out;
4181 }
4182 }
4183 if (visit_optional(v, "active-l1", &obj->has_active_l1)) {
4184 visit_type_bool(v, "active-l1", &obj->active_l1, &err);
4185 if (err) {
4186 goto out;
4187 }
4188 }
4189 if (visit_optional(v, "active-l2", &obj->has_active_l2)) {
4190 visit_type_bool(v, "active-l2", &obj->active_l2, &err);
4191 if (err) {
4192 goto out;
4193 }
4194 }
4195 if (visit_optional(v, "refcount-table", &obj->has_refcount_table)) {
4196 visit_type_bool(v, "refcount-table", &obj->refcount_table, &err);
4197 if (err) {
4198 goto out;
4199 }
4200 }
4201 if (visit_optional(v, "refcount-block", &obj->has_refcount_block)) {
4202 visit_type_bool(v, "refcount-block", &obj->refcount_block, &err);
4203 if (err) {
4204 goto out;
4205 }
4206 }
4207 if (visit_optional(v, "snapshot-table", &obj->has_snapshot_table)) {
4208 visit_type_bool(v, "snapshot-table", &obj->snapshot_table, &err);
4209 if (err) {
4210 goto out;
4211 }
4212 }
4213 if (visit_optional(v, "inactive-l1", &obj->has_inactive_l1)) {
4214 visit_type_bool(v, "inactive-l1", &obj->inactive_l1, &err);
4215 if (err) {
4216 goto out;
4217 }
4218 }
4219 if (visit_optional(v, "inactive-l2", &obj->has_inactive_l2)) {
4220 visit_type_bool(v, "inactive-l2", &obj->inactive_l2, &err);
4221 if (err) {
4222 goto out;
4223 }
4224 }
4225 if (visit_optional(v, "bitmap-directory", &obj->has_bitmap_directory)) {
4226 visit_type_bool(v, "bitmap-directory", &obj->bitmap_directory, &err);
4227 if (err) {
4228 goto out;
4229 }
4230 }
4231
4232out:
4233 error_propagate(errp, err);
4234}
4235
4236void visit_type_Qcow2OverlapCheckFlags(Visitor *v, const char *name, Qcow2OverlapCheckFlags **obj, Error **errp)
4237{
4238 Error *err = NULL;
4239
4240 visit_start_struct(v, name, (void **)obj, sizeof(Qcow2OverlapCheckFlags), &err);
4241 if (err) {
4242 goto out;
4243 }
4244 if (!*obj) {
4245 goto out_obj;
4246 }
4247 visit_type_Qcow2OverlapCheckFlags_members(v, *obj, &err);
4248 if (err) {
4249 goto out_obj;
4250 }
4251 visit_check_struct(v, &err);
4252out_obj:
4253 visit_end_struct(v, (void **)obj);
4254 if (err && visit_is_input(v)) {
4255 qapi_free_Qcow2OverlapCheckFlags(*obj);
4256 *obj = NULL;
4257 }
4258out:
4259 error_propagate(errp, err);
4260}
4261
4262void visit_type_Qcow2OverlapChecks(Visitor *v, const char *name, Qcow2OverlapChecks **obj, Error **errp)
4263{
4264 Error *err = NULL;
4265
4266 visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
4267 &err);
4268 if (err) {
4269 goto out;
4270 }
4271 if (!*obj) {
4272 goto out_obj;
4273 }
4274 switch ((*obj)->type) {
4275 case QTYPE_QDICT:
4276 visit_start_struct(v, name, NULL, 0, &err);
4277 if (err) {
4278 break;
4279 }
4280 visit_type_Qcow2OverlapCheckFlags_members(v, &(*obj)->u.flags, &err);
4281 if (!err) {
4282 visit_check_struct(v, &err);
4283 }
4284 visit_end_struct(v, NULL);
4285 break;
4286 case QTYPE_QSTRING:
4287 visit_type_Qcow2OverlapCheckMode(v, name, &(*obj)->u.mode, &err);
4288 break;
4289 case QTYPE_NONE:
4290 abort();
4291 default:
4292 error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
4293 "Qcow2OverlapChecks");
4294 }
4295out_obj:
4296 visit_end_alternate(v, (void **)obj);
4297 if (err && visit_is_input(v)) {
4298 qapi_free_Qcow2OverlapChecks(*obj);
4299 *obj = NULL;
4300 }
4301out:
4302 error_propagate(errp, err);
4303}
4304
4305void visit_type_BlockdevQcowEncryptionFormat(Visitor *v, const char *name, BlockdevQcowEncryptionFormat *obj, Error **errp)
4306{
4307 int value = *obj;
4308 visit_type_enum(v, name, &value, &BlockdevQcowEncryptionFormat_lookup, errp);
4309 *obj = value;
4310}
4311
4312void visit_type_q_obj_BlockdevQcowEncryption_base_members(Visitor *v, q_obj_BlockdevQcowEncryption_base *obj, Error **errp)
4313{
4314 Error *err = NULL;
4315
4316 visit_type_BlockdevQcowEncryptionFormat(v, "format", &obj->format, &err);
4317 if (err) {
4318 goto out;
4319 }
4320
4321out:
4322 error_propagate(errp, err);
4323}
4324
4325void visit_type_BlockdevQcowEncryption_members(Visitor *v, BlockdevQcowEncryption *obj, Error **errp)
4326{
4327 Error *err = NULL;
4328
4329 visit_type_q_obj_BlockdevQcowEncryption_base_members(v, (q_obj_BlockdevQcowEncryption_base *)obj, &err);
4330 if (err) {
4331 goto out;
4332 }
4333 switch (obj->format) {
4334 case BLOCKDEV_QCOW_ENCRYPTION_FORMAT_AES:
4335 visit_type_QCryptoBlockOptionsQCow_members(v, &obj->u.aes, &err);
4336 break;
4337 default:
4338 abort();
4339 }
4340
4341out:
4342 error_propagate(errp, err);
4343}
4344
4345void visit_type_BlockdevQcowEncryption(Visitor *v, const char *name, BlockdevQcowEncryption **obj, Error **errp)
4346{
4347 Error *err = NULL;
4348
4349 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevQcowEncryption), &err);
4350 if (err) {
4351 goto out;
4352 }
4353 if (!*obj) {
4354 goto out_obj;
4355 }
4356 visit_type_BlockdevQcowEncryption_members(v, *obj, &err);
4357 if (err) {
4358 goto out_obj;
4359 }
4360 visit_check_struct(v, &err);
4361out_obj:
4362 visit_end_struct(v, (void **)obj);
4363 if (err && visit_is_input(v)) {
4364 qapi_free_BlockdevQcowEncryption(*obj);
4365 *obj = NULL;
4366 }
4367out:
4368 error_propagate(errp, err);
4369}
4370
4371void visit_type_BlockdevOptionsQcow_members(Visitor *v, BlockdevOptionsQcow *obj, Error **errp)
4372{
4373 Error *err = NULL;
4374
4375 visit_type_BlockdevOptionsGenericCOWFormat_members(v, (BlockdevOptionsGenericCOWFormat *)obj, &err);
4376 if (err) {
4377 goto out;
4378 }
4379 if (visit_optional(v, "encrypt", &obj->has_encrypt)) {
4380 visit_type_BlockdevQcowEncryption(v, "encrypt", &obj->encrypt, &err);
4381 if (err) {
4382 goto out;
4383 }
4384 }
4385
4386out:
4387 error_propagate(errp, err);
4388}
4389
4390void visit_type_BlockdevOptionsQcow(Visitor *v, const char *name, BlockdevOptionsQcow **obj, Error **errp)
4391{
4392 Error *err = NULL;
4393
4394 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsQcow), &err);
4395 if (err) {
4396 goto out;
4397 }
4398 if (!*obj) {
4399 goto out_obj;
4400 }
4401 visit_type_BlockdevOptionsQcow_members(v, *obj, &err);
4402 if (err) {
4403 goto out_obj;
4404 }
4405 visit_check_struct(v, &err);
4406out_obj:
4407 visit_end_struct(v, (void **)obj);
4408 if (err && visit_is_input(v)) {
4409 qapi_free_BlockdevOptionsQcow(*obj);
4410 *obj = NULL;
4411 }
4412out:
4413 error_propagate(errp, err);
4414}
4415
4416void visit_type_BlockdevQcow2EncryptionFormat(Visitor *v, const char *name, BlockdevQcow2EncryptionFormat *obj, Error **errp)
4417{
4418 int value = *obj;
4419 visit_type_enum(v, name, &value, &BlockdevQcow2EncryptionFormat_lookup, errp);
4420 *obj = value;
4421}
4422
4423void visit_type_q_obj_BlockdevQcow2Encryption_base_members(Visitor *v, q_obj_BlockdevQcow2Encryption_base *obj, Error **errp)
4424{
4425 Error *err = NULL;
4426
4427 visit_type_BlockdevQcow2EncryptionFormat(v, "format", &obj->format, &err);
4428 if (err) {
4429 goto out;
4430 }
4431
4432out:
4433 error_propagate(errp, err);
4434}
4435
4436void visit_type_BlockdevQcow2Encryption_members(Visitor *v, BlockdevQcow2Encryption *obj, Error **errp)
4437{
4438 Error *err = NULL;
4439
4440 visit_type_q_obj_BlockdevQcow2Encryption_base_members(v, (q_obj_BlockdevQcow2Encryption_base *)obj, &err);
4441 if (err) {
4442 goto out;
4443 }
4444 switch (obj->format) {
4445 case BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES:
4446 visit_type_QCryptoBlockOptionsQCow_members(v, &obj->u.aes, &err);
4447 break;
4448 case BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS:
4449 visit_type_QCryptoBlockOptionsLUKS_members(v, &obj->u.luks, &err);
4450 break;
4451 default:
4452 abort();
4453 }
4454
4455out:
4456 error_propagate(errp, err);
4457}
4458
4459void visit_type_BlockdevQcow2Encryption(Visitor *v, const char *name, BlockdevQcow2Encryption **obj, Error **errp)
4460{
4461 Error *err = NULL;
4462
4463 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevQcow2Encryption), &err);
4464 if (err) {
4465 goto out;
4466 }
4467 if (!*obj) {
4468 goto out_obj;
4469 }
4470 visit_type_BlockdevQcow2Encryption_members(v, *obj, &err);
4471 if (err) {
4472 goto out_obj;
4473 }
4474 visit_check_struct(v, &err);
4475out_obj:
4476 visit_end_struct(v, (void **)obj);
4477 if (err && visit_is_input(v)) {
4478 qapi_free_BlockdevQcow2Encryption(*obj);
4479 *obj = NULL;
4480 }
4481out:
4482 error_propagate(errp, err);
4483}
4484
4485void visit_type_BlockdevOptionsQcow2_members(Visitor *v, BlockdevOptionsQcow2 *obj, Error **errp)
4486{
4487 Error *err = NULL;
4488
4489 visit_type_BlockdevOptionsGenericCOWFormat_members(v, (BlockdevOptionsGenericCOWFormat *)obj, &err);
4490 if (err) {
4491 goto out;
4492 }
4493 if (visit_optional(v, "lazy-refcounts", &obj->has_lazy_refcounts)) {
4494 visit_type_bool(v, "lazy-refcounts", &obj->lazy_refcounts, &err);
4495 if (err) {
4496 goto out;
4497 }
4498 }
4499 if (visit_optional(v, "pass-discard-request", &obj->has_pass_discard_request)) {
4500 visit_type_bool(v, "pass-discard-request", &obj->pass_discard_request, &err);
4501 if (err) {
4502 goto out;
4503 }
4504 }
4505 if (visit_optional(v, "pass-discard-snapshot", &obj->has_pass_discard_snapshot)) {
4506 visit_type_bool(v, "pass-discard-snapshot", &obj->pass_discard_snapshot, &err);
4507 if (err) {
4508 goto out;
4509 }
4510 }
4511 if (visit_optional(v, "pass-discard-other", &obj->has_pass_discard_other)) {
4512 visit_type_bool(v, "pass-discard-other", &obj->pass_discard_other, &err);
4513 if (err) {
4514 goto out;
4515 }
4516 }
4517 if (visit_optional(v, "overlap-check", &obj->has_overlap_check)) {
4518 visit_type_Qcow2OverlapChecks(v, "overlap-check", &obj->overlap_check, &err);
4519 if (err) {
4520 goto out;
4521 }
4522 }
4523 if (visit_optional(v, "cache-size", &obj->has_cache_size)) {
4524 visit_type_int(v, "cache-size", &obj->cache_size, &err);
4525 if (err) {
4526 goto out;
4527 }
4528 }
4529 if (visit_optional(v, "l2-cache-size", &obj->has_l2_cache_size)) {
4530 visit_type_int(v, "l2-cache-size", &obj->l2_cache_size, &err);
4531 if (err) {
4532 goto out;
4533 }
4534 }
4535 if (visit_optional(v, "l2-cache-entry-size", &obj->has_l2_cache_entry_size)) {
4536 visit_type_int(v, "l2-cache-entry-size", &obj->l2_cache_entry_size, &err);
4537 if (err) {
4538 goto out;
4539 }
4540 }
4541 if (visit_optional(v, "refcount-cache-size", &obj->has_refcount_cache_size)) {
4542 visit_type_int(v, "refcount-cache-size", &obj->refcount_cache_size, &err);
4543 if (err) {
4544 goto out;
4545 }
4546 }
4547 if (visit_optional(v, "cache-clean-interval", &obj->has_cache_clean_interval)) {
4548 visit_type_int(v, "cache-clean-interval", &obj->cache_clean_interval, &err);
4549 if (err) {
4550 goto out;
4551 }
4552 }
4553 if (visit_optional(v, "encrypt", &obj->has_encrypt)) {
4554 visit_type_BlockdevQcow2Encryption(v, "encrypt", &obj->encrypt, &err);
4555 if (err) {
4556 goto out;
4557 }
4558 }
4559 if (visit_optional(v, "data-file", &obj->has_data_file)) {
4560 visit_type_BlockdevRef(v, "data-file", &obj->data_file, &err);
4561 if (err) {
4562 goto out;
4563 }
4564 }
4565
4566out:
4567 error_propagate(errp, err);
4568}
4569
4570void visit_type_BlockdevOptionsQcow2(Visitor *v, const char *name, BlockdevOptionsQcow2 **obj, Error **errp)
4571{
4572 Error *err = NULL;
4573
4574 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsQcow2), &err);
4575 if (err) {
4576 goto out;
4577 }
4578 if (!*obj) {
4579 goto out_obj;
4580 }
4581 visit_type_BlockdevOptionsQcow2_members(v, *obj, &err);
4582 if (err) {
4583 goto out_obj;
4584 }
4585 visit_check_struct(v, &err);
4586out_obj:
4587 visit_end_struct(v, (void **)obj);
4588 if (err && visit_is_input(v)) {
4589 qapi_free_BlockdevOptionsQcow2(*obj);
4590 *obj = NULL;
4591 }
4592out:
4593 error_propagate(errp, err);
4594}
4595
4596void visit_type_SshHostKeyCheckMode(Visitor *v, const char *name, SshHostKeyCheckMode *obj, Error **errp)
4597{
4598 int value = *obj;
4599 visit_type_enum(v, name, &value, &SshHostKeyCheckMode_lookup, errp);
4600 *obj = value;
4601}
4602
4603void visit_type_SshHostKeyCheckHashType(Visitor *v, const char *name, SshHostKeyCheckHashType *obj, Error **errp)
4604{
4605 int value = *obj;
4606 visit_type_enum(v, name, &value, &SshHostKeyCheckHashType_lookup, errp);
4607 *obj = value;
4608}
4609
4610void visit_type_SshHostKeyHash_members(Visitor *v, SshHostKeyHash *obj, Error **errp)
4611{
4612 Error *err = NULL;
4613
4614 visit_type_SshHostKeyCheckHashType(v, "type", &obj->type, &err);
4615 if (err) {
4616 goto out;
4617 }
4618 visit_type_str(v, "hash", &obj->hash, &err);
4619 if (err) {
4620 goto out;
4621 }
4622
4623out:
4624 error_propagate(errp, err);
4625}
4626
4627void visit_type_SshHostKeyHash(Visitor *v, const char *name, SshHostKeyHash **obj, Error **errp)
4628{
4629 Error *err = NULL;
4630
4631 visit_start_struct(v, name, (void **)obj, sizeof(SshHostKeyHash), &err);
4632 if (err) {
4633 goto out;
4634 }
4635 if (!*obj) {
4636 goto out_obj;
4637 }
4638 visit_type_SshHostKeyHash_members(v, *obj, &err);
4639 if (err) {
4640 goto out_obj;
4641 }
4642 visit_check_struct(v, &err);
4643out_obj:
4644 visit_end_struct(v, (void **)obj);
4645 if (err && visit_is_input(v)) {
4646 qapi_free_SshHostKeyHash(*obj);
4647 *obj = NULL;
4648 }
4649out:
4650 error_propagate(errp, err);
4651}
4652
4653void visit_type_q_obj_SshHostKeyCheck_base_members(Visitor *v, q_obj_SshHostKeyCheck_base *obj, Error **errp)
4654{
4655 Error *err = NULL;
4656
4657 visit_type_SshHostKeyCheckMode(v, "mode", &obj->mode, &err);
4658 if (err) {
4659 goto out;
4660 }
4661
4662out:
4663 error_propagate(errp, err);
4664}
4665
4666void visit_type_SshHostKeyCheck_members(Visitor *v, SshHostKeyCheck *obj, Error **errp)
4667{
4668 Error *err = NULL;
4669
4670 visit_type_q_obj_SshHostKeyCheck_base_members(v, (q_obj_SshHostKeyCheck_base *)obj, &err);
4671 if (err) {
4672 goto out;
4673 }
4674 switch (obj->mode) {
4675 case SSH_HOST_KEY_CHECK_MODE_HASH:
4676 visit_type_SshHostKeyHash_members(v, &obj->u.hash, &err);
4677 break;
4678 case SSH_HOST_KEY_CHECK_MODE_NONE:
4679 break;
4680 case SSH_HOST_KEY_CHECK_MODE_KNOWN_HOSTS:
4681 break;
4682 default:
4683 abort();
4684 }
4685
4686out:
4687 error_propagate(errp, err);
4688}
4689
4690void visit_type_SshHostKeyCheck(Visitor *v, const char *name, SshHostKeyCheck **obj, Error **errp)
4691{
4692 Error *err = NULL;
4693
4694 visit_start_struct(v, name, (void **)obj, sizeof(SshHostKeyCheck), &err);
4695 if (err) {
4696 goto out;
4697 }
4698 if (!*obj) {
4699 goto out_obj;
4700 }
4701 visit_type_SshHostKeyCheck_members(v, *obj, &err);
4702 if (err) {
4703 goto out_obj;
4704 }
4705 visit_check_struct(v, &err);
4706out_obj:
4707 visit_end_struct(v, (void **)obj);
4708 if (err && visit_is_input(v)) {
4709 qapi_free_SshHostKeyCheck(*obj);
4710 *obj = NULL;
4711 }
4712out:
4713 error_propagate(errp, err);
4714}
4715
4716void visit_type_BlockdevOptionsSsh_members(Visitor *v, BlockdevOptionsSsh *obj, Error **errp)
4717{
4718 Error *err = NULL;
4719
4720 visit_type_InetSocketAddress(v, "server", &obj->server, &err);
4721 if (err) {
4722 goto out;
4723 }
4724 visit_type_str(v, "path", &obj->path, &err);
4725 if (err) {
4726 goto out;
4727 }
4728 if (visit_optional(v, "user", &obj->has_user)) {
4729 visit_type_str(v, "user", &obj->user, &err);
4730 if (err) {
4731 goto out;
4732 }
4733 }
4734 if (visit_optional(v, "host-key-check", &obj->has_host_key_check)) {
4735 visit_type_SshHostKeyCheck(v, "host-key-check", &obj->host_key_check, &err);
4736 if (err) {
4737 goto out;
4738 }
4739 }
4740
4741out:
4742 error_propagate(errp, err);
4743}
4744
4745void visit_type_BlockdevOptionsSsh(Visitor *v, const char *name, BlockdevOptionsSsh **obj, Error **errp)
4746{
4747 Error *err = NULL;
4748
4749 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsSsh), &err);
4750 if (err) {
4751 goto out;
4752 }
4753 if (!*obj) {
4754 goto out_obj;
4755 }
4756 visit_type_BlockdevOptionsSsh_members(v, *obj, &err);
4757 if (err) {
4758 goto out_obj;
4759 }
4760 visit_check_struct(v, &err);
4761out_obj:
4762 visit_end_struct(v, (void **)obj);
4763 if (err && visit_is_input(v)) {
4764 qapi_free_BlockdevOptionsSsh(*obj);
4765 *obj = NULL;
4766 }
4767out:
4768 error_propagate(errp, err);
4769}
4770
4771void visit_type_BlkdebugEvent(Visitor *v, const char *name, BlkdebugEvent *obj, Error **errp)
4772{
4773 int value = *obj;
4774 visit_type_enum(v, name, &value, &BlkdebugEvent_lookup, errp);
4775 *obj = value;
4776}
4777
4778void visit_type_BlkdebugIOType(Visitor *v, const char *name, BlkdebugIOType *obj, Error **errp)
4779{
4780 int value = *obj;
4781 visit_type_enum(v, name, &value, &BlkdebugIOType_lookup, errp);
4782 *obj = value;
4783}
4784
4785void visit_type_BlkdebugInjectErrorOptions_members(Visitor *v, BlkdebugInjectErrorOptions *obj, Error **errp)
4786{
4787 Error *err = NULL;
4788
4789 visit_type_BlkdebugEvent(v, "event", &obj->event, &err);
4790 if (err) {
4791 goto out;
4792 }
4793 if (visit_optional(v, "state", &obj->has_state)) {
4794 visit_type_int(v, "state", &obj->state, &err);
4795 if (err) {
4796 goto out;
4797 }
4798 }
4799 if (visit_optional(v, "iotype", &obj->has_iotype)) {
4800 visit_type_BlkdebugIOType(v, "iotype", &obj->iotype, &err);
4801 if (err) {
4802 goto out;
4803 }
4804 }
4805 if (visit_optional(v, "errno", &obj->has_q_errno)) {
4806 visit_type_int(v, "errno", &obj->q_errno, &err);
4807 if (err) {
4808 goto out;
4809 }
4810 }
4811 if (visit_optional(v, "sector", &obj->has_sector)) {
4812 visit_type_int(v, "sector", &obj->sector, &err);
4813 if (err) {
4814 goto out;
4815 }
4816 }
4817 if (visit_optional(v, "once", &obj->has_once)) {
4818 visit_type_bool(v, "once", &obj->once, &err);
4819 if (err) {
4820 goto out;
4821 }
4822 }
4823 if (visit_optional(v, "immediately", &obj->has_immediately)) {
4824 visit_type_bool(v, "immediately", &obj->immediately, &err);
4825 if (err) {
4826 goto out;
4827 }
4828 }
4829
4830out:
4831 error_propagate(errp, err);
4832}
4833
4834void visit_type_BlkdebugInjectErrorOptions(Visitor *v, const char *name, BlkdebugInjectErrorOptions **obj, Error **errp)
4835{
4836 Error *err = NULL;
4837
4838 visit_start_struct(v, name, (void **)obj, sizeof(BlkdebugInjectErrorOptions), &err);
4839 if (err) {
4840 goto out;
4841 }
4842 if (!*obj) {
4843 goto out_obj;
4844 }
4845 visit_type_BlkdebugInjectErrorOptions_members(v, *obj, &err);
4846 if (err) {
4847 goto out_obj;
4848 }
4849 visit_check_struct(v, &err);
4850out_obj:
4851 visit_end_struct(v, (void **)obj);
4852 if (err && visit_is_input(v)) {
4853 qapi_free_BlkdebugInjectErrorOptions(*obj);
4854 *obj = NULL;
4855 }
4856out:
4857 error_propagate(errp, err);
4858}
4859
4860void visit_type_BlkdebugSetStateOptions_members(Visitor *v, BlkdebugSetStateOptions *obj, Error **errp)
4861{
4862 Error *err = NULL;
4863
4864 visit_type_BlkdebugEvent(v, "event", &obj->event, &err);
4865 if (err) {
4866 goto out;
4867 }
4868 if (visit_optional(v, "state", &obj->has_state)) {
4869 visit_type_int(v, "state", &obj->state, &err);
4870 if (err) {
4871 goto out;
4872 }
4873 }
4874 visit_type_int(v, "new_state", &obj->new_state, &err);
4875 if (err) {
4876 goto out;
4877 }
4878
4879out:
4880 error_propagate(errp, err);
4881}
4882
4883void visit_type_BlkdebugSetStateOptions(Visitor *v, const char *name, BlkdebugSetStateOptions **obj, Error **errp)
4884{
4885 Error *err = NULL;
4886
4887 visit_start_struct(v, name, (void **)obj, sizeof(BlkdebugSetStateOptions), &err);
4888 if (err) {
4889 goto out;
4890 }
4891 if (!*obj) {
4892 goto out_obj;
4893 }
4894 visit_type_BlkdebugSetStateOptions_members(v, *obj, &err);
4895 if (err) {
4896 goto out_obj;
4897 }
4898 visit_check_struct(v, &err);
4899out_obj:
4900 visit_end_struct(v, (void **)obj);
4901 if (err && visit_is_input(v)) {
4902 qapi_free_BlkdebugSetStateOptions(*obj);
4903 *obj = NULL;
4904 }
4905out:
4906 error_propagate(errp, err);
4907}
4908
4909void visit_type_BlkdebugInjectErrorOptionsList(Visitor *v, const char *name, BlkdebugInjectErrorOptionsList **obj, Error **errp)
4910{
4911 Error *err = NULL;
4912 BlkdebugInjectErrorOptionsList *tail;
4913 size_t size = sizeof(**obj);
4914
4915 visit_start_list(v, name, (GenericList **)obj, size, &err);
4916 if (err) {
4917 goto out;
4918 }
4919
4920 for (tail = *obj; tail;
4921 tail = (BlkdebugInjectErrorOptionsList *)visit_next_list(v, (GenericList *)tail, size)) {
4922 visit_type_BlkdebugInjectErrorOptions(v, NULL, &tail->value, &err);
4923 if (err) {
4924 break;
4925 }
4926 }
4927
4928 if (!err) {
4929 visit_check_list(v, &err);
4930 }
4931 visit_end_list(v, (void **)obj);
4932 if (err && visit_is_input(v)) {
4933 qapi_free_BlkdebugInjectErrorOptionsList(*obj);
4934 *obj = NULL;
4935 }
4936out:
4937 error_propagate(errp, err);
4938}
4939
4940void visit_type_BlkdebugSetStateOptionsList(Visitor *v, const char *name, BlkdebugSetStateOptionsList **obj, Error **errp)
4941{
4942 Error *err = NULL;
4943 BlkdebugSetStateOptionsList *tail;
4944 size_t size = sizeof(**obj);
4945
4946 visit_start_list(v, name, (GenericList **)obj, size, &err);
4947 if (err) {
4948 goto out;
4949 }
4950
4951 for (tail = *obj; tail;
4952 tail = (BlkdebugSetStateOptionsList *)visit_next_list(v, (GenericList *)tail, size)) {
4953 visit_type_BlkdebugSetStateOptions(v, NULL, &tail->value, &err);
4954 if (err) {
4955 break;
4956 }
4957 }
4958
4959 if (!err) {
4960 visit_check_list(v, &err);
4961 }
4962 visit_end_list(v, (void **)obj);
4963 if (err && visit_is_input(v)) {
4964 qapi_free_BlkdebugSetStateOptionsList(*obj);
4965 *obj = NULL;
4966 }
4967out:
4968 error_propagate(errp, err);
4969}
4970
4971void visit_type_BlockdevOptionsBlkdebug_members(Visitor *v, BlockdevOptionsBlkdebug *obj, Error **errp)
4972{
4973 Error *err = NULL;
4974
4975 visit_type_BlockdevRef(v, "image", &obj->image, &err);
4976 if (err) {
4977 goto out;
4978 }
4979 if (visit_optional(v, "config", &obj->has_config)) {
4980 visit_type_str(v, "config", &obj->config, &err);
4981 if (err) {
4982 goto out;
4983 }
4984 }
4985 if (visit_optional(v, "align", &obj->has_align)) {
4986 visit_type_int(v, "align", &obj->align, &err);
4987 if (err) {
4988 goto out;
4989 }
4990 }
4991 if (visit_optional(v, "max-transfer", &obj->has_max_transfer)) {
4992 visit_type_int32(v, "max-transfer", &obj->max_transfer, &err);
4993 if (err) {
4994 goto out;
4995 }
4996 }
4997 if (visit_optional(v, "opt-write-zero", &obj->has_opt_write_zero)) {
4998 visit_type_int32(v, "opt-write-zero", &obj->opt_write_zero, &err);
4999 if (err) {
5000 goto out;
5001 }
5002 }
5003 if (visit_optional(v, "max-write-zero", &obj->has_max_write_zero)) {
5004 visit_type_int32(v, "max-write-zero", &obj->max_write_zero, &err);
5005 if (err) {
5006 goto out;
5007 }
5008 }
5009 if (visit_optional(v, "opt-discard", &obj->has_opt_discard)) {
5010 visit_type_int32(v, "opt-discard", &obj->opt_discard, &err);
5011 if (err) {
5012 goto out;
5013 }
5014 }
5015 if (visit_optional(v, "max-discard", &obj->has_max_discard)) {
5016 visit_type_int32(v, "max-discard", &obj->max_discard, &err);
5017 if (err) {
5018 goto out;
5019 }
5020 }
5021 if (visit_optional(v, "inject-error", &obj->has_inject_error)) {
5022 visit_type_BlkdebugInjectErrorOptionsList(v, "inject-error", &obj->inject_error, &err);
5023 if (err) {
5024 goto out;
5025 }
5026 }
5027 if (visit_optional(v, "set-state", &obj->has_set_state)) {
5028 visit_type_BlkdebugSetStateOptionsList(v, "set-state", &obj->set_state, &err);
5029 if (err) {
5030 goto out;
5031 }
5032 }
5033
5034out:
5035 error_propagate(errp, err);
5036}
5037
5038void visit_type_BlockdevOptionsBlkdebug(Visitor *v, const char *name, BlockdevOptionsBlkdebug **obj, Error **errp)
5039{
5040 Error *err = NULL;
5041
5042 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsBlkdebug), &err);
5043 if (err) {
5044 goto out;
5045 }
5046 if (!*obj) {
5047 goto out_obj;
5048 }
5049 visit_type_BlockdevOptionsBlkdebug_members(v, *obj, &err);
5050 if (err) {
5051 goto out_obj;
5052 }
5053 visit_check_struct(v, &err);
5054out_obj:
5055 visit_end_struct(v, (void **)obj);
5056 if (err && visit_is_input(v)) {
5057 qapi_free_BlockdevOptionsBlkdebug(*obj);
5058 *obj = NULL;
5059 }
5060out:
5061 error_propagate(errp, err);
5062}
5063
5064void visit_type_BlockdevOptionsBlklogwrites_members(Visitor *v, BlockdevOptionsBlklogwrites *obj, Error **errp)
5065{
5066 Error *err = NULL;
5067
5068 visit_type_BlockdevRef(v, "file", &obj->file, &err);
5069 if (err) {
5070 goto out;
5071 }
5072 visit_type_BlockdevRef(v, "log", &obj->log, &err);
5073 if (err) {
5074 goto out;
5075 }
5076 if (visit_optional(v, "log-sector-size", &obj->has_log_sector_size)) {
5077 visit_type_uint32(v, "log-sector-size", &obj->log_sector_size, &err);
5078 if (err) {
5079 goto out;
5080 }
5081 }
5082 if (visit_optional(v, "log-append", &obj->has_log_append)) {
5083 visit_type_bool(v, "log-append", &obj->log_append, &err);
5084 if (err) {
5085 goto out;
5086 }
5087 }
5088 if (visit_optional(v, "log-super-update-interval", &obj->has_log_super_update_interval)) {
5089 visit_type_uint64(v, "log-super-update-interval", &obj->log_super_update_interval, &err);
5090 if (err) {
5091 goto out;
5092 }
5093 }
5094
5095out:
5096 error_propagate(errp, err);
5097}
5098
5099void visit_type_BlockdevOptionsBlklogwrites(Visitor *v, const char *name, BlockdevOptionsBlklogwrites **obj, Error **errp)
5100{
5101 Error *err = NULL;
5102
5103 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsBlklogwrites), &err);
5104 if (err) {
5105 goto out;
5106 }
5107 if (!*obj) {
5108 goto out_obj;
5109 }
5110 visit_type_BlockdevOptionsBlklogwrites_members(v, *obj, &err);
5111 if (err) {
5112 goto out_obj;
5113 }
5114 visit_check_struct(v, &err);
5115out_obj:
5116 visit_end_struct(v, (void **)obj);
5117 if (err && visit_is_input(v)) {
5118 qapi_free_BlockdevOptionsBlklogwrites(*obj);
5119 *obj = NULL;
5120 }
5121out:
5122 error_propagate(errp, err);
5123}
5124
5125void visit_type_BlockdevOptionsBlkverify_members(Visitor *v, BlockdevOptionsBlkverify *obj, Error **errp)
5126{
5127 Error *err = NULL;
5128
5129 visit_type_BlockdevRef(v, "test", &obj->test, &err);
5130 if (err) {
5131 goto out;
5132 }
5133 visit_type_BlockdevRef(v, "raw", &obj->raw, &err);
5134 if (err) {
5135 goto out;
5136 }
5137
5138out:
5139 error_propagate(errp, err);
5140}
5141
5142void visit_type_BlockdevOptionsBlkverify(Visitor *v, const char *name, BlockdevOptionsBlkverify **obj, Error **errp)
5143{
5144 Error *err = NULL;
5145
5146 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsBlkverify), &err);
5147 if (err) {
5148 goto out;
5149 }
5150 if (!*obj) {
5151 goto out_obj;
5152 }
5153 visit_type_BlockdevOptionsBlkverify_members(v, *obj, &err);
5154 if (err) {
5155 goto out_obj;
5156 }
5157 visit_check_struct(v, &err);
5158out_obj:
5159 visit_end_struct(v, (void **)obj);
5160 if (err && visit_is_input(v)) {
5161 qapi_free_BlockdevOptionsBlkverify(*obj);
5162 *obj = NULL;
5163 }
5164out:
5165 error_propagate(errp, err);
5166}
5167
5168void visit_type_QuorumReadPattern(Visitor *v, const char *name, QuorumReadPattern *obj, Error **errp)
5169{
5170 int value = *obj;
5171 visit_type_enum(v, name, &value, &QuorumReadPattern_lookup, errp);
5172 *obj = value;
5173}
5174
5175void visit_type_BlockdevRefList(Visitor *v, const char *name, BlockdevRefList **obj, Error **errp)
5176{
5177 Error *err = NULL;
5178 BlockdevRefList *tail;
5179 size_t size = sizeof(**obj);
5180
5181 visit_start_list(v, name, (GenericList **)obj, size, &err);
5182 if (err) {
5183 goto out;
5184 }
5185
5186 for (tail = *obj; tail;
5187 tail = (BlockdevRefList *)visit_next_list(v, (GenericList *)tail, size)) {
5188 visit_type_BlockdevRef(v, NULL, &tail->value, &err);
5189 if (err) {
5190 break;
5191 }
5192 }
5193
5194 if (!err) {
5195 visit_check_list(v, &err);
5196 }
5197 visit_end_list(v, (void **)obj);
5198 if (err && visit_is_input(v)) {
5199 qapi_free_BlockdevRefList(*obj);
5200 *obj = NULL;
5201 }
5202out:
5203 error_propagate(errp, err);
5204}
5205
5206void visit_type_BlockdevOptionsQuorum_members(Visitor *v, BlockdevOptionsQuorum *obj, Error **errp)
5207{
5208 Error *err = NULL;
5209
5210 if (visit_optional(v, "blkverify", &obj->has_blkverify)) {
5211 visit_type_bool(v, "blkverify", &obj->blkverify, &err);
5212 if (err) {
5213 goto out;
5214 }
5215 }
5216 visit_type_BlockdevRefList(v, "children", &obj->children, &err);
5217 if (err) {
5218 goto out;
5219 }
5220 visit_type_int(v, "vote-threshold", &obj->vote_threshold, &err);
5221 if (err) {
5222 goto out;
5223 }
5224 if (visit_optional(v, "rewrite-corrupted", &obj->has_rewrite_corrupted)) {
5225 visit_type_bool(v, "rewrite-corrupted", &obj->rewrite_corrupted, &err);
5226 if (err) {
5227 goto out;
5228 }
5229 }
5230 if (visit_optional(v, "read-pattern", &obj->has_read_pattern)) {
5231 visit_type_QuorumReadPattern(v, "read-pattern", &obj->read_pattern, &err);
5232 if (err) {
5233 goto out;
5234 }
5235 }
5236
5237out:
5238 error_propagate(errp, err);
5239}
5240
5241void visit_type_BlockdevOptionsQuorum(Visitor *v, const char *name, BlockdevOptionsQuorum **obj, Error **errp)
5242{
5243 Error *err = NULL;
5244
5245 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsQuorum), &err);
5246 if (err) {
5247 goto out;
5248 }
5249 if (!*obj) {
5250 goto out_obj;
5251 }
5252 visit_type_BlockdevOptionsQuorum_members(v, *obj, &err);
5253 if (err) {
5254 goto out_obj;
5255 }
5256 visit_check_struct(v, &err);
5257out_obj:
5258 visit_end_struct(v, (void **)obj);
5259 if (err && visit_is_input(v)) {
5260 qapi_free_BlockdevOptionsQuorum(*obj);
5261 *obj = NULL;
5262 }
5263out:
5264 error_propagate(errp, err);
5265}
5266
5267void visit_type_BlockdevOptionsGluster_members(Visitor *v, BlockdevOptionsGluster *obj, Error **errp)
5268{
5269 Error *err = NULL;
5270
5271 visit_type_str(v, "volume", &obj->volume, &err);
5272 if (err) {
5273 goto out;
5274 }
5275 visit_type_str(v, "path", &obj->path, &err);
5276 if (err) {
5277 goto out;
5278 }
5279 visit_type_SocketAddressList(v, "server", &obj->server, &err);
5280 if (err) {
5281 goto out;
5282 }
5283 if (visit_optional(v, "debug", &obj->has_debug)) {
5284 visit_type_int(v, "debug", &obj->debug, &err);
5285 if (err) {
5286 goto out;
5287 }
5288 }
5289 if (visit_optional(v, "logfile", &obj->has_logfile)) {
5290 visit_type_str(v, "logfile", &obj->logfile, &err);
5291 if (err) {
5292 goto out;
5293 }
5294 }
5295
5296out:
5297 error_propagate(errp, err);
5298}
5299
5300void visit_type_BlockdevOptionsGluster(Visitor *v, const char *name, BlockdevOptionsGluster **obj, Error **errp)
5301{
5302 Error *err = NULL;
5303
5304 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsGluster), &err);
5305 if (err) {
5306 goto out;
5307 }
5308 if (!*obj) {
5309 goto out_obj;
5310 }
5311 visit_type_BlockdevOptionsGluster_members(v, *obj, &err);
5312 if (err) {
5313 goto out_obj;
5314 }
5315 visit_check_struct(v, &err);
5316out_obj:
5317 visit_end_struct(v, (void **)obj);
5318 if (err && visit_is_input(v)) {
5319 qapi_free_BlockdevOptionsGluster(*obj);
5320 *obj = NULL;
5321 }
5322out:
5323 error_propagate(errp, err);
5324}
5325
5326void visit_type_IscsiTransport(Visitor *v, const char *name, IscsiTransport *obj, Error **errp)
5327{
5328 int value = *obj;
5329 visit_type_enum(v, name, &value, &IscsiTransport_lookup, errp);
5330 *obj = value;
5331}
5332
5333void visit_type_IscsiHeaderDigest(Visitor *v, const char *name, IscsiHeaderDigest *obj, Error **errp)
5334{
5335 int value = *obj;
5336 visit_type_enum(v, name, &value, &IscsiHeaderDigest_lookup, errp);
5337 *obj = value;
5338}
5339
5340void visit_type_BlockdevOptionsIscsi_members(Visitor *v, BlockdevOptionsIscsi *obj, Error **errp)
5341{
5342 Error *err = NULL;
5343
5344 visit_type_IscsiTransport(v, "transport", &obj->transport, &err);
5345 if (err) {
5346 goto out;
5347 }
5348 visit_type_str(v, "portal", &obj->portal, &err);
5349 if (err) {
5350 goto out;
5351 }
5352 visit_type_str(v, "target", &obj->target, &err);
5353 if (err) {
5354 goto out;
5355 }
5356 if (visit_optional(v, "lun", &obj->has_lun)) {
5357 visit_type_int(v, "lun", &obj->lun, &err);
5358 if (err) {
5359 goto out;
5360 }
5361 }
5362 if (visit_optional(v, "user", &obj->has_user)) {
5363 visit_type_str(v, "user", &obj->user, &err);
5364 if (err) {
5365 goto out;
5366 }
5367 }
5368 if (visit_optional(v, "password-secret", &obj->has_password_secret)) {
5369 visit_type_str(v, "password-secret", &obj->password_secret, &err);
5370 if (err) {
5371 goto out;
5372 }
5373 }
5374 if (visit_optional(v, "initiator-name", &obj->has_initiator_name)) {
5375 visit_type_str(v, "initiator-name", &obj->initiator_name, &err);
5376 if (err) {
5377 goto out;
5378 }
5379 }
5380 if (visit_optional(v, "header-digest", &obj->has_header_digest)) {
5381 visit_type_IscsiHeaderDigest(v, "header-digest", &obj->header_digest, &err);
5382 if (err) {
5383 goto out;
5384 }
5385 }
5386 if (visit_optional(v, "timeout", &obj->has_timeout)) {
5387 visit_type_int(v, "timeout", &obj->timeout, &err);
5388 if (err) {
5389 goto out;
5390 }
5391 }
5392
5393out:
5394 error_propagate(errp, err);
5395}
5396
5397void visit_type_BlockdevOptionsIscsi(Visitor *v, const char *name, BlockdevOptionsIscsi **obj, Error **errp)
5398{
5399 Error *err = NULL;
5400
5401 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsIscsi), &err);
5402 if (err) {
5403 goto out;
5404 }
5405 if (!*obj) {
5406 goto out_obj;
5407 }
5408 visit_type_BlockdevOptionsIscsi_members(v, *obj, &err);
5409 if (err) {
5410 goto out_obj;
5411 }
5412 visit_check_struct(v, &err);
5413out_obj:
5414 visit_end_struct(v, (void **)obj);
5415 if (err && visit_is_input(v)) {
5416 qapi_free_BlockdevOptionsIscsi(*obj);
5417 *obj = NULL;
5418 }
5419out:
5420 error_propagate(errp, err);
5421}
5422
5423void visit_type_RbdAuthMode(Visitor *v, const char *name, RbdAuthMode *obj, Error **errp)
5424{
5425 int value = *obj;
5426 visit_type_enum(v, name, &value, &RbdAuthMode_lookup, errp);
5427 *obj = value;
5428}
5429
5430void visit_type_RbdAuthModeList(Visitor *v, const char *name, RbdAuthModeList **obj, Error **errp)
5431{
5432 Error *err = NULL;
5433 RbdAuthModeList *tail;
5434 size_t size = sizeof(**obj);
5435
5436 visit_start_list(v, name, (GenericList **)obj, size, &err);
5437 if (err) {
5438 goto out;
5439 }
5440
5441 for (tail = *obj; tail;
5442 tail = (RbdAuthModeList *)visit_next_list(v, (GenericList *)tail, size)) {
5443 visit_type_RbdAuthMode(v, NULL, &tail->value, &err);
5444 if (err) {
5445 break;
5446 }
5447 }
5448
5449 if (!err) {
5450 visit_check_list(v, &err);
5451 }
5452 visit_end_list(v, (void **)obj);
5453 if (err && visit_is_input(v)) {
5454 qapi_free_RbdAuthModeList(*obj);
5455 *obj = NULL;
5456 }
5457out:
5458 error_propagate(errp, err);
5459}
5460
5461void visit_type_BlockdevOptionsRbd_members(Visitor *v, BlockdevOptionsRbd *obj, Error **errp)
5462{
5463 Error *err = NULL;
5464
5465 visit_type_str(v, "pool", &obj->pool, &err);
5466 if (err) {
5467 goto out;
5468 }
5469 visit_type_str(v, "image", &obj->image, &err);
5470 if (err) {
5471 goto out;
5472 }
5473 if (visit_optional(v, "conf", &obj->has_conf)) {
5474 visit_type_str(v, "conf", &obj->conf, &err);
5475 if (err) {
5476 goto out;
5477 }
5478 }
5479 if (visit_optional(v, "snapshot", &obj->has_snapshot)) {
5480 visit_type_str(v, "snapshot", &obj->snapshot, &err);
5481 if (err) {
5482 goto out;
5483 }
5484 }
5485 if (visit_optional(v, "user", &obj->has_user)) {
5486 visit_type_str(v, "user", &obj->user, &err);
5487 if (err) {
5488 goto out;
5489 }
5490 }
5491 if (visit_optional(v, "auth-client-required", &obj->has_auth_client_required)) {
5492 visit_type_RbdAuthModeList(v, "auth-client-required", &obj->auth_client_required, &err);
5493 if (err) {
5494 goto out;
5495 }
5496 }
5497 if (visit_optional(v, "key-secret", &obj->has_key_secret)) {
5498 visit_type_str(v, "key-secret", &obj->key_secret, &err);
5499 if (err) {
5500 goto out;
5501 }
5502 }
5503 if (visit_optional(v, "server", &obj->has_server)) {
5504 visit_type_InetSocketAddressBaseList(v, "server", &obj->server, &err);
5505 if (err) {
5506 goto out;
5507 }
5508 }
5509
5510out:
5511 error_propagate(errp, err);
5512}
5513
5514void visit_type_BlockdevOptionsRbd(Visitor *v, const char *name, BlockdevOptionsRbd **obj, Error **errp)
5515{
5516 Error *err = NULL;
5517
5518 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsRbd), &err);
5519 if (err) {
5520 goto out;
5521 }
5522 if (!*obj) {
5523 goto out_obj;
5524 }
5525 visit_type_BlockdevOptionsRbd_members(v, *obj, &err);
5526 if (err) {
5527 goto out_obj;
5528 }
5529 visit_check_struct(v, &err);
5530out_obj:
5531 visit_end_struct(v, (void **)obj);
5532 if (err && visit_is_input(v)) {
5533 qapi_free_BlockdevOptionsRbd(*obj);
5534 *obj = NULL;
5535 }
5536out:
5537 error_propagate(errp, err);
5538}
5539
5540void visit_type_BlockdevOptionsSheepdog_members(Visitor *v, BlockdevOptionsSheepdog *obj, Error **errp)
5541{
5542 Error *err = NULL;
5543
5544 visit_type_SocketAddress(v, "server", &obj->server, &err);
5545 if (err) {
5546 goto out;
5547 }
5548 visit_type_str(v, "vdi", &obj->vdi, &err);
5549 if (err) {
5550 goto out;
5551 }
5552 if (visit_optional(v, "snap-id", &obj->has_snap_id)) {
5553 visit_type_uint32(v, "snap-id", &obj->snap_id, &err);
5554 if (err) {
5555 goto out;
5556 }
5557 }
5558 if (visit_optional(v, "tag", &obj->has_tag)) {
5559 visit_type_str(v, "tag", &obj->tag, &err);
5560 if (err) {
5561 goto out;
5562 }
5563 }
5564
5565out:
5566 error_propagate(errp, err);
5567}
5568
5569void visit_type_BlockdevOptionsSheepdog(Visitor *v, const char *name, BlockdevOptionsSheepdog **obj, Error **errp)
5570{
5571 Error *err = NULL;
5572
5573 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsSheepdog), &err);
5574 if (err) {
5575 goto out;
5576 }
5577 if (!*obj) {
5578 goto out_obj;
5579 }
5580 visit_type_BlockdevOptionsSheepdog_members(v, *obj, &err);
5581 if (err) {
5582 goto out_obj;
5583 }
5584 visit_check_struct(v, &err);
5585out_obj:
5586 visit_end_struct(v, (void **)obj);
5587 if (err && visit_is_input(v)) {
5588 qapi_free_BlockdevOptionsSheepdog(*obj);
5589 *obj = NULL;
5590 }
5591out:
5592 error_propagate(errp, err);
5593}
5594
5595#if defined(CONFIG_REPLICATION)
5596void visit_type_ReplicationMode(Visitor *v, const char *name, ReplicationMode *obj, Error **errp)
5597{
5598 int value = *obj;
5599 visit_type_enum(v, name, &value, &ReplicationMode_lookup, errp);
5600 *obj = value;
5601}
5602#endif /* defined(CONFIG_REPLICATION) */
5603
5604#if defined(CONFIG_REPLICATION)
5605void visit_type_BlockdevOptionsReplication_members(Visitor *v, BlockdevOptionsReplication *obj, Error **errp)
5606{
5607 Error *err = NULL;
5608
5609 visit_type_BlockdevOptionsGenericFormat_members(v, (BlockdevOptionsGenericFormat *)obj, &err);
5610 if (err) {
5611 goto out;
5612 }
5613 visit_type_ReplicationMode(v, "mode", &obj->mode, &err);
5614 if (err) {
5615 goto out;
5616 }
5617 if (visit_optional(v, "top-id", &obj->has_top_id)) {
5618 visit_type_str(v, "top-id", &obj->top_id, &err);
5619 if (err) {
5620 goto out;
5621 }
5622 }
5623
5624out:
5625 error_propagate(errp, err);
5626}
5627
5628void visit_type_BlockdevOptionsReplication(Visitor *v, const char *name, BlockdevOptionsReplication **obj, Error **errp)
5629{
5630 Error *err = NULL;
5631
5632 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsReplication), &err);
5633 if (err) {
5634 goto out;
5635 }
5636 if (!*obj) {
5637 goto out_obj;
5638 }
5639 visit_type_BlockdevOptionsReplication_members(v, *obj, &err);
5640 if (err) {
5641 goto out_obj;
5642 }
5643 visit_check_struct(v, &err);
5644out_obj:
5645 visit_end_struct(v, (void **)obj);
5646 if (err && visit_is_input(v)) {
5647 qapi_free_BlockdevOptionsReplication(*obj);
5648 *obj = NULL;
5649 }
5650out:
5651 error_propagate(errp, err);
5652}
5653#endif /* defined(CONFIG_REPLICATION) */
5654
5655void visit_type_NFSTransport(Visitor *v, const char *name, NFSTransport *obj, Error **errp)
5656{
5657 int value = *obj;
5658 visit_type_enum(v, name, &value, &NFSTransport_lookup, errp);
5659 *obj = value;
5660}
5661
5662void visit_type_NFSServer_members(Visitor *v, NFSServer *obj, Error **errp)
5663{
5664 Error *err = NULL;
5665
5666 visit_type_NFSTransport(v, "type", &obj->type, &err);
5667 if (err) {
5668 goto out;
5669 }
5670 visit_type_str(v, "host", &obj->host, &err);
5671 if (err) {
5672 goto out;
5673 }
5674
5675out:
5676 error_propagate(errp, err);
5677}
5678
5679void visit_type_NFSServer(Visitor *v, const char *name, NFSServer **obj, Error **errp)
5680{
5681 Error *err = NULL;
5682
5683 visit_start_struct(v, name, (void **)obj, sizeof(NFSServer), &err);
5684 if (err) {
5685 goto out;
5686 }
5687 if (!*obj) {
5688 goto out_obj;
5689 }
5690 visit_type_NFSServer_members(v, *obj, &err);
5691 if (err) {
5692 goto out_obj;
5693 }
5694 visit_check_struct(v, &err);
5695out_obj:
5696 visit_end_struct(v, (void **)obj);
5697 if (err && visit_is_input(v)) {
5698 qapi_free_NFSServer(*obj);
5699 *obj = NULL;
5700 }
5701out:
5702 error_propagate(errp, err);
5703}
5704
5705void visit_type_BlockdevOptionsNfs_members(Visitor *v, BlockdevOptionsNfs *obj, Error **errp)
5706{
5707 Error *err = NULL;
5708
5709 visit_type_NFSServer(v, "server", &obj->server, &err);
5710 if (err) {
5711 goto out;
5712 }
5713 visit_type_str(v, "path", &obj->path, &err);
5714 if (err) {
5715 goto out;
5716 }
5717 if (visit_optional(v, "user", &obj->has_user)) {
5718 visit_type_int(v, "user", &obj->user, &err);
5719 if (err) {
5720 goto out;
5721 }
5722 }
5723 if (visit_optional(v, "group", &obj->has_group)) {
5724 visit_type_int(v, "group", &obj->group, &err);
5725 if (err) {
5726 goto out;
5727 }
5728 }
5729 if (visit_optional(v, "tcp-syn-count", &obj->has_tcp_syn_count)) {
5730 visit_type_int(v, "tcp-syn-count", &obj->tcp_syn_count, &err);
5731 if (err) {
5732 goto out;
5733 }
5734 }
5735 if (visit_optional(v, "readahead-size", &obj->has_readahead_size)) {
5736 visit_type_int(v, "readahead-size", &obj->readahead_size, &err);
5737 if (err) {
5738 goto out;
5739 }
5740 }
5741 if (visit_optional(v, "page-cache-size", &obj->has_page_cache_size)) {
5742 visit_type_int(v, "page-cache-size", &obj->page_cache_size, &err);
5743 if (err) {
5744 goto out;
5745 }
5746 }
5747 if (visit_optional(v, "debug", &obj->has_debug)) {
5748 visit_type_int(v, "debug", &obj->debug, &err);
5749 if (err) {
5750 goto out;
5751 }
5752 }
5753
5754out:
5755 error_propagate(errp, err);
5756}
5757
5758void visit_type_BlockdevOptionsNfs(Visitor *v, const char *name, BlockdevOptionsNfs **obj, Error **errp)
5759{
5760 Error *err = NULL;
5761
5762 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsNfs), &err);
5763 if (err) {
5764 goto out;
5765 }
5766 if (!*obj) {
5767 goto out_obj;
5768 }
5769 visit_type_BlockdevOptionsNfs_members(v, *obj, &err);
5770 if (err) {
5771 goto out_obj;
5772 }
5773 visit_check_struct(v, &err);
5774out_obj:
5775 visit_end_struct(v, (void **)obj);
5776 if (err && visit_is_input(v)) {
5777 qapi_free_BlockdevOptionsNfs(*obj);
5778 *obj = NULL;
5779 }
5780out:
5781 error_propagate(errp, err);
5782}
5783
5784void visit_type_BlockdevOptionsCurlBase_members(Visitor *v, BlockdevOptionsCurlBase *obj, Error **errp)
5785{
5786 Error *err = NULL;
5787
5788 visit_type_str(v, "url", &obj->url, &err);
5789 if (err) {
5790 goto out;
5791 }
5792 if (visit_optional(v, "readahead", &obj->has_readahead)) {
5793 visit_type_int(v, "readahead", &obj->readahead, &err);
5794 if (err) {
5795 goto out;
5796 }
5797 }
5798 if (visit_optional(v, "timeout", &obj->has_timeout)) {
5799 visit_type_int(v, "timeout", &obj->timeout, &err);
5800 if (err) {
5801 goto out;
5802 }
5803 }
5804 if (visit_optional(v, "username", &obj->has_username)) {
5805 visit_type_str(v, "username", &obj->username, &err);
5806 if (err) {
5807 goto out;
5808 }
5809 }
5810 if (visit_optional(v, "password-secret", &obj->has_password_secret)) {
5811 visit_type_str(v, "password-secret", &obj->password_secret, &err);
5812 if (err) {
5813 goto out;
5814 }
5815 }
5816 if (visit_optional(v, "proxy-username", &obj->has_proxy_username)) {
5817 visit_type_str(v, "proxy-username", &obj->proxy_username, &err);
5818 if (err) {
5819 goto out;
5820 }
5821 }
5822 if (visit_optional(v, "proxy-password-secret", &obj->has_proxy_password_secret)) {
5823 visit_type_str(v, "proxy-password-secret", &obj->proxy_password_secret, &err);
5824 if (err) {
5825 goto out;
5826 }
5827 }
5828
5829out:
5830 error_propagate(errp, err);
5831}
5832
5833void visit_type_BlockdevOptionsCurlBase(Visitor *v, const char *name, BlockdevOptionsCurlBase **obj, Error **errp)
5834{
5835 Error *err = NULL;
5836
5837 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsCurlBase), &err);
5838 if (err) {
5839 goto out;
5840 }
5841 if (!*obj) {
5842 goto out_obj;
5843 }
5844 visit_type_BlockdevOptionsCurlBase_members(v, *obj, &err);
5845 if (err) {
5846 goto out_obj;
5847 }
5848 visit_check_struct(v, &err);
5849out_obj:
5850 visit_end_struct(v, (void **)obj);
5851 if (err && visit_is_input(v)) {
5852 qapi_free_BlockdevOptionsCurlBase(*obj);
5853 *obj = NULL;
5854 }
5855out:
5856 error_propagate(errp, err);
5857}
5858
5859void visit_type_BlockdevOptionsCurlHttp_members(Visitor *v, BlockdevOptionsCurlHttp *obj, Error **errp)
5860{
5861 Error *err = NULL;
5862
5863 visit_type_BlockdevOptionsCurlBase_members(v, (BlockdevOptionsCurlBase *)obj, &err);
5864 if (err) {
5865 goto out;
5866 }
5867 if (visit_optional(v, "cookie", &obj->has_cookie)) {
5868 visit_type_str(v, "cookie", &obj->cookie, &err);
5869 if (err) {
5870 goto out;
5871 }
5872 }
5873 if (visit_optional(v, "cookie-secret", &obj->has_cookie_secret)) {
5874 visit_type_str(v, "cookie-secret", &obj->cookie_secret, &err);
5875 if (err) {
5876 goto out;
5877 }
5878 }
5879
5880out:
5881 error_propagate(errp, err);
5882}
5883
5884void visit_type_BlockdevOptionsCurlHttp(Visitor *v, const char *name, BlockdevOptionsCurlHttp **obj, Error **errp)
5885{
5886 Error *err = NULL;
5887
5888 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsCurlHttp), &err);
5889 if (err) {
5890 goto out;
5891 }
5892 if (!*obj) {
5893 goto out_obj;
5894 }
5895 visit_type_BlockdevOptionsCurlHttp_members(v, *obj, &err);
5896 if (err) {
5897 goto out_obj;
5898 }
5899 visit_check_struct(v, &err);
5900out_obj:
5901 visit_end_struct(v, (void **)obj);
5902 if (err && visit_is_input(v)) {
5903 qapi_free_BlockdevOptionsCurlHttp(*obj);
5904 *obj = NULL;
5905 }
5906out:
5907 error_propagate(errp, err);
5908}
5909
5910void visit_type_BlockdevOptionsCurlHttps_members(Visitor *v, BlockdevOptionsCurlHttps *obj, Error **errp)
5911{
5912 Error *err = NULL;
5913
5914 visit_type_BlockdevOptionsCurlBase_members(v, (BlockdevOptionsCurlBase *)obj, &err);
5915 if (err) {
5916 goto out;
5917 }
5918 if (visit_optional(v, "cookie", &obj->has_cookie)) {
5919 visit_type_str(v, "cookie", &obj->cookie, &err);
5920 if (err) {
5921 goto out;
5922 }
5923 }
5924 if (visit_optional(v, "sslverify", &obj->has_sslverify)) {
5925 visit_type_bool(v, "sslverify", &obj->sslverify, &err);
5926 if (err) {
5927 goto out;
5928 }
5929 }
5930 if (visit_optional(v, "cookie-secret", &obj->has_cookie_secret)) {
5931 visit_type_str(v, "cookie-secret", &obj->cookie_secret, &err);
5932 if (err) {
5933 goto out;
5934 }
5935 }
5936
5937out:
5938 error_propagate(errp, err);
5939}
5940
5941void visit_type_BlockdevOptionsCurlHttps(Visitor *v, const char *name, BlockdevOptionsCurlHttps **obj, Error **errp)
5942{
5943 Error *err = NULL;
5944
5945 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsCurlHttps), &err);
5946 if (err) {
5947 goto out;
5948 }
5949 if (!*obj) {
5950 goto out_obj;
5951 }
5952 visit_type_BlockdevOptionsCurlHttps_members(v, *obj, &err);
5953 if (err) {
5954 goto out_obj;
5955 }
5956 visit_check_struct(v, &err);
5957out_obj:
5958 visit_end_struct(v, (void **)obj);
5959 if (err && visit_is_input(v)) {
5960 qapi_free_BlockdevOptionsCurlHttps(*obj);
5961 *obj = NULL;
5962 }
5963out:
5964 error_propagate(errp, err);
5965}
5966
5967void visit_type_BlockdevOptionsCurlFtp_members(Visitor *v, BlockdevOptionsCurlFtp *obj, Error **errp)
5968{
5969 Error *err = NULL;
5970
5971 visit_type_BlockdevOptionsCurlBase_members(v, (BlockdevOptionsCurlBase *)obj, &err);
5972 if (err) {
5973 goto out;
5974 }
5975
5976out:
5977 error_propagate(errp, err);
5978}
5979
5980void visit_type_BlockdevOptionsCurlFtp(Visitor *v, const char *name, BlockdevOptionsCurlFtp **obj, Error **errp)
5981{
5982 Error *err = NULL;
5983
5984 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsCurlFtp), &err);
5985 if (err) {
5986 goto out;
5987 }
5988 if (!*obj) {
5989 goto out_obj;
5990 }
5991 visit_type_BlockdevOptionsCurlFtp_members(v, *obj, &err);
5992 if (err) {
5993 goto out_obj;
5994 }
5995 visit_check_struct(v, &err);
5996out_obj:
5997 visit_end_struct(v, (void **)obj);
5998 if (err && visit_is_input(v)) {
5999 qapi_free_BlockdevOptionsCurlFtp(*obj);
6000 *obj = NULL;
6001 }
6002out:
6003 error_propagate(errp, err);
6004}
6005
6006void visit_type_BlockdevOptionsCurlFtps_members(Visitor *v, BlockdevOptionsCurlFtps *obj, Error **errp)
6007{
6008 Error *err = NULL;
6009
6010 visit_type_BlockdevOptionsCurlBase_members(v, (BlockdevOptionsCurlBase *)obj, &err);
6011 if (err) {
6012 goto out;
6013 }
6014 if (visit_optional(v, "sslverify", &obj->has_sslverify)) {
6015 visit_type_bool(v, "sslverify", &obj->sslverify, &err);
6016 if (err) {
6017 goto out;
6018 }
6019 }
6020
6021out:
6022 error_propagate(errp, err);
6023}
6024
6025void visit_type_BlockdevOptionsCurlFtps(Visitor *v, const char *name, BlockdevOptionsCurlFtps **obj, Error **errp)
6026{
6027 Error *err = NULL;
6028
6029 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsCurlFtps), &err);
6030 if (err) {
6031 goto out;
6032 }
6033 if (!*obj) {
6034 goto out_obj;
6035 }
6036 visit_type_BlockdevOptionsCurlFtps_members(v, *obj, &err);
6037 if (err) {
6038 goto out_obj;
6039 }
6040 visit_check_struct(v, &err);
6041out_obj:
6042 visit_end_struct(v, (void **)obj);
6043 if (err && visit_is_input(v)) {
6044 qapi_free_BlockdevOptionsCurlFtps(*obj);
6045 *obj = NULL;
6046 }
6047out:
6048 error_propagate(errp, err);
6049}
6050
6051void visit_type_BlockdevOptionsNbd_members(Visitor *v, BlockdevOptionsNbd *obj, Error **errp)
6052{
6053 Error *err = NULL;
6054
6055 visit_type_SocketAddress(v, "server", &obj->server, &err);
6056 if (err) {
6057 goto out;
6058 }
6059 if (visit_optional(v, "export", &obj->has_export)) {
6060 visit_type_str(v, "export", &obj->export, &err);
6061 if (err) {
6062 goto out;
6063 }
6064 }
6065 if (visit_optional(v, "tls-creds", &obj->has_tls_creds)) {
6066 visit_type_str(v, "tls-creds", &obj->tls_creds, &err);
6067 if (err) {
6068 goto out;
6069 }
6070 }
6071 if (visit_optional(v, "x-dirty-bitmap", &obj->has_x_dirty_bitmap)) {
6072 visit_type_str(v, "x-dirty-bitmap", &obj->x_dirty_bitmap, &err);
6073 if (err) {
6074 goto out;
6075 }
6076 }
6077 if (visit_optional(v, "reconnect-delay", &obj->has_reconnect_delay)) {
6078 visit_type_uint32(v, "reconnect-delay", &obj->reconnect_delay, &err);
6079 if (err) {
6080 goto out;
6081 }
6082 }
6083
6084out:
6085 error_propagate(errp, err);
6086}
6087
6088void visit_type_BlockdevOptionsNbd(Visitor *v, const char *name, BlockdevOptionsNbd **obj, Error **errp)
6089{
6090 Error *err = NULL;
6091
6092 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsNbd), &err);
6093 if (err) {
6094 goto out;
6095 }
6096 if (!*obj) {
6097 goto out_obj;
6098 }
6099 visit_type_BlockdevOptionsNbd_members(v, *obj, &err);
6100 if (err) {
6101 goto out_obj;
6102 }
6103 visit_check_struct(v, &err);
6104out_obj:
6105 visit_end_struct(v, (void **)obj);
6106 if (err && visit_is_input(v)) {
6107 qapi_free_BlockdevOptionsNbd(*obj);
6108 *obj = NULL;
6109 }
6110out:
6111 error_propagate(errp, err);
6112}
6113
6114void visit_type_BlockdevOptionsRaw_members(Visitor *v, BlockdevOptionsRaw *obj, Error **errp)
6115{
6116 Error *err = NULL;
6117
6118 visit_type_BlockdevOptionsGenericFormat_members(v, (BlockdevOptionsGenericFormat *)obj, &err);
6119 if (err) {
6120 goto out;
6121 }
6122 if (visit_optional(v, "offset", &obj->has_offset)) {
6123 visit_type_int(v, "offset", &obj->offset, &err);
6124 if (err) {
6125 goto out;
6126 }
6127 }
6128 if (visit_optional(v, "size", &obj->has_size)) {
6129 visit_type_int(v, "size", &obj->size, &err);
6130 if (err) {
6131 goto out;
6132 }
6133 }
6134
6135out:
6136 error_propagate(errp, err);
6137}
6138
6139void visit_type_BlockdevOptionsRaw(Visitor *v, const char *name, BlockdevOptionsRaw **obj, Error **errp)
6140{
6141 Error *err = NULL;
6142
6143 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsRaw), &err);
6144 if (err) {
6145 goto out;
6146 }
6147 if (!*obj) {
6148 goto out_obj;
6149 }
6150 visit_type_BlockdevOptionsRaw_members(v, *obj, &err);
6151 if (err) {
6152 goto out_obj;
6153 }
6154 visit_check_struct(v, &err);
6155out_obj:
6156 visit_end_struct(v, (void **)obj);
6157 if (err && visit_is_input(v)) {
6158 qapi_free_BlockdevOptionsRaw(*obj);
6159 *obj = NULL;
6160 }
6161out:
6162 error_propagate(errp, err);
6163}
6164
6165void visit_type_BlockdevOptionsVxHS_members(Visitor *v, BlockdevOptionsVxHS *obj, Error **errp)
6166{
6167 Error *err = NULL;
6168
6169 visit_type_str(v, "vdisk-id", &obj->vdisk_id, &err);
6170 if (err) {
6171 goto out;
6172 }
6173 visit_type_InetSocketAddressBase(v, "server", &obj->server, &err);
6174 if (err) {
6175 goto out;
6176 }
6177 if (visit_optional(v, "tls-creds", &obj->has_tls_creds)) {
6178 visit_type_str(v, "tls-creds", &obj->tls_creds, &err);
6179 if (err) {
6180 goto out;
6181 }
6182 }
6183
6184out:
6185 error_propagate(errp, err);
6186}
6187
6188void visit_type_BlockdevOptionsVxHS(Visitor *v, const char *name, BlockdevOptionsVxHS **obj, Error **errp)
6189{
6190 Error *err = NULL;
6191
6192 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsVxHS), &err);
6193 if (err) {
6194 goto out;
6195 }
6196 if (!*obj) {
6197 goto out_obj;
6198 }
6199 visit_type_BlockdevOptionsVxHS_members(v, *obj, &err);
6200 if (err) {
6201 goto out_obj;
6202 }
6203 visit_check_struct(v, &err);
6204out_obj:
6205 visit_end_struct(v, (void **)obj);
6206 if (err && visit_is_input(v)) {
6207 qapi_free_BlockdevOptionsVxHS(*obj);
6208 *obj = NULL;
6209 }
6210out:
6211 error_propagate(errp, err);
6212}
6213
6214void visit_type_BlockdevOptionsThrottle_members(Visitor *v, BlockdevOptionsThrottle *obj, Error **errp)
6215{
6216 Error *err = NULL;
6217
6218 visit_type_str(v, "throttle-group", &obj->throttle_group, &err);
6219 if (err) {
6220 goto out;
6221 }
6222 visit_type_BlockdevRef(v, "file", &obj->file, &err);
6223 if (err) {
6224 goto out;
6225 }
6226
6227out:
6228 error_propagate(errp, err);
6229}
6230
6231void visit_type_BlockdevOptionsThrottle(Visitor *v, const char *name, BlockdevOptionsThrottle **obj, Error **errp)
6232{
6233 Error *err = NULL;
6234
6235 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptionsThrottle), &err);
6236 if (err) {
6237 goto out;
6238 }
6239 if (!*obj) {
6240 goto out_obj;
6241 }
6242 visit_type_BlockdevOptionsThrottle_members(v, *obj, &err);
6243 if (err) {
6244 goto out_obj;
6245 }
6246 visit_check_struct(v, &err);
6247out_obj:
6248 visit_end_struct(v, (void **)obj);
6249 if (err && visit_is_input(v)) {
6250 qapi_free_BlockdevOptionsThrottle(*obj);
6251 *obj = NULL;
6252 }
6253out:
6254 error_propagate(errp, err);
6255}
6256
6257void visit_type_q_obj_BlockdevOptions_base_members(Visitor *v, q_obj_BlockdevOptions_base *obj, Error **errp)
6258{
6259 Error *err = NULL;
6260
6261 visit_type_BlockdevDriver(v, "driver", &obj->driver, &err);
6262 if (err) {
6263 goto out;
6264 }
6265 if (visit_optional(v, "node-name", &obj->has_node_name)) {
6266 visit_type_str(v, "node-name", &obj->node_name, &err);
6267 if (err) {
6268 goto out;
6269 }
6270 }
6271 if (visit_optional(v, "discard", &obj->has_discard)) {
6272 visit_type_BlockdevDiscardOptions(v, "discard", &obj->discard, &err);
6273 if (err) {
6274 goto out;
6275 }
6276 }
6277 if (visit_optional(v, "cache", &obj->has_cache)) {
6278 visit_type_BlockdevCacheOptions(v, "cache", &obj->cache, &err);
6279 if (err) {
6280 goto out;
6281 }
6282 }
6283 if (visit_optional(v, "read-only", &obj->has_read_only)) {
6284 visit_type_bool(v, "read-only", &obj->read_only, &err);
6285 if (err) {
6286 goto out;
6287 }
6288 }
6289 if (visit_optional(v, "auto-read-only", &obj->has_auto_read_only)) {
6290 visit_type_bool(v, "auto-read-only", &obj->auto_read_only, &err);
6291 if (err) {
6292 goto out;
6293 }
6294 }
6295 if (visit_optional(v, "force-share", &obj->has_force_share)) {
6296 visit_type_bool(v, "force-share", &obj->force_share, &err);
6297 if (err) {
6298 goto out;
6299 }
6300 }
6301 if (visit_optional(v, "detect-zeroes", &obj->has_detect_zeroes)) {
6302 visit_type_BlockdevDetectZeroesOptions(v, "detect-zeroes", &obj->detect_zeroes, &err);
6303 if (err) {
6304 goto out;
6305 }
6306 }
6307
6308out:
6309 error_propagate(errp, err);
6310}
6311
6312void visit_type_BlockdevOptions_members(Visitor *v, BlockdevOptions *obj, Error **errp)
6313{
6314 Error *err = NULL;
6315
6316 visit_type_q_obj_BlockdevOptions_base_members(v, (q_obj_BlockdevOptions_base *)obj, &err);
6317 if (err) {
6318 goto out;
6319 }
6320 switch (obj->driver) {
6321 case BLOCKDEV_DRIVER_BLKDEBUG:
6322 visit_type_BlockdevOptionsBlkdebug_members(v, &obj->u.blkdebug, &err);
6323 break;
6324 case BLOCKDEV_DRIVER_BLKLOGWRITES:
6325 visit_type_BlockdevOptionsBlklogwrites_members(v, &obj->u.blklogwrites, &err);
6326 break;
6327 case BLOCKDEV_DRIVER_BLKVERIFY:
6328 visit_type_BlockdevOptionsBlkverify_members(v, &obj->u.blkverify, &err);
6329 break;
6330 case BLOCKDEV_DRIVER_BOCHS:
6331 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.bochs, &err);
6332 break;
6333 case BLOCKDEV_DRIVER_CLOOP:
6334 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.cloop, &err);
6335 break;
6336 case BLOCKDEV_DRIVER_COPY_ON_READ:
6337 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.copy_on_read, &err);
6338 break;
6339 case BLOCKDEV_DRIVER_DMG:
6340 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.dmg, &err);
6341 break;
6342 case BLOCKDEV_DRIVER_FILE:
6343 visit_type_BlockdevOptionsFile_members(v, &obj->u.file, &err);
6344 break;
6345 case BLOCKDEV_DRIVER_FTP:
6346 visit_type_BlockdevOptionsCurlFtp_members(v, &obj->u.ftp, &err);
6347 break;
6348 case BLOCKDEV_DRIVER_FTPS:
6349 visit_type_BlockdevOptionsCurlFtps_members(v, &obj->u.ftps, &err);
6350 break;
6351 case BLOCKDEV_DRIVER_GLUSTER:
6352 visit_type_BlockdevOptionsGluster_members(v, &obj->u.gluster, &err);
6353 break;
6354 case BLOCKDEV_DRIVER_HOST_CDROM:
6355 visit_type_BlockdevOptionsFile_members(v, &obj->u.host_cdrom, &err);
6356 break;
6357 case BLOCKDEV_DRIVER_HOST_DEVICE:
6358 visit_type_BlockdevOptionsFile_members(v, &obj->u.host_device, &err);
6359 break;
6360 case BLOCKDEV_DRIVER_HTTP:
6361 visit_type_BlockdevOptionsCurlHttp_members(v, &obj->u.http, &err);
6362 break;
6363 case BLOCKDEV_DRIVER_HTTPS:
6364 visit_type_BlockdevOptionsCurlHttps_members(v, &obj->u.https, &err);
6365 break;
6366 case BLOCKDEV_DRIVER_ISCSI:
6367 visit_type_BlockdevOptionsIscsi_members(v, &obj->u.iscsi, &err);
6368 break;
6369 case BLOCKDEV_DRIVER_LUKS:
6370 visit_type_BlockdevOptionsLUKS_members(v, &obj->u.luks, &err);
6371 break;
6372 case BLOCKDEV_DRIVER_NBD:
6373 visit_type_BlockdevOptionsNbd_members(v, &obj->u.nbd, &err);
6374 break;
6375 case BLOCKDEV_DRIVER_NFS:
6376 visit_type_BlockdevOptionsNfs_members(v, &obj->u.nfs, &err);
6377 break;
6378 case BLOCKDEV_DRIVER_NULL_AIO:
6379 visit_type_BlockdevOptionsNull_members(v, &obj->u.null_aio, &err);
6380 break;
6381 case BLOCKDEV_DRIVER_NULL_CO:
6382 visit_type_BlockdevOptionsNull_members(v, &obj->u.null_co, &err);
6383 break;
6384 case BLOCKDEV_DRIVER_NVME:
6385 visit_type_BlockdevOptionsNVMe_members(v, &obj->u.nvme, &err);
6386 break;
6387 case BLOCKDEV_DRIVER_PARALLELS:
6388 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.parallels, &err);
6389 break;
6390 case BLOCKDEV_DRIVER_QCOW2:
6391 visit_type_BlockdevOptionsQcow2_members(v, &obj->u.qcow2, &err);
6392 break;
6393 case BLOCKDEV_DRIVER_QCOW:
6394 visit_type_BlockdevOptionsQcow_members(v, &obj->u.qcow, &err);
6395 break;
6396 case BLOCKDEV_DRIVER_QED:
6397 visit_type_BlockdevOptionsGenericCOWFormat_members(v, &obj->u.qed, &err);
6398 break;
6399 case BLOCKDEV_DRIVER_QUORUM:
6400 visit_type_BlockdevOptionsQuorum_members(v, &obj->u.quorum, &err);
6401 break;
6402 case BLOCKDEV_DRIVER_RAW:
6403 visit_type_BlockdevOptionsRaw_members(v, &obj->u.raw, &err);
6404 break;
6405 case BLOCKDEV_DRIVER_RBD:
6406 visit_type_BlockdevOptionsRbd_members(v, &obj->u.rbd, &err);
6407 break;
6408#if defined(CONFIG_REPLICATION)
6409 case BLOCKDEV_DRIVER_REPLICATION:
6410 visit_type_BlockdevOptionsReplication_members(v, &obj->u.replication, &err);
6411 break;
6412#endif /* defined(CONFIG_REPLICATION) */
6413 case BLOCKDEV_DRIVER_SHEEPDOG:
6414 visit_type_BlockdevOptionsSheepdog_members(v, &obj->u.sheepdog, &err);
6415 break;
6416 case BLOCKDEV_DRIVER_SSH:
6417 visit_type_BlockdevOptionsSsh_members(v, &obj->u.ssh, &err);
6418 break;
6419 case BLOCKDEV_DRIVER_THROTTLE:
6420 visit_type_BlockdevOptionsThrottle_members(v, &obj->u.throttle, &err);
6421 break;
6422 case BLOCKDEV_DRIVER_VDI:
6423 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.vdi, &err);
6424 break;
6425 case BLOCKDEV_DRIVER_VHDX:
6426 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.vhdx, &err);
6427 break;
6428 case BLOCKDEV_DRIVER_VMDK:
6429 visit_type_BlockdevOptionsGenericCOWFormat_members(v, &obj->u.vmdk, &err);
6430 break;
6431 case BLOCKDEV_DRIVER_VPC:
6432 visit_type_BlockdevOptionsGenericFormat_members(v, &obj->u.vpc, &err);
6433 break;
6434 case BLOCKDEV_DRIVER_VVFAT:
6435 visit_type_BlockdevOptionsVVFAT_members(v, &obj->u.vvfat, &err);
6436 break;
6437 case BLOCKDEV_DRIVER_VXHS:
6438 visit_type_BlockdevOptionsVxHS_members(v, &obj->u.vxhs, &err);
6439 break;
6440 default:
6441 abort();
6442 }
6443
6444out:
6445 error_propagate(errp, err);
6446}
6447
6448void visit_type_BlockdevOptions(Visitor *v, const char *name, BlockdevOptions **obj, Error **errp)
6449{
6450 Error *err = NULL;
6451
6452 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevOptions), &err);
6453 if (err) {
6454 goto out;
6455 }
6456 if (!*obj) {
6457 goto out_obj;
6458 }
6459 visit_type_BlockdevOptions_members(v, *obj, &err);
6460 if (err) {
6461 goto out_obj;
6462 }
6463 visit_check_struct(v, &err);
6464out_obj:
6465 visit_end_struct(v, (void **)obj);
6466 if (err && visit_is_input(v)) {
6467 qapi_free_BlockdevOptions(*obj);
6468 *obj = NULL;
6469 }
6470out:
6471 error_propagate(errp, err);
6472}
6473
6474void visit_type_BlockdevRef(Visitor *v, const char *name, BlockdevRef **obj, Error **errp)
6475{
6476 Error *err = NULL;
6477
6478 visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
6479 &err);
6480 if (err) {
6481 goto out;
6482 }
6483 if (!*obj) {
6484 goto out_obj;
6485 }
6486 switch ((*obj)->type) {
6487 case QTYPE_QDICT:
6488 visit_start_struct(v, name, NULL, 0, &err);
6489 if (err) {
6490 break;
6491 }
6492 visit_type_BlockdevOptions_members(v, &(*obj)->u.definition, &err);
6493 if (!err) {
6494 visit_check_struct(v, &err);
6495 }
6496 visit_end_struct(v, NULL);
6497 break;
6498 case QTYPE_QSTRING:
6499 visit_type_str(v, name, &(*obj)->u.reference, &err);
6500 break;
6501 case QTYPE_NONE:
6502 abort();
6503 default:
6504 error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
6505 "BlockdevRef");
6506 }
6507out_obj:
6508 visit_end_alternate(v, (void **)obj);
6509 if (err && visit_is_input(v)) {
6510 qapi_free_BlockdevRef(*obj);
6511 *obj = NULL;
6512 }
6513out:
6514 error_propagate(errp, err);
6515}
6516
6517void visit_type_BlockdevRefOrNull(Visitor *v, const char *name, BlockdevRefOrNull **obj, Error **errp)
6518{
6519 Error *err = NULL;
6520
6521 visit_start_alternate(v, name, (GenericAlternate **)obj, sizeof(**obj),
6522 &err);
6523 if (err) {
6524 goto out;
6525 }
6526 if (!*obj) {
6527 goto out_obj;
6528 }
6529 switch ((*obj)->type) {
6530 case QTYPE_QDICT:
6531 visit_start_struct(v, name, NULL, 0, &err);
6532 if (err) {
6533 break;
6534 }
6535 visit_type_BlockdevOptions_members(v, &(*obj)->u.definition, &err);
6536 if (!err) {
6537 visit_check_struct(v, &err);
6538 }
6539 visit_end_struct(v, NULL);
6540 break;
6541 case QTYPE_QSTRING:
6542 visit_type_str(v, name, &(*obj)->u.reference, &err);
6543 break;
6544 case QTYPE_QNULL:
6545 visit_type_null(v, name, &(*obj)->u.null, &err);
6546 break;
6547 case QTYPE_NONE:
6548 abort();
6549 default:
6550 error_setg(&err, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
6551 "BlockdevRefOrNull");
6552 }
6553out_obj:
6554 visit_end_alternate(v, (void **)obj);
6555 if (err && visit_is_input(v)) {
6556 qapi_free_BlockdevRefOrNull(*obj);
6557 *obj = NULL;
6558 }
6559out:
6560 error_propagate(errp, err);
6561}
6562
6563void visit_type_q_obj_blockdev_del_arg_members(Visitor *v, q_obj_blockdev_del_arg *obj, Error **errp)
6564{
6565 Error *err = NULL;
6566
6567 visit_type_str(v, "node-name", &obj->node_name, &err);
6568 if (err) {
6569 goto out;
6570 }
6571
6572out:
6573 error_propagate(errp, err);
6574}
6575
6576void visit_type_BlockdevCreateOptionsFile_members(Visitor *v, BlockdevCreateOptionsFile *obj, Error **errp)
6577{
6578 Error *err = NULL;
6579
6580 visit_type_str(v, "filename", &obj->filename, &err);
6581 if (err) {
6582 goto out;
6583 }
6584 visit_type_size(v, "size", &obj->size, &err);
6585 if (err) {
6586 goto out;
6587 }
6588 if (visit_optional(v, "preallocation", &obj->has_preallocation)) {
6589 visit_type_PreallocMode(v, "preallocation", &obj->preallocation, &err);
6590 if (err) {
6591 goto out;
6592 }
6593 }
6594 if (visit_optional(v, "nocow", &obj->has_nocow)) {
6595 visit_type_bool(v, "nocow", &obj->nocow, &err);
6596 if (err) {
6597 goto out;
6598 }
6599 }
6600
6601out:
6602 error_propagate(errp, err);
6603}
6604
6605void visit_type_BlockdevCreateOptionsFile(Visitor *v, const char *name, BlockdevCreateOptionsFile **obj, Error **errp)
6606{
6607 Error *err = NULL;
6608
6609 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsFile), &err);
6610 if (err) {
6611 goto out;
6612 }
6613 if (!*obj) {
6614 goto out_obj;
6615 }
6616 visit_type_BlockdevCreateOptionsFile_members(v, *obj, &err);
6617 if (err) {
6618 goto out_obj;
6619 }
6620 visit_check_struct(v, &err);
6621out_obj:
6622 visit_end_struct(v, (void **)obj);
6623 if (err && visit_is_input(v)) {
6624 qapi_free_BlockdevCreateOptionsFile(*obj);
6625 *obj = NULL;
6626 }
6627out:
6628 error_propagate(errp, err);
6629}
6630
6631void visit_type_BlockdevCreateOptionsGluster_members(Visitor *v, BlockdevCreateOptionsGluster *obj, Error **errp)
6632{
6633 Error *err = NULL;
6634
6635 visit_type_BlockdevOptionsGluster(v, "location", &obj->location, &err);
6636 if (err) {
6637 goto out;
6638 }
6639 visit_type_size(v, "size", &obj->size, &err);
6640 if (err) {
6641 goto out;
6642 }
6643 if (visit_optional(v, "preallocation", &obj->has_preallocation)) {
6644 visit_type_PreallocMode(v, "preallocation", &obj->preallocation, &err);
6645 if (err) {
6646 goto out;
6647 }
6648 }
6649
6650out:
6651 error_propagate(errp, err);
6652}
6653
6654void visit_type_BlockdevCreateOptionsGluster(Visitor *v, const char *name, BlockdevCreateOptionsGluster **obj, Error **errp)
6655{
6656 Error *err = NULL;
6657
6658 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsGluster), &err);
6659 if (err) {
6660 goto out;
6661 }
6662 if (!*obj) {
6663 goto out_obj;
6664 }
6665 visit_type_BlockdevCreateOptionsGluster_members(v, *obj, &err);
6666 if (err) {
6667 goto out_obj;
6668 }
6669 visit_check_struct(v, &err);
6670out_obj:
6671 visit_end_struct(v, (void **)obj);
6672 if (err && visit_is_input(v)) {
6673 qapi_free_BlockdevCreateOptionsGluster(*obj);
6674 *obj = NULL;
6675 }
6676out:
6677 error_propagate(errp, err);
6678}
6679
6680void visit_type_BlockdevCreateOptionsLUKS_members(Visitor *v, BlockdevCreateOptionsLUKS *obj, Error **errp)
6681{
6682 Error *err = NULL;
6683
6684 visit_type_QCryptoBlockCreateOptionsLUKS_members(v, (QCryptoBlockCreateOptionsLUKS *)obj, &err);
6685 if (err) {
6686 goto out;
6687 }
6688 visit_type_BlockdevRef(v, "file", &obj->file, &err);
6689 if (err) {
6690 goto out;
6691 }
6692 visit_type_size(v, "size", &obj->size, &err);
6693 if (err) {
6694 goto out;
6695 }
6696 if (visit_optional(v, "preallocation", &obj->has_preallocation)) {
6697 visit_type_PreallocMode(v, "preallocation", &obj->preallocation, &err);
6698 if (err) {
6699 goto out;
6700 }
6701 }
6702
6703out:
6704 error_propagate(errp, err);
6705}
6706
6707void visit_type_BlockdevCreateOptionsLUKS(Visitor *v, const char *name, BlockdevCreateOptionsLUKS **obj, Error **errp)
6708{
6709 Error *err = NULL;
6710
6711 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsLUKS), &err);
6712 if (err) {
6713 goto out;
6714 }
6715 if (!*obj) {
6716 goto out_obj;
6717 }
6718 visit_type_BlockdevCreateOptionsLUKS_members(v, *obj, &err);
6719 if (err) {
6720 goto out_obj;
6721 }
6722 visit_check_struct(v, &err);
6723out_obj:
6724 visit_end_struct(v, (void **)obj);
6725 if (err && visit_is_input(v)) {
6726 qapi_free_BlockdevCreateOptionsLUKS(*obj);
6727 *obj = NULL;
6728 }
6729out:
6730 error_propagate(errp, err);
6731}
6732
6733void visit_type_BlockdevCreateOptionsNfs_members(Visitor *v, BlockdevCreateOptionsNfs *obj, Error **errp)
6734{
6735 Error *err = NULL;
6736
6737 visit_type_BlockdevOptionsNfs(v, "location", &obj->location, &err);
6738 if (err) {
6739 goto out;
6740 }
6741 visit_type_size(v, "size", &obj->size, &err);
6742 if (err) {
6743 goto out;
6744 }
6745
6746out:
6747 error_propagate(errp, err);
6748}
6749
6750void visit_type_BlockdevCreateOptionsNfs(Visitor *v, const char *name, BlockdevCreateOptionsNfs **obj, Error **errp)
6751{
6752 Error *err = NULL;
6753
6754 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsNfs), &err);
6755 if (err) {
6756 goto out;
6757 }
6758 if (!*obj) {
6759 goto out_obj;
6760 }
6761 visit_type_BlockdevCreateOptionsNfs_members(v, *obj, &err);
6762 if (err) {
6763 goto out_obj;
6764 }
6765 visit_check_struct(v, &err);
6766out_obj:
6767 visit_end_struct(v, (void **)obj);
6768 if (err && visit_is_input(v)) {
6769 qapi_free_BlockdevCreateOptionsNfs(*obj);
6770 *obj = NULL;
6771 }
6772out:
6773 error_propagate(errp, err);
6774}
6775
6776void visit_type_BlockdevCreateOptionsParallels_members(Visitor *v, BlockdevCreateOptionsParallels *obj, Error **errp)
6777{
6778 Error *err = NULL;
6779
6780 visit_type_BlockdevRef(v, "file", &obj->file, &err);
6781 if (err) {
6782 goto out;
6783 }
6784 visit_type_size(v, "size", &obj->size, &err);
6785 if (err) {
6786 goto out;
6787 }
6788 if (visit_optional(v, "cluster-size", &obj->has_cluster_size)) {
6789 visit_type_size(v, "cluster-size", &obj->cluster_size, &err);
6790 if (err) {
6791 goto out;
6792 }
6793 }
6794
6795out:
6796 error_propagate(errp, err);
6797}
6798
6799void visit_type_BlockdevCreateOptionsParallels(Visitor *v, const char *name, BlockdevCreateOptionsParallels **obj, Error **errp)
6800{
6801 Error *err = NULL;
6802
6803 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsParallels), &err);
6804 if (err) {
6805 goto out;
6806 }
6807 if (!*obj) {
6808 goto out_obj;
6809 }
6810 visit_type_BlockdevCreateOptionsParallels_members(v, *obj, &err);
6811 if (err) {
6812 goto out_obj;
6813 }
6814 visit_check_struct(v, &err);
6815out_obj:
6816 visit_end_struct(v, (void **)obj);
6817 if (err && visit_is_input(v)) {
6818 qapi_free_BlockdevCreateOptionsParallels(*obj);
6819 *obj = NULL;
6820 }
6821out:
6822 error_propagate(errp, err);
6823}
6824
6825void visit_type_BlockdevCreateOptionsQcow_members(Visitor *v, BlockdevCreateOptionsQcow *obj, Error **errp)
6826{
6827 Error *err = NULL;
6828
6829 visit_type_BlockdevRef(v, "file", &obj->file, &err);
6830 if (err) {
6831 goto out;
6832 }
6833 visit_type_size(v, "size", &obj->size, &err);
6834 if (err) {
6835 goto out;
6836 }
6837 if (visit_optional(v, "backing-file", &obj->has_backing_file)) {
6838 visit_type_str(v, "backing-file", &obj->backing_file, &err);
6839 if (err) {
6840 goto out;
6841 }
6842 }
6843 if (visit_optional(v, "encrypt", &obj->has_encrypt)) {
6844 visit_type_QCryptoBlockCreateOptions(v, "encrypt", &obj->encrypt, &err);
6845 if (err) {
6846 goto out;
6847 }
6848 }
6849
6850out:
6851 error_propagate(errp, err);
6852}
6853
6854void visit_type_BlockdevCreateOptionsQcow(Visitor *v, const char *name, BlockdevCreateOptionsQcow **obj, Error **errp)
6855{
6856 Error *err = NULL;
6857
6858 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsQcow), &err);
6859 if (err) {
6860 goto out;
6861 }
6862 if (!*obj) {
6863 goto out_obj;
6864 }
6865 visit_type_BlockdevCreateOptionsQcow_members(v, *obj, &err);
6866 if (err) {
6867 goto out_obj;
6868 }
6869 visit_check_struct(v, &err);
6870out_obj:
6871 visit_end_struct(v, (void **)obj);
6872 if (err && visit_is_input(v)) {
6873 qapi_free_BlockdevCreateOptionsQcow(*obj);
6874 *obj = NULL;
6875 }
6876out:
6877 error_propagate(errp, err);
6878}
6879
6880void visit_type_BlockdevQcow2Version(Visitor *v, const char *name, BlockdevQcow2Version *obj, Error **errp)
6881{
6882 int value = *obj;
6883 visit_type_enum(v, name, &value, &BlockdevQcow2Version_lookup, errp);
6884 *obj = value;
6885}
6886
6887void visit_type_BlockdevCreateOptionsQcow2_members(Visitor *v, BlockdevCreateOptionsQcow2 *obj, Error **errp)
6888{
6889 Error *err = NULL;
6890
6891 visit_type_BlockdevRef(v, "file", &obj->file, &err);
6892 if (err) {
6893 goto out;
6894 }
6895 if (visit_optional(v, "data-file", &obj->has_data_file)) {
6896 visit_type_BlockdevRef(v, "data-file", &obj->data_file, &err);
6897 if (err) {
6898 goto out;
6899 }
6900 }
6901 if (visit_optional(v, "data-file-raw", &obj->has_data_file_raw)) {
6902 visit_type_bool(v, "data-file-raw", &obj->data_file_raw, &err);
6903 if (err) {
6904 goto out;
6905 }
6906 }
6907 visit_type_size(v, "size", &obj->size, &err);
6908 if (err) {
6909 goto out;
6910 }
6911 if (visit_optional(v, "version", &obj->has_version)) {
6912 visit_type_BlockdevQcow2Version(v, "version", &obj->version, &err);
6913 if (err) {
6914 goto out;
6915 }
6916 }
6917 if (visit_optional(v, "backing-file", &obj->has_backing_file)) {
6918 visit_type_str(v, "backing-file", &obj->backing_file, &err);
6919 if (err) {
6920 goto out;
6921 }
6922 }
6923 if (visit_optional(v, "backing-fmt", &obj->has_backing_fmt)) {
6924 visit_type_BlockdevDriver(v, "backing-fmt", &obj->backing_fmt, &err);
6925 if (err) {
6926 goto out;
6927 }
6928 }
6929 if (visit_optional(v, "encrypt", &obj->has_encrypt)) {
6930 visit_type_QCryptoBlockCreateOptions(v, "encrypt", &obj->encrypt, &err);
6931 if (err) {
6932 goto out;
6933 }
6934 }
6935 if (visit_optional(v, "cluster-size", &obj->has_cluster_size)) {
6936 visit_type_size(v, "cluster-size", &obj->cluster_size, &err);
6937 if (err) {
6938 goto out;
6939 }
6940 }
6941 if (visit_optional(v, "preallocation", &obj->has_preallocation)) {
6942 visit_type_PreallocMode(v, "preallocation", &obj->preallocation, &err);
6943 if (err) {
6944 goto out;
6945 }
6946 }
6947 if (visit_optional(v, "lazy-refcounts", &obj->has_lazy_refcounts)) {
6948 visit_type_bool(v, "lazy-refcounts", &obj->lazy_refcounts, &err);
6949 if (err) {
6950 goto out;
6951 }
6952 }
6953 if (visit_optional(v, "refcount-bits", &obj->has_refcount_bits)) {
6954 visit_type_int(v, "refcount-bits", &obj->refcount_bits, &err);
6955 if (err) {
6956 goto out;
6957 }
6958 }
6959
6960out:
6961 error_propagate(errp, err);
6962}
6963
6964void visit_type_BlockdevCreateOptionsQcow2(Visitor *v, const char *name, BlockdevCreateOptionsQcow2 **obj, Error **errp)
6965{
6966 Error *err = NULL;
6967
6968 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsQcow2), &err);
6969 if (err) {
6970 goto out;
6971 }
6972 if (!*obj) {
6973 goto out_obj;
6974 }
6975 visit_type_BlockdevCreateOptionsQcow2_members(v, *obj, &err);
6976 if (err) {
6977 goto out_obj;
6978 }
6979 visit_check_struct(v, &err);
6980out_obj:
6981 visit_end_struct(v, (void **)obj);
6982 if (err && visit_is_input(v)) {
6983 qapi_free_BlockdevCreateOptionsQcow2(*obj);
6984 *obj = NULL;
6985 }
6986out:
6987 error_propagate(errp, err);
6988}
6989
6990void visit_type_BlockdevCreateOptionsQed_members(Visitor *v, BlockdevCreateOptionsQed *obj, Error **errp)
6991{
6992 Error *err = NULL;
6993
6994 visit_type_BlockdevRef(v, "file", &obj->file, &err);
6995 if (err) {
6996 goto out;
6997 }
6998 visit_type_size(v, "size", &obj->size, &err);
6999 if (err) {
7000 goto out;
7001 }
7002 if (visit_optional(v, "backing-file", &obj->has_backing_file)) {
7003 visit_type_str(v, "backing-file", &obj->backing_file, &err);
7004 if (err) {
7005 goto out;
7006 }
7007 }
7008 if (visit_optional(v, "backing-fmt", &obj->has_backing_fmt)) {
7009 visit_type_BlockdevDriver(v, "backing-fmt", &obj->backing_fmt, &err);
7010 if (err) {
7011 goto out;
7012 }
7013 }
7014 if (visit_optional(v, "cluster-size", &obj->has_cluster_size)) {
7015 visit_type_size(v, "cluster-size", &obj->cluster_size, &err);
7016 if (err) {
7017 goto out;
7018 }
7019 }
7020 if (visit_optional(v, "table-size", &obj->has_table_size)) {
7021 visit_type_int(v, "table-size", &obj->table_size, &err);
7022 if (err) {
7023 goto out;
7024 }
7025 }
7026
7027out:
7028 error_propagate(errp, err);
7029}
7030
7031void visit_type_BlockdevCreateOptionsQed(Visitor *v, const char *name, BlockdevCreateOptionsQed **obj, Error **errp)
7032{
7033 Error *err = NULL;
7034
7035 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsQed), &err);
7036 if (err) {
7037 goto out;
7038 }
7039 if (!*obj) {
7040 goto out_obj;
7041 }
7042 visit_type_BlockdevCreateOptionsQed_members(v, *obj, &err);
7043 if (err) {
7044 goto out_obj;
7045 }
7046 visit_check_struct(v, &err);
7047out_obj:
7048 visit_end_struct(v, (void **)obj);
7049 if (err && visit_is_input(v)) {
7050 qapi_free_BlockdevCreateOptionsQed(*obj);
7051 *obj = NULL;
7052 }
7053out:
7054 error_propagate(errp, err);
7055}
7056
7057void visit_type_BlockdevCreateOptionsRbd_members(Visitor *v, BlockdevCreateOptionsRbd *obj, Error **errp)
7058{
7059 Error *err = NULL;
7060
7061 visit_type_BlockdevOptionsRbd(v, "location", &obj->location, &err);
7062 if (err) {
7063 goto out;
7064 }
7065 visit_type_size(v, "size", &obj->size, &err);
7066 if (err) {
7067 goto out;
7068 }
7069 if (visit_optional(v, "cluster-size", &obj->has_cluster_size)) {
7070 visit_type_size(v, "cluster-size", &obj->cluster_size, &err);
7071 if (err) {
7072 goto out;
7073 }
7074 }
7075
7076out:
7077 error_propagate(errp, err);
7078}
7079
7080void visit_type_BlockdevCreateOptionsRbd(Visitor *v, const char *name, BlockdevCreateOptionsRbd **obj, Error **errp)
7081{
7082 Error *err = NULL;
7083
7084 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsRbd), &err);
7085 if (err) {
7086 goto out;
7087 }
7088 if (!*obj) {
7089 goto out_obj;
7090 }
7091 visit_type_BlockdevCreateOptionsRbd_members(v, *obj, &err);
7092 if (err) {
7093 goto out_obj;
7094 }
7095 visit_check_struct(v, &err);
7096out_obj:
7097 visit_end_struct(v, (void **)obj);
7098 if (err && visit_is_input(v)) {
7099 qapi_free_BlockdevCreateOptionsRbd(*obj);
7100 *obj = NULL;
7101 }
7102out:
7103 error_propagate(errp, err);
7104}
7105
7106void visit_type_BlockdevVmdkSubformat(Visitor *v, const char *name, BlockdevVmdkSubformat *obj, Error **errp)
7107{
7108 int value = *obj;
7109 visit_type_enum(v, name, &value, &BlockdevVmdkSubformat_lookup, errp);
7110 *obj = value;
7111}
7112
7113void visit_type_BlockdevVmdkAdapterType(Visitor *v, const char *name, BlockdevVmdkAdapterType *obj, Error **errp)
7114{
7115 int value = *obj;
7116 visit_type_enum(v, name, &value, &BlockdevVmdkAdapterType_lookup, errp);
7117 *obj = value;
7118}
7119
7120void visit_type_BlockdevCreateOptionsVmdk_members(Visitor *v, BlockdevCreateOptionsVmdk *obj, Error **errp)
7121{
7122 Error *err = NULL;
7123
7124 visit_type_BlockdevRef(v, "file", &obj->file, &err);
7125 if (err) {
7126 goto out;
7127 }
7128 visit_type_size(v, "size", &obj->size, &err);
7129 if (err) {
7130 goto out;
7131 }
7132 if (visit_optional(v, "extents", &obj->has_extents)) {
7133 visit_type_BlockdevRefList(v, "extents", &obj->extents, &err);
7134 if (err) {
7135 goto out;
7136 }
7137 }
7138 if (visit_optional(v, "subformat", &obj->has_subformat)) {
7139 visit_type_BlockdevVmdkSubformat(v, "subformat", &obj->subformat, &err);
7140 if (err) {
7141 goto out;
7142 }
7143 }
7144 if (visit_optional(v, "backing-file", &obj->has_backing_file)) {
7145 visit_type_str(v, "backing-file", &obj->backing_file, &err);
7146 if (err) {
7147 goto out;
7148 }
7149 }
7150 if (visit_optional(v, "adapter-type", &obj->has_adapter_type)) {
7151 visit_type_BlockdevVmdkAdapterType(v, "adapter-type", &obj->adapter_type, &err);
7152 if (err) {
7153 goto out;
7154 }
7155 }
7156 if (visit_optional(v, "hwversion", &obj->has_hwversion)) {
7157 visit_type_str(v, "hwversion", &obj->hwversion, &err);
7158 if (err) {
7159 goto out;
7160 }
7161 }
7162 if (visit_optional(v, "zeroed-grain", &obj->has_zeroed_grain)) {
7163 visit_type_bool(v, "zeroed-grain", &obj->zeroed_grain, &err);
7164 if (err) {
7165 goto out;
7166 }
7167 }
7168
7169out:
7170 error_propagate(errp, err);
7171}
7172
7173void visit_type_BlockdevCreateOptionsVmdk(Visitor *v, const char *name, BlockdevCreateOptionsVmdk **obj, Error **errp)
7174{
7175 Error *err = NULL;
7176
7177 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsVmdk), &err);
7178 if (err) {
7179 goto out;
7180 }
7181 if (!*obj) {
7182 goto out_obj;
7183 }
7184 visit_type_BlockdevCreateOptionsVmdk_members(v, *obj, &err);
7185 if (err) {
7186 goto out_obj;
7187 }
7188 visit_check_struct(v, &err);
7189out_obj:
7190 visit_end_struct(v, (void **)obj);
7191 if (err && visit_is_input(v)) {
7192 qapi_free_BlockdevCreateOptionsVmdk(*obj);
7193 *obj = NULL;
7194 }
7195out:
7196 error_propagate(errp, err);
7197}
7198
7199void visit_type_SheepdogRedundancyType(Visitor *v, const char *name, SheepdogRedundancyType *obj, Error **errp)
7200{
7201 int value = *obj;
7202 visit_type_enum(v, name, &value, &SheepdogRedundancyType_lookup, errp);
7203 *obj = value;
7204}
7205
7206void visit_type_SheepdogRedundancyFull_members(Visitor *v, SheepdogRedundancyFull *obj, Error **errp)
7207{
7208 Error *err = NULL;
7209
7210 visit_type_int(v, "copies", &obj->copies, &err);
7211 if (err) {
7212 goto out;
7213 }
7214
7215out:
7216 error_propagate(errp, err);
7217}
7218
7219void visit_type_SheepdogRedundancyFull(Visitor *v, const char *name, SheepdogRedundancyFull **obj, Error **errp)
7220{
7221 Error *err = NULL;
7222
7223 visit_start_struct(v, name, (void **)obj, sizeof(SheepdogRedundancyFull), &err);
7224 if (err) {
7225 goto out;
7226 }
7227 if (!*obj) {
7228 goto out_obj;
7229 }
7230 visit_type_SheepdogRedundancyFull_members(v, *obj, &err);
7231 if (err) {
7232 goto out_obj;
7233 }
7234 visit_check_struct(v, &err);
7235out_obj:
7236 visit_end_struct(v, (void **)obj);
7237 if (err && visit_is_input(v)) {
7238 qapi_free_SheepdogRedundancyFull(*obj);
7239 *obj = NULL;
7240 }
7241out:
7242 error_propagate(errp, err);
7243}
7244
7245void visit_type_SheepdogRedundancyErasureCoded_members(Visitor *v, SheepdogRedundancyErasureCoded *obj, Error **errp)
7246{
7247 Error *err = NULL;
7248
7249 visit_type_int(v, "data-strips", &obj->data_strips, &err);
7250 if (err) {
7251 goto out;
7252 }
7253 visit_type_int(v, "parity-strips", &obj->parity_strips, &err);
7254 if (err) {
7255 goto out;
7256 }
7257
7258out:
7259 error_propagate(errp, err);
7260}
7261
7262void visit_type_SheepdogRedundancyErasureCoded(Visitor *v, const char *name, SheepdogRedundancyErasureCoded **obj, Error **errp)
7263{
7264 Error *err = NULL;
7265
7266 visit_start_struct(v, name, (void **)obj, sizeof(SheepdogRedundancyErasureCoded), &err);
7267 if (err) {
7268 goto out;
7269 }
7270 if (!*obj) {
7271 goto out_obj;
7272 }
7273 visit_type_SheepdogRedundancyErasureCoded_members(v, *obj, &err);
7274 if (err) {
7275 goto out_obj;
7276 }
7277 visit_check_struct(v, &err);
7278out_obj:
7279 visit_end_struct(v, (void **)obj);
7280 if (err && visit_is_input(v)) {
7281 qapi_free_SheepdogRedundancyErasureCoded(*obj);
7282 *obj = NULL;
7283 }
7284out:
7285 error_propagate(errp, err);
7286}
7287
7288void visit_type_q_obj_SheepdogRedundancy_base_members(Visitor *v, q_obj_SheepdogRedundancy_base *obj, Error **errp)
7289{
7290 Error *err = NULL;
7291
7292 visit_type_SheepdogRedundancyType(v, "type", &obj->type, &err);
7293 if (err) {
7294 goto out;
7295 }
7296
7297out:
7298 error_propagate(errp, err);
7299}
7300
7301void visit_type_SheepdogRedundancy_members(Visitor *v, SheepdogRedundancy *obj, Error **errp)
7302{
7303 Error *err = NULL;
7304
7305 visit_type_q_obj_SheepdogRedundancy_base_members(v, (q_obj_SheepdogRedundancy_base *)obj, &err);
7306 if (err) {
7307 goto out;
7308 }
7309 switch (obj->type) {
7310 case SHEEPDOG_REDUNDANCY_TYPE_FULL:
7311 visit_type_SheepdogRedundancyFull_members(v, &obj->u.full, &err);
7312 break;
7313 case SHEEPDOG_REDUNDANCY_TYPE_ERASURE_CODED:
7314 visit_type_SheepdogRedundancyErasureCoded_members(v, &obj->u.erasure_coded, &err);
7315 break;
7316 default:
7317 abort();
7318 }
7319
7320out:
7321 error_propagate(errp, err);
7322}
7323
7324void visit_type_SheepdogRedundancy(Visitor *v, const char *name, SheepdogRedundancy **obj, Error **errp)
7325{
7326 Error *err = NULL;
7327
7328 visit_start_struct(v, name, (void **)obj, sizeof(SheepdogRedundancy), &err);
7329 if (err) {
7330 goto out;
7331 }
7332 if (!*obj) {
7333 goto out_obj;
7334 }
7335 visit_type_SheepdogRedundancy_members(v, *obj, &err);
7336 if (err) {
7337 goto out_obj;
7338 }
7339 visit_check_struct(v, &err);
7340out_obj:
7341 visit_end_struct(v, (void **)obj);
7342 if (err && visit_is_input(v)) {
7343 qapi_free_SheepdogRedundancy(*obj);
7344 *obj = NULL;
7345 }
7346out:
7347 error_propagate(errp, err);
7348}
7349
7350void visit_type_BlockdevCreateOptionsSheepdog_members(Visitor *v, BlockdevCreateOptionsSheepdog *obj, Error **errp)
7351{
7352 Error *err = NULL;
7353
7354 visit_type_BlockdevOptionsSheepdog(v, "location", &obj->location, &err);
7355 if (err) {
7356 goto out;
7357 }
7358 visit_type_size(v, "size", &obj->size, &err);
7359 if (err) {
7360 goto out;
7361 }
7362 if (visit_optional(v, "backing-file", &obj->has_backing_file)) {
7363 visit_type_str(v, "backing-file", &obj->backing_file, &err);
7364 if (err) {
7365 goto out;
7366 }
7367 }
7368 if (visit_optional(v, "preallocation", &obj->has_preallocation)) {
7369 visit_type_PreallocMode(v, "preallocation", &obj->preallocation, &err);
7370 if (err) {
7371 goto out;
7372 }
7373 }
7374 if (visit_optional(v, "redundancy", &obj->has_redundancy)) {
7375 visit_type_SheepdogRedundancy(v, "redundancy", &obj->redundancy, &err);
7376 if (err) {
7377 goto out;
7378 }
7379 }
7380 if (visit_optional(v, "object-size", &obj->has_object_size)) {
7381 visit_type_size(v, "object-size", &obj->object_size, &err);
7382 if (err) {
7383 goto out;
7384 }
7385 }
7386
7387out:
7388 error_propagate(errp, err);
7389}
7390
7391void visit_type_BlockdevCreateOptionsSheepdog(Visitor *v, const char *name, BlockdevCreateOptionsSheepdog **obj, Error **errp)
7392{
7393 Error *err = NULL;
7394
7395 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsSheepdog), &err);
7396 if (err) {
7397 goto out;
7398 }
7399 if (!*obj) {
7400 goto out_obj;
7401 }
7402 visit_type_BlockdevCreateOptionsSheepdog_members(v, *obj, &err);
7403 if (err) {
7404 goto out_obj;
7405 }
7406 visit_check_struct(v, &err);
7407out_obj:
7408 visit_end_struct(v, (void **)obj);
7409 if (err && visit_is_input(v)) {
7410 qapi_free_BlockdevCreateOptionsSheepdog(*obj);
7411 *obj = NULL;
7412 }
7413out:
7414 error_propagate(errp, err);
7415}
7416
7417void visit_type_BlockdevCreateOptionsSsh_members(Visitor *v, BlockdevCreateOptionsSsh *obj, Error **errp)
7418{
7419 Error *err = NULL;
7420
7421 visit_type_BlockdevOptionsSsh(v, "location", &obj->location, &err);
7422 if (err) {
7423 goto out;
7424 }
7425 visit_type_size(v, "size", &obj->size, &err);
7426 if (err) {
7427 goto out;
7428 }
7429
7430out:
7431 error_propagate(errp, err);
7432}
7433
7434void visit_type_BlockdevCreateOptionsSsh(Visitor *v, const char *name, BlockdevCreateOptionsSsh **obj, Error **errp)
7435{
7436 Error *err = NULL;
7437
7438 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsSsh), &err);
7439 if (err) {
7440 goto out;
7441 }
7442 if (!*obj) {
7443 goto out_obj;
7444 }
7445 visit_type_BlockdevCreateOptionsSsh_members(v, *obj, &err);
7446 if (err) {
7447 goto out_obj;
7448 }
7449 visit_check_struct(v, &err);
7450out_obj:
7451 visit_end_struct(v, (void **)obj);
7452 if (err && visit_is_input(v)) {
7453 qapi_free_BlockdevCreateOptionsSsh(*obj);
7454 *obj = NULL;
7455 }
7456out:
7457 error_propagate(errp, err);
7458}
7459
7460void visit_type_BlockdevCreateOptionsVdi_members(Visitor *v, BlockdevCreateOptionsVdi *obj, Error **errp)
7461{
7462 Error *err = NULL;
7463
7464 visit_type_BlockdevRef(v, "file", &obj->file, &err);
7465 if (err) {
7466 goto out;
7467 }
7468 visit_type_size(v, "size", &obj->size, &err);
7469 if (err) {
7470 goto out;
7471 }
7472 if (visit_optional(v, "preallocation", &obj->has_preallocation)) {
7473 visit_type_PreallocMode(v, "preallocation", &obj->preallocation, &err);
7474 if (err) {
7475 goto out;
7476 }
7477 }
7478
7479out:
7480 error_propagate(errp, err);
7481}
7482
7483void visit_type_BlockdevCreateOptionsVdi(Visitor *v, const char *name, BlockdevCreateOptionsVdi **obj, Error **errp)
7484{
7485 Error *err = NULL;
7486
7487 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsVdi), &err);
7488 if (err) {
7489 goto out;
7490 }
7491 if (!*obj) {
7492 goto out_obj;
7493 }
7494 visit_type_BlockdevCreateOptionsVdi_members(v, *obj, &err);
7495 if (err) {
7496 goto out_obj;
7497 }
7498 visit_check_struct(v, &err);
7499out_obj:
7500 visit_end_struct(v, (void **)obj);
7501 if (err && visit_is_input(v)) {
7502 qapi_free_BlockdevCreateOptionsVdi(*obj);
7503 *obj = NULL;
7504 }
7505out:
7506 error_propagate(errp, err);
7507}
7508
7509void visit_type_BlockdevVhdxSubformat(Visitor *v, const char *name, BlockdevVhdxSubformat *obj, Error **errp)
7510{
7511 int value = *obj;
7512 visit_type_enum(v, name, &value, &BlockdevVhdxSubformat_lookup, errp);
7513 *obj = value;
7514}
7515
7516void visit_type_BlockdevCreateOptionsVhdx_members(Visitor *v, BlockdevCreateOptionsVhdx *obj, Error **errp)
7517{
7518 Error *err = NULL;
7519
7520 visit_type_BlockdevRef(v, "file", &obj->file, &err);
7521 if (err) {
7522 goto out;
7523 }
7524 visit_type_size(v, "size", &obj->size, &err);
7525 if (err) {
7526 goto out;
7527 }
7528 if (visit_optional(v, "log-size", &obj->has_log_size)) {
7529 visit_type_size(v, "log-size", &obj->log_size, &err);
7530 if (err) {
7531 goto out;
7532 }
7533 }
7534 if (visit_optional(v, "block-size", &obj->has_block_size)) {
7535 visit_type_size(v, "block-size", &obj->block_size, &err);
7536 if (err) {
7537 goto out;
7538 }
7539 }
7540 if (visit_optional(v, "subformat", &obj->has_subformat)) {
7541 visit_type_BlockdevVhdxSubformat(v, "subformat", &obj->subformat, &err);
7542 if (err) {
7543 goto out;
7544 }
7545 }
7546 if (visit_optional(v, "block-state-zero", &obj->has_block_state_zero)) {
7547 visit_type_bool(v, "block-state-zero", &obj->block_state_zero, &err);
7548 if (err) {
7549 goto out;
7550 }
7551 }
7552
7553out:
7554 error_propagate(errp, err);
7555}
7556
7557void visit_type_BlockdevCreateOptionsVhdx(Visitor *v, const char *name, BlockdevCreateOptionsVhdx **obj, Error **errp)
7558{
7559 Error *err = NULL;
7560
7561 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsVhdx), &err);
7562 if (err) {
7563 goto out;
7564 }
7565 if (!*obj) {
7566 goto out_obj;
7567 }
7568 visit_type_BlockdevCreateOptionsVhdx_members(v, *obj, &err);
7569 if (err) {
7570 goto out_obj;
7571 }
7572 visit_check_struct(v, &err);
7573out_obj:
7574 visit_end_struct(v, (void **)obj);
7575 if (err && visit_is_input(v)) {
7576 qapi_free_BlockdevCreateOptionsVhdx(*obj);
7577 *obj = NULL;
7578 }
7579out:
7580 error_propagate(errp, err);
7581}
7582
7583void visit_type_BlockdevVpcSubformat(Visitor *v, const char *name, BlockdevVpcSubformat *obj, Error **errp)
7584{
7585 int value = *obj;
7586 visit_type_enum(v, name, &value, &BlockdevVpcSubformat_lookup, errp);
7587 *obj = value;
7588}
7589
7590void visit_type_BlockdevCreateOptionsVpc_members(Visitor *v, BlockdevCreateOptionsVpc *obj, Error **errp)
7591{
7592 Error *err = NULL;
7593
7594 visit_type_BlockdevRef(v, "file", &obj->file, &err);
7595 if (err) {
7596 goto out;
7597 }
7598 visit_type_size(v, "size", &obj->size, &err);
7599 if (err) {
7600 goto out;
7601 }
7602 if (visit_optional(v, "subformat", &obj->has_subformat)) {
7603 visit_type_BlockdevVpcSubformat(v, "subformat", &obj->subformat, &err);
7604 if (err) {
7605 goto out;
7606 }
7607 }
7608 if (visit_optional(v, "force-size", &obj->has_force_size)) {
7609 visit_type_bool(v, "force-size", &obj->force_size, &err);
7610 if (err) {
7611 goto out;
7612 }
7613 }
7614
7615out:
7616 error_propagate(errp, err);
7617}
7618
7619void visit_type_BlockdevCreateOptionsVpc(Visitor *v, const char *name, BlockdevCreateOptionsVpc **obj, Error **errp)
7620{
7621 Error *err = NULL;
7622
7623 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptionsVpc), &err);
7624 if (err) {
7625 goto out;
7626 }
7627 if (!*obj) {
7628 goto out_obj;
7629 }
7630 visit_type_BlockdevCreateOptionsVpc_members(v, *obj, &err);
7631 if (err) {
7632 goto out_obj;
7633 }
7634 visit_check_struct(v, &err);
7635out_obj:
7636 visit_end_struct(v, (void **)obj);
7637 if (err && visit_is_input(v)) {
7638 qapi_free_BlockdevCreateOptionsVpc(*obj);
7639 *obj = NULL;
7640 }
7641out:
7642 error_propagate(errp, err);
7643}
7644
7645void visit_type_q_obj_BlockdevCreateOptions_base_members(Visitor *v, q_obj_BlockdevCreateOptions_base *obj, Error **errp)
7646{
7647 Error *err = NULL;
7648
7649 visit_type_BlockdevDriver(v, "driver", &obj->driver, &err);
7650 if (err) {
7651 goto out;
7652 }
7653
7654out:
7655 error_propagate(errp, err);
7656}
7657
7658void visit_type_BlockdevCreateOptions_members(Visitor *v, BlockdevCreateOptions *obj, Error **errp)
7659{
7660 Error *err = NULL;
7661
7662 visit_type_q_obj_BlockdevCreateOptions_base_members(v, (q_obj_BlockdevCreateOptions_base *)obj, &err);
7663 if (err) {
7664 goto out;
7665 }
7666 switch (obj->driver) {
7667 case BLOCKDEV_DRIVER_FILE:
7668 visit_type_BlockdevCreateOptionsFile_members(v, &obj->u.file, &err);
7669 break;
7670 case BLOCKDEV_DRIVER_GLUSTER:
7671 visit_type_BlockdevCreateOptionsGluster_members(v, &obj->u.gluster, &err);
7672 break;
7673 case BLOCKDEV_DRIVER_LUKS:
7674 visit_type_BlockdevCreateOptionsLUKS_members(v, &obj->u.luks, &err);
7675 break;
7676 case BLOCKDEV_DRIVER_NFS:
7677 visit_type_BlockdevCreateOptionsNfs_members(v, &obj->u.nfs, &err);
7678 break;
7679 case BLOCKDEV_DRIVER_PARALLELS:
7680 visit_type_BlockdevCreateOptionsParallels_members(v, &obj->u.parallels, &err);
7681 break;
7682 case BLOCKDEV_DRIVER_QCOW:
7683 visit_type_BlockdevCreateOptionsQcow_members(v, &obj->u.qcow, &err);
7684 break;
7685 case BLOCKDEV_DRIVER_QCOW2:
7686 visit_type_BlockdevCreateOptionsQcow2_members(v, &obj->u.qcow2, &err);
7687 break;
7688 case BLOCKDEV_DRIVER_QED:
7689 visit_type_BlockdevCreateOptionsQed_members(v, &obj->u.qed, &err);
7690 break;
7691 case BLOCKDEV_DRIVER_RBD:
7692 visit_type_BlockdevCreateOptionsRbd_members(v, &obj->u.rbd, &err);
7693 break;
7694 case BLOCKDEV_DRIVER_SHEEPDOG:
7695 visit_type_BlockdevCreateOptionsSheepdog_members(v, &obj->u.sheepdog, &err);
7696 break;
7697 case BLOCKDEV_DRIVER_SSH:
7698 visit_type_BlockdevCreateOptionsSsh_members(v, &obj->u.ssh, &err);
7699 break;
7700 case BLOCKDEV_DRIVER_VDI:
7701 visit_type_BlockdevCreateOptionsVdi_members(v, &obj->u.vdi, &err);
7702 break;
7703 case BLOCKDEV_DRIVER_VHDX:
7704 visit_type_BlockdevCreateOptionsVhdx_members(v, &obj->u.vhdx, &err);
7705 break;
7706 case BLOCKDEV_DRIVER_VMDK:
7707 visit_type_BlockdevCreateOptionsVmdk_members(v, &obj->u.vmdk, &err);
7708 break;
7709 case BLOCKDEV_DRIVER_VPC:
7710 visit_type_BlockdevCreateOptionsVpc_members(v, &obj->u.vpc, &err);
7711 break;
7712 case BLOCKDEV_DRIVER_BLKDEBUG:
7713 break;
7714 case BLOCKDEV_DRIVER_BLKLOGWRITES:
7715 break;
7716 case BLOCKDEV_DRIVER_BLKVERIFY:
7717 break;
7718 case BLOCKDEV_DRIVER_BOCHS:
7719 break;
7720 case BLOCKDEV_DRIVER_CLOOP:
7721 break;
7722 case BLOCKDEV_DRIVER_COPY_ON_READ:
7723 break;
7724 case BLOCKDEV_DRIVER_DMG:
7725 break;
7726 case BLOCKDEV_DRIVER_FTP:
7727 break;
7728 case BLOCKDEV_DRIVER_FTPS:
7729 break;
7730 case BLOCKDEV_DRIVER_HOST_CDROM:
7731 break;
7732 case BLOCKDEV_DRIVER_HOST_DEVICE:
7733 break;
7734 case BLOCKDEV_DRIVER_HTTP:
7735 break;
7736 case BLOCKDEV_DRIVER_HTTPS:
7737 break;
7738 case BLOCKDEV_DRIVER_ISCSI:
7739 break;
7740 case BLOCKDEV_DRIVER_NBD:
7741 break;
7742 case BLOCKDEV_DRIVER_NULL_AIO:
7743 break;
7744 case BLOCKDEV_DRIVER_NULL_CO:
7745 break;
7746 case BLOCKDEV_DRIVER_NVME:
7747 break;
7748 case BLOCKDEV_DRIVER_QUORUM:
7749 break;
7750 case BLOCKDEV_DRIVER_RAW:
7751 break;
7752#if defined(CONFIG_REPLICATION)
7753 case BLOCKDEV_DRIVER_REPLICATION:
7754 break;
7755#endif /* defined(CONFIG_REPLICATION) */
7756 case BLOCKDEV_DRIVER_THROTTLE:
7757 break;
7758 case BLOCKDEV_DRIVER_VVFAT:
7759 break;
7760 case BLOCKDEV_DRIVER_VXHS:
7761 break;
7762 default:
7763 abort();
7764 }
7765
7766out:
7767 error_propagate(errp, err);
7768}
7769
7770void visit_type_BlockdevCreateOptions(Visitor *v, const char *name, BlockdevCreateOptions **obj, Error **errp)
7771{
7772 Error *err = NULL;
7773
7774 visit_start_struct(v, name, (void **)obj, sizeof(BlockdevCreateOptions), &err);
7775 if (err) {
7776 goto out;
7777 }
7778 if (!*obj) {
7779 goto out_obj;
7780 }
7781 visit_type_BlockdevCreateOptions_members(v, *obj, &err);
7782 if (err) {
7783 goto out_obj;
7784 }
7785 visit_check_struct(v, &err);
7786out_obj:
7787 visit_end_struct(v, (void **)obj);
7788 if (err && visit_is_input(v)) {
7789 qapi_free_BlockdevCreateOptions(*obj);
7790 *obj = NULL;
7791 }
7792out:
7793 error_propagate(errp, err);
7794}
7795
7796void visit_type_q_obj_blockdev_create_arg_members(Visitor *v, q_obj_blockdev_create_arg *obj, Error **errp)
7797{
7798 Error *err = NULL;
7799
7800 visit_type_str(v, "job-id", &obj->job_id, &err);
7801 if (err) {
7802 goto out;
7803 }
7804 visit_type_BlockdevCreateOptions(v, "options", &obj->options, &err);
7805 if (err) {
7806 goto out;
7807 }
7808
7809out:
7810 error_propagate(errp, err);
7811}
7812
7813void visit_type_q_obj_blockdev_open_tray_arg_members(Visitor *v, q_obj_blockdev_open_tray_arg *obj, Error **errp)
7814{
7815 Error *err = NULL;
7816
7817 if (visit_optional(v, "device", &obj->has_device)) {
7818 visit_type_str(v, "device", &obj->device, &err);
7819 if (err) {
7820 goto out;
7821 }
7822 }
7823 if (visit_optional(v, "id", &obj->has_id)) {
7824 visit_type_str(v, "id", &obj->id, &err);
7825 if (err) {
7826 goto out;
7827 }
7828 }
7829 if (visit_optional(v, "force", &obj->has_force)) {
7830 visit_type_bool(v, "force", &obj->force, &err);
7831 if (err) {
7832 goto out;
7833 }
7834 }
7835
7836out:
7837 error_propagate(errp, err);
7838}
7839
7840void visit_type_q_obj_blockdev_close_tray_arg_members(Visitor *v, q_obj_blockdev_close_tray_arg *obj, Error **errp)
7841{
7842 Error *err = NULL;
7843
7844 if (visit_optional(v, "device", &obj->has_device)) {
7845 visit_type_str(v, "device", &obj->device, &err);
7846 if (err) {
7847 goto out;
7848 }
7849 }
7850 if (visit_optional(v, "id", &obj->has_id)) {
7851 visit_type_str(v, "id", &obj->id, &err);
7852 if (err) {
7853 goto out;
7854 }
7855 }
7856
7857out:
7858 error_propagate(errp, err);
7859}
7860
7861void visit_type_q_obj_blockdev_remove_medium_arg_members(Visitor *v, q_obj_blockdev_remove_medium_arg *obj, Error **errp)
7862{
7863 Error *err = NULL;
7864
7865 visit_type_str(v, "id", &obj->id, &err);
7866 if (err) {
7867 goto out;
7868 }
7869
7870out:
7871 error_propagate(errp, err);
7872}
7873
7874void visit_type_q_obj_blockdev_insert_medium_arg_members(Visitor *v, q_obj_blockdev_insert_medium_arg *obj, Error **errp)
7875{
7876 Error *err = NULL;
7877
7878 visit_type_str(v, "id", &obj->id, &err);
7879 if (err) {
7880 goto out;
7881 }
7882 visit_type_str(v, "node-name", &obj->node_name, &err);
7883 if (err) {
7884 goto out;
7885 }
7886
7887out:
7888 error_propagate(errp, err);
7889}
7890
7891void visit_type_BlockdevChangeReadOnlyMode(Visitor *v, const char *name, BlockdevChangeReadOnlyMode *obj, Error **errp)
7892{
7893 int value = *obj;
7894 visit_type_enum(v, name, &value, &BlockdevChangeReadOnlyMode_lookup, errp);
7895 *obj = value;
7896}
7897
7898void visit_type_q_obj_blockdev_change_medium_arg_members(Visitor *v, q_obj_blockdev_change_medium_arg *obj, Error **errp)
7899{
7900 Error *err = NULL;
7901
7902 if (visit_optional(v, "device", &obj->has_device)) {
7903 visit_type_str(v, "device", &obj->device, &err);
7904 if (err) {
7905 goto out;
7906 }
7907 }
7908 if (visit_optional(v, "id", &obj->has_id)) {
7909 visit_type_str(v, "id", &obj->id, &err);
7910 if (err) {
7911 goto out;
7912 }
7913 }
7914 visit_type_str(v, "filename", &obj->filename, &err);
7915 if (err) {
7916 goto out;
7917 }
7918 if (visit_optional(v, "format", &obj->has_format)) {
7919 visit_type_str(v, "format", &obj->format, &err);
7920 if (err) {
7921 goto out;
7922 }
7923 }
7924 if (visit_optional(v, "read-only-mode", &obj->has_read_only_mode)) {
7925 visit_type_BlockdevChangeReadOnlyMode(v, "read-only-mode", &obj->read_only_mode, &err);
7926 if (err) {
7927 goto out;
7928 }
7929 }
7930
7931out:
7932 error_propagate(errp, err);
7933}
7934
7935void visit_type_BlockErrorAction(Visitor *v, const char *name, BlockErrorAction *obj, Error **errp)
7936{
7937 int value = *obj;
7938 visit_type_enum(v, name, &value, &BlockErrorAction_lookup, errp);
7939 *obj = value;
7940}
7941
7942void visit_type_q_obj_BLOCK_IMAGE_CORRUPTED_arg_members(Visitor *v, q_obj_BLOCK_IMAGE_CORRUPTED_arg *obj, Error **errp)
7943{
7944 Error *err = NULL;
7945
7946 visit_type_str(v, "device", &obj->device, &err);
7947 if (err) {
7948 goto out;
7949 }
7950 if (visit_optional(v, "node-name", &obj->has_node_name)) {
7951 visit_type_str(v, "node-name", &obj->node_name, &err);
7952 if (err) {
7953 goto out;
7954 }
7955 }
7956 visit_type_str(v, "msg", &obj->msg, &err);
7957 if (err) {
7958 goto out;
7959 }
7960 if (visit_optional(v, "offset", &obj->has_offset)) {
7961 visit_type_int(v, "offset", &obj->offset, &err);
7962 if (err) {
7963 goto out;
7964 }
7965 }
7966 if (visit_optional(v, "size", &obj->has_size)) {
7967 visit_type_int(v, "size", &obj->size, &err);
7968 if (err) {
7969 goto out;
7970 }
7971 }
7972 visit_type_bool(v, "fatal", &obj->fatal, &err);
7973 if (err) {
7974 goto out;
7975 }
7976
7977out:
7978 error_propagate(errp, err);
7979}
7980
7981void visit_type_q_obj_BLOCK_IO_ERROR_arg_members(Visitor *v, q_obj_BLOCK_IO_ERROR_arg *obj, Error **errp)
7982{
7983 Error *err = NULL;
7984
7985 visit_type_str(v, "device", &obj->device, &err);
7986 if (err) {
7987 goto out;
7988 }
7989 if (visit_optional(v, "node-name", &obj->has_node_name)) {
7990 visit_type_str(v, "node-name", &obj->node_name, &err);
7991 if (err) {
7992 goto out;
7993 }
7994 }
7995 visit_type_IoOperationType(v, "operation", &obj->operation, &err);
7996 if (err) {
7997 goto out;
7998 }
7999 visit_type_BlockErrorAction(v, "action", &obj->action, &err);
8000 if (err) {
8001 goto out;
8002 }
8003 if (visit_optional(v, "nospace", &obj->has_nospace)) {
8004 visit_type_bool(v, "nospace", &obj->nospace, &err);
8005 if (err) {
8006 goto out;
8007 }
8008 }
8009 visit_type_str(v, "reason", &obj->reason, &err);
8010 if (err) {
8011 goto out;
8012 }
8013
8014out:
8015 error_propagate(errp, err);
8016}
8017
8018void visit_type_q_obj_BLOCK_JOB_COMPLETED_arg_members(Visitor *v, q_obj_BLOCK_JOB_COMPLETED_arg *obj, Error **errp)
8019{
8020 Error *err = NULL;
8021
8022 visit_type_JobType(v, "type", &obj->type, &err);
8023 if (err) {
8024 goto out;
8025 }
8026 visit_type_str(v, "device", &obj->device, &err);
8027 if (err) {
8028 goto out;
8029 }
8030 visit_type_int(v, "len", &obj->len, &err);
8031 if (err) {
8032 goto out;
8033 }
8034 visit_type_int(v, "offset", &obj->offset, &err);
8035 if (err) {
8036 goto out;
8037 }
8038 visit_type_int(v, "speed", &obj->speed, &err);
8039 if (err) {
8040 goto out;
8041 }
8042 if (visit_optional(v, "error", &obj->has_error)) {
8043 visit_type_str(v, "error", &obj->error, &err);
8044 if (err) {
8045 goto out;
8046 }
8047 }
8048
8049out:
8050 error_propagate(errp, err);
8051}
8052
8053void visit_type_q_obj_BLOCK_JOB_CANCELLED_arg_members(Visitor *v, q_obj_BLOCK_JOB_CANCELLED_arg *obj, Error **errp)
8054{
8055 Error *err = NULL;
8056
8057 visit_type_JobType(v, "type", &obj->type, &err);
8058 if (err) {
8059 goto out;
8060 }
8061 visit_type_str(v, "device", &obj->device, &err);
8062 if (err) {
8063 goto out;
8064 }
8065 visit_type_int(v, "len", &obj->len, &err);
8066 if (err) {
8067 goto out;
8068 }
8069 visit_type_int(v, "offset", &obj->offset, &err);
8070 if (err) {
8071 goto out;
8072 }
8073 visit_type_int(v, "speed", &obj->speed, &err);
8074 if (err) {
8075 goto out;
8076 }
8077
8078out:
8079 error_propagate(errp, err);
8080}
8081
8082void visit_type_q_obj_BLOCK_JOB_ERROR_arg_members(Visitor *v, q_obj_BLOCK_JOB_ERROR_arg *obj, Error **errp)
8083{
8084 Error *err = NULL;
8085
8086 visit_type_str(v, "device", &obj->device, &err);
8087 if (err) {
8088 goto out;
8089 }
8090 visit_type_IoOperationType(v, "operation", &obj->operation, &err);
8091 if (err) {
8092 goto out;
8093 }
8094 visit_type_BlockErrorAction(v, "action", &obj->action, &err);
8095 if (err) {
8096 goto out;
8097 }
8098
8099out:
8100 error_propagate(errp, err);
8101}
8102
8103void visit_type_q_obj_BLOCK_JOB_READY_arg_members(Visitor *v, q_obj_BLOCK_JOB_READY_arg *obj, Error **errp)
8104{
8105 Error *err = NULL;
8106
8107 visit_type_JobType(v, "type", &obj->type, &err);
8108 if (err) {
8109 goto out;
8110 }
8111 visit_type_str(v, "device", &obj->device, &err);
8112 if (err) {
8113 goto out;
8114 }
8115 visit_type_int(v, "len", &obj->len, &err);
8116 if (err) {
8117 goto out;
8118 }
8119 visit_type_int(v, "offset", &obj->offset, &err);
8120 if (err) {
8121 goto out;
8122 }
8123 visit_type_int(v, "speed", &obj->speed, &err);
8124 if (err) {
8125 goto out;
8126 }
8127
8128out:
8129 error_propagate(errp, err);
8130}
8131
8132void visit_type_q_obj_BLOCK_JOB_PENDING_arg_members(Visitor *v, q_obj_BLOCK_JOB_PENDING_arg *obj, Error **errp)
8133{
8134 Error *err = NULL;
8135
8136 visit_type_JobType(v, "type", &obj->type, &err);
8137 if (err) {
8138 goto out;
8139 }
8140 visit_type_str(v, "id", &obj->id, &err);
8141 if (err) {
8142 goto out;
8143 }
8144
8145out:
8146 error_propagate(errp, err);
8147}
8148
8149void visit_type_PreallocMode(Visitor *v, const char *name, PreallocMode *obj, Error **errp)
8150{
8151 int value = *obj;
8152 visit_type_enum(v, name, &value, &PreallocMode_lookup, errp);
8153 *obj = value;
8154}
8155
8156void visit_type_q_obj_BLOCK_WRITE_THRESHOLD_arg_members(Visitor *v, q_obj_BLOCK_WRITE_THRESHOLD_arg *obj, Error **errp)
8157{
8158 Error *err = NULL;
8159
8160 visit_type_str(v, "node-name", &obj->node_name, &err);
8161 if (err) {
8162 goto out;
8163 }
8164 visit_type_uint64(v, "amount-exceeded", &obj->amount_exceeded, &err);
8165 if (err) {
8166 goto out;
8167 }
8168 visit_type_uint64(v, "write-threshold", &obj->write_threshold, &err);
8169 if (err) {
8170 goto out;
8171 }
8172
8173out:
8174 error_propagate(errp, err);
8175}
8176
8177void visit_type_q_obj_block_set_write_threshold_arg_members(Visitor *v, q_obj_block_set_write_threshold_arg *obj, Error **errp)
8178{
8179 Error *err = NULL;
8180
8181 visit_type_str(v, "node-name", &obj->node_name, &err);
8182 if (err) {
8183 goto out;
8184 }
8185 visit_type_uint64(v, "write-threshold", &obj->write_threshold, &err);
8186 if (err) {
8187 goto out;
8188 }
8189
8190out:
8191 error_propagate(errp, err);
8192}
8193
8194void visit_type_q_obj_x_blockdev_change_arg_members(Visitor *v, q_obj_x_blockdev_change_arg *obj, Error **errp)
8195{
8196 Error *err = NULL;
8197
8198 visit_type_str(v, "parent", &obj->parent, &err);
8199 if (err) {
8200 goto out;
8201 }
8202 if (visit_optional(v, "child", &obj->has_child)) {
8203 visit_type_str(v, "child", &obj->child, &err);
8204 if (err) {
8205 goto out;
8206 }
8207 }
8208 if (visit_optional(v, "node", &obj->has_node)) {
8209 visit_type_str(v, "node", &obj->node, &err);
8210 if (err) {
8211 goto out;
8212 }
8213 }
8214
8215out:
8216 error_propagate(errp, err);
8217}
8218
8219void visit_type_q_obj_x_blockdev_set_iothread_arg_members(Visitor *v, q_obj_x_blockdev_set_iothread_arg *obj, Error **errp)
8220{
8221 Error *err = NULL;
8222
8223 visit_type_str(v, "node-name", &obj->node_name, &err);
8224 if (err) {
8225 goto out;
8226 }
8227 visit_type_StrOrNull(v, "iothread", &obj->iothread, &err);
8228 if (err) {
8229 goto out;
8230 }
8231 if (visit_optional(v, "force", &obj->has_force)) {
8232 visit_type_bool(v, "force", &obj->force, &err);
8233 if (err) {
8234 goto out;
8235 }
8236 }
8237
8238out:
8239 error_propagate(errp, err);
8240}
8241
8242/* Dummy declaration to prevent empty .o file */
8243char qapi_dummy_qapi_visit_block_core_c;
8244