qapi-types-block-core.h source code [qemu/build/qapi/qapi-types-block-core.h]

1	/ AUTOMATICALLY GENERATED, DO NOT MODIFY /
2
3	/*
4	* Schema-defined QAPI types
5	*
6	* Copyright IBM, Corp. 2011
7	* Copyright (c) 2013-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	#ifndef QAPI_TYPES_BLOCK_CORE_H
14	#define QAPI_TYPES_BLOCK_CORE_H
15
16	#include "qapi/qapi-builtin-types.h"
17	#include "qapi-types-common.h"
18	#include "qapi-types-crypto.h"
19	#include "qapi-types-job.h"
20	#include "qapi-types-sockets.h"
21
22	typedef struct SnapshotInfo SnapshotInfo;
23
24	typedef struct ImageInfoSpecificQCow2EncryptionBase ImageInfoSpecificQCow2EncryptionBase;
25
26	typedef struct ImageInfoSpecificQCow2Encryption ImageInfoSpecificQCow2Encryption;
27
28	typedef struct Qcow2BitmapInfoList Qcow2BitmapInfoList;
29
30	typedef struct ImageInfoSpecificQCow2 ImageInfoSpecificQCow2;
31
32	typedef struct ImageInfoList ImageInfoList;
33
34	typedef struct ImageInfoSpecificVmdk ImageInfoSpecificVmdk;
35
36	typedef struct q_obj_ImageInfoSpecificQCow2_wrapper q_obj_ImageInfoSpecificQCow2_wrapper;
37
38	typedef struct q_obj_ImageInfoSpecificVmdk_wrapper q_obj_ImageInfoSpecificVmdk_wrapper;
39
40	typedef struct q_obj_QCryptoBlockInfoLUKS_wrapper q_obj_QCryptoBlockInfoLUKS_wrapper;
41
42	typedef enum ImageInfoSpecificKind {
43	IMAGE_INFO_SPECIFIC_KIND_QCOW2,
44	IMAGE_INFO_SPECIFIC_KIND_VMDK,
45	IMAGE_INFO_SPECIFIC_KIND_LUKS,
46	IMAGE_INFO_SPECIFIC_KIND__MAX,
47	} ImageInfoSpecificKind;
48
49	#define ImageInfoSpecificKind_str(val) \
50	qapi_enum_lookup(&ImageInfoSpecificKind_lookup, (val))
51
52	extern const QEnumLookup ImageInfoSpecificKind_lookup;
53
54	typedef struct ImageInfoSpecific ImageInfoSpecific;
55
56	typedef struct SnapshotInfoList SnapshotInfoList;
57
58	typedef struct ImageInfo ImageInfo;
59
60	typedef struct ImageCheck ImageCheck;
61
62	typedef struct MapEntry MapEntry;
63
64	typedef struct BlockdevCacheInfo BlockdevCacheInfo;
65
66	typedef struct BlockDirtyInfoList BlockDirtyInfoList;
67
68	typedef struct BlockDeviceInfo BlockDeviceInfo;
69
70	typedef enum BlockDeviceIoStatus {
71	BLOCK_DEVICE_IO_STATUS_OK,
72	BLOCK_DEVICE_IO_STATUS_FAILED,
73	BLOCK_DEVICE_IO_STATUS_NOSPACE,
74	BLOCK_DEVICE_IO_STATUS__MAX,
75	} BlockDeviceIoStatus;
76
77	#define BlockDeviceIoStatus_str(val) \
78	qapi_enum_lookup(&BlockDeviceIoStatus_lookup, (val))
79
80	extern const QEnumLookup BlockDeviceIoStatus_lookup;
81
82	typedef struct BlockDeviceMapEntry BlockDeviceMapEntry;
83
84	typedef enum DirtyBitmapStatus {
85	DIRTY_BITMAP_STATUS_ACTIVE,
86	DIRTY_BITMAP_STATUS_DISABLED,
87	DIRTY_BITMAP_STATUS_FROZEN,
88	DIRTY_BITMAP_STATUS_LOCKED,
89	DIRTY_BITMAP_STATUS_INCONSISTENT,
90	DIRTY_BITMAP_STATUS__MAX,
91	} DirtyBitmapStatus;
92
93	#define DirtyBitmapStatus_str(val) \
94	qapi_enum_lookup(&DirtyBitmapStatus_lookup, (val))
95
96	extern const QEnumLookup DirtyBitmapStatus_lookup;
97
98	typedef struct BlockDirtyInfo BlockDirtyInfo;
99
100	typedef enum Qcow2BitmapInfoFlags {
101	QCOW2_BITMAP_INFO_FLAGS_IN_USE,
102	QCOW2_BITMAP_INFO_FLAGS_AUTO,
103	QCOW2_BITMAP_INFO_FLAGS__MAX,
104	} Qcow2BitmapInfoFlags;
105
106	#define Qcow2BitmapInfoFlags_str(val) \
107	qapi_enum_lookup(&Qcow2BitmapInfoFlags_lookup, (val))
108
109	extern const QEnumLookup Qcow2BitmapInfoFlags_lookup;
110
111	typedef struct Qcow2BitmapInfoFlagsList Qcow2BitmapInfoFlagsList;
112
113	typedef struct Qcow2BitmapInfo Qcow2BitmapInfo;
114
115	typedef struct BlockLatencyHistogramInfo BlockLatencyHistogramInfo;
116
117	typedef struct q_obj_block_latency_histogram_set_arg q_obj_block_latency_histogram_set_arg;
118
119	typedef struct BlockInfo BlockInfo;
120
121	typedef struct BlockMeasureInfo BlockMeasureInfo;
122
123	typedef struct BlockInfoList BlockInfoList;
124
125	typedef struct BlockDeviceTimedStats BlockDeviceTimedStats;
126
127	typedef struct BlockDeviceTimedStatsList BlockDeviceTimedStatsList;
128
129	typedef struct BlockDeviceStats BlockDeviceStats;
130
131	typedef struct BlockStats BlockStats;
132
133	typedef struct q_obj_query_blockstats_arg q_obj_query_blockstats_arg;
134
135	typedef struct BlockStatsList BlockStatsList;
136
137	typedef enum BlockdevOnError {
138	BLOCKDEV_ON_ERROR_REPORT,
139	BLOCKDEV_ON_ERROR_IGNORE,
140	BLOCKDEV_ON_ERROR_ENOSPC,
141	BLOCKDEV_ON_ERROR_STOP,
142	BLOCKDEV_ON_ERROR_AUTO,
143	BLOCKDEV_ON_ERROR__MAX,
144	} BlockdevOnError;
145
146	#define BlockdevOnError_str(val) \
147	qapi_enum_lookup(&BlockdevOnError_lookup, (val))
148
149	extern const QEnumLookup BlockdevOnError_lookup;
150
151	typedef enum MirrorSyncMode {
152	MIRROR_SYNC_MODE_TOP,
153	MIRROR_SYNC_MODE_FULL,
154	MIRROR_SYNC_MODE_NONE,
155	MIRROR_SYNC_MODE_INCREMENTAL,
156	MIRROR_SYNC_MODE_BITMAP,
157	MIRROR_SYNC_MODE__MAX,
158	} MirrorSyncMode;
159
160	#define MirrorSyncMode_str(val) \
161	qapi_enum_lookup(&MirrorSyncMode_lookup, (val))
162
163	extern const QEnumLookup MirrorSyncMode_lookup;
164
165	typedef enum BitmapSyncMode {
166	BITMAP_SYNC_MODE_ON_SUCCESS,
167	BITMAP_SYNC_MODE_NEVER,
168	BITMAP_SYNC_MODE_ALWAYS,
169	BITMAP_SYNC_MODE__MAX,
170	} BitmapSyncMode;
171
172	#define BitmapSyncMode_str(val) \
173	qapi_enum_lookup(&BitmapSyncMode_lookup, (val))
174
175	extern const QEnumLookup BitmapSyncMode_lookup;
176
177	typedef enum MirrorCopyMode {
178	MIRROR_COPY_MODE_BACKGROUND,
179	MIRROR_COPY_MODE_WRITE_BLOCKING,
180	MIRROR_COPY_MODE__MAX,
181	} MirrorCopyMode;
182
183	#define MirrorCopyMode_str(val) \
184	qapi_enum_lookup(&MirrorCopyMode_lookup, (val))
185
186	extern const QEnumLookup MirrorCopyMode_lookup;
187
188	typedef struct BlockJobInfo BlockJobInfo;
189
190	typedef struct BlockJobInfoList BlockJobInfoList;
191
192	typedef struct q_obj_block_passwd_arg q_obj_block_passwd_arg;
193
194	typedef struct q_obj_block_resize_arg q_obj_block_resize_arg;
195
196	typedef enum NewImageMode {
197	NEW_IMAGE_MODE_EXISTING,
198	NEW_IMAGE_MODE_ABSOLUTE_PATHS,
199	NEW_IMAGE_MODE__MAX,
200	} NewImageMode;
201
202	#define NewImageMode_str(val) \
203	qapi_enum_lookup(&NewImageMode_lookup, (val))
204
205	extern const QEnumLookup NewImageMode_lookup;
206
207	typedef struct BlockdevSnapshotSync BlockdevSnapshotSync;
208
209	typedef struct BlockdevSnapshot BlockdevSnapshot;
210
211	typedef struct BackupCommon BackupCommon;
212
213	typedef struct DriveBackup DriveBackup;
214
215	typedef struct BlockdevBackup BlockdevBackup;
216
217	typedef struct q_obj_change_backing_file_arg q_obj_change_backing_file_arg;
218
219	typedef struct q_obj_block_commit_arg q_obj_block_commit_arg;
220
221	typedef struct BlockDeviceInfoList BlockDeviceInfoList;
222
223	typedef enum XDbgBlockGraphNodeType {
224	X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_BACKEND,
225	X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_JOB,
226	X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_DRIVER,
227	X_DBG_BLOCK_GRAPH_NODE_TYPE__MAX,
228	} XDbgBlockGraphNodeType;
229
230	#define XDbgBlockGraphNodeType_str(val) \
231	qapi_enum_lookup(&XDbgBlockGraphNodeType_lookup, (val))
232
233	extern const QEnumLookup XDbgBlockGraphNodeType_lookup;
234
235	typedef struct XDbgBlockGraphNode XDbgBlockGraphNode;
236
237	typedef enum BlockPermission {
238	BLOCK_PERMISSION_CONSISTENT_READ,
239	BLOCK_PERMISSION_WRITE,
240	BLOCK_PERMISSION_WRITE_UNCHANGED,
241	BLOCK_PERMISSION_RESIZE,
242	BLOCK_PERMISSION_GRAPH_MOD,
243	BLOCK_PERMISSION__MAX,
244	} BlockPermission;
245
246	#define BlockPermission_str(val) \
247	qapi_enum_lookup(&BlockPermission_lookup, (val))
248
249	extern const QEnumLookup BlockPermission_lookup;
250
251	typedef struct BlockPermissionList BlockPermissionList;
252
253	typedef struct XDbgBlockGraphEdge XDbgBlockGraphEdge;
254
255	typedef struct XDbgBlockGraphNodeList XDbgBlockGraphNodeList;
256
257	typedef struct XDbgBlockGraphEdgeList XDbgBlockGraphEdgeList;
258
259	typedef struct XDbgBlockGraph XDbgBlockGraph;
260
261	typedef struct DriveMirror DriveMirror;
262
263	typedef struct BlockDirtyBitmap BlockDirtyBitmap;
264
265	typedef struct BlockDirtyBitmapAdd BlockDirtyBitmapAdd;
266
267	typedef struct BlockDirtyBitmapMergeSource BlockDirtyBitmapMergeSource;
268
269	typedef struct BlockDirtyBitmapMergeSourceList BlockDirtyBitmapMergeSourceList;
270
271	typedef struct BlockDirtyBitmapMerge BlockDirtyBitmapMerge;
272
273	typedef struct BlockDirtyBitmapSha256 BlockDirtyBitmapSha256;
274
275	typedef struct q_obj_blockdev_mirror_arg q_obj_blockdev_mirror_arg;
276
277	typedef struct BlockIOThrottle BlockIOThrottle;
278
279	typedef struct ThrottleLimits ThrottleLimits;
280
281	typedef struct q_obj_block_stream_arg q_obj_block_stream_arg;
282
283	typedef struct q_obj_block_job_set_speed_arg q_obj_block_job_set_speed_arg;
284
285	typedef struct q_obj_block_job_cancel_arg q_obj_block_job_cancel_arg;
286
287	typedef struct q_obj_block_job_pause_arg q_obj_block_job_pause_arg;
288
289	typedef struct q_obj_block_job_resume_arg q_obj_block_job_resume_arg;
290
291	typedef struct q_obj_block_job_complete_arg q_obj_block_job_complete_arg;
292
293	typedef struct q_obj_block_job_dismiss_arg q_obj_block_job_dismiss_arg;
294
295	typedef struct q_obj_block_job_finalize_arg q_obj_block_job_finalize_arg;
296
297	typedef enum BlockdevDiscardOptions {
298	BLOCKDEV_DISCARD_OPTIONS_IGNORE,
299	BLOCKDEV_DISCARD_OPTIONS_UNMAP,
300	BLOCKDEV_DISCARD_OPTIONS__MAX,
301	} BlockdevDiscardOptions;
302
303	#define BlockdevDiscardOptions_str(val) \
304	qapi_enum_lookup(&BlockdevDiscardOptions_lookup, (val))
305
306	extern const QEnumLookup BlockdevDiscardOptions_lookup;
307
308	typedef enum BlockdevDetectZeroesOptions {
309	BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF,
310	BLOCKDEV_DETECT_ZEROES_OPTIONS_ON,
311	BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP,
312	BLOCKDEV_DETECT_ZEROES_OPTIONS__MAX,
313	} BlockdevDetectZeroesOptions;
314
315	#define BlockdevDetectZeroesOptions_str(val) \
316	qapi_enum_lookup(&BlockdevDetectZeroesOptions_lookup, (val))
317
318	extern const QEnumLookup BlockdevDetectZeroesOptions_lookup;
319
320	typedef enum BlockdevAioOptions {
321	BLOCKDEV_AIO_OPTIONS_THREADS,
322	BLOCKDEV_AIO_OPTIONS_NATIVE,
323	BLOCKDEV_AIO_OPTIONS__MAX,
324	} BlockdevAioOptions;
325
326	#define BlockdevAioOptions_str(val) \
327	qapi_enum_lookup(&BlockdevAioOptions_lookup, (val))
328
329	extern const QEnumLookup BlockdevAioOptions_lookup;
330
331	typedef struct BlockdevCacheOptions BlockdevCacheOptions;
332
333	typedef enum BlockdevDriver {
334	BLOCKDEV_DRIVER_BLKDEBUG,
335	BLOCKDEV_DRIVER_BLKLOGWRITES,
336	BLOCKDEV_DRIVER_BLKVERIFY,
337	BLOCKDEV_DRIVER_BOCHS,
338	BLOCKDEV_DRIVER_CLOOP,
339	BLOCKDEV_DRIVER_COPY_ON_READ,
340	BLOCKDEV_DRIVER_DMG,
341	BLOCKDEV_DRIVER_FILE,
342	BLOCKDEV_DRIVER_FTP,
343	BLOCKDEV_DRIVER_FTPS,
344	BLOCKDEV_DRIVER_GLUSTER,
345	BLOCKDEV_DRIVER_HOST_CDROM,
346	BLOCKDEV_DRIVER_HOST_DEVICE,
347	BLOCKDEV_DRIVER_HTTP,
348	BLOCKDEV_DRIVER_HTTPS,
349	BLOCKDEV_DRIVER_ISCSI,
350	BLOCKDEV_DRIVER_LUKS,
351	BLOCKDEV_DRIVER_NBD,
352	BLOCKDEV_DRIVER_NFS,
353	BLOCKDEV_DRIVER_NULL_AIO,
354	BLOCKDEV_DRIVER_NULL_CO,
355	BLOCKDEV_DRIVER_NVME,
356	BLOCKDEV_DRIVER_PARALLELS,
357	BLOCKDEV_DRIVER_QCOW,
358	BLOCKDEV_DRIVER_QCOW2,
359	BLOCKDEV_DRIVER_QED,
360	BLOCKDEV_DRIVER_QUORUM,
361	BLOCKDEV_DRIVER_RAW,
362	BLOCKDEV_DRIVER_RBD,
363	#if defined(CONFIG_REPLICATION)
364	BLOCKDEV_DRIVER_REPLICATION,
365	#endif /* defined(CONFIG_REPLICATION) */
366	BLOCKDEV_DRIVER_SHEEPDOG,
367	BLOCKDEV_DRIVER_SSH,
368	BLOCKDEV_DRIVER_THROTTLE,
369	BLOCKDEV_DRIVER_VDI,
370	BLOCKDEV_DRIVER_VHDX,
371	BLOCKDEV_DRIVER_VMDK,
372	BLOCKDEV_DRIVER_VPC,
373	BLOCKDEV_DRIVER_VVFAT,
374	BLOCKDEV_DRIVER_VXHS,
375	BLOCKDEV_DRIVER__MAX,
376	} BlockdevDriver;
377
378	#define BlockdevDriver_str(val) \
379	qapi_enum_lookup(&BlockdevDriver_lookup, (val))
380
381	extern const QEnumLookup BlockdevDriver_lookup;
382
383	typedef struct BlockdevOptionsFile BlockdevOptionsFile;
384
385	typedef struct BlockdevOptionsNull BlockdevOptionsNull;
386
387	typedef struct BlockdevOptionsNVMe BlockdevOptionsNVMe;
388
389	typedef struct BlockdevOptionsVVFAT BlockdevOptionsVVFAT;
390
391	typedef struct BlockdevOptionsGenericFormat BlockdevOptionsGenericFormat;
392
393	typedef struct BlockdevOptionsLUKS BlockdevOptionsLUKS;
394
395	typedef struct BlockdevOptionsGenericCOWFormat BlockdevOptionsGenericCOWFormat;
396
397	typedef enum Qcow2OverlapCheckMode {
398	QCOW2_OVERLAP_CHECK_MODE_NONE,
399	QCOW2_OVERLAP_CHECK_MODE_CONSTANT,
400	QCOW2_OVERLAP_CHECK_MODE_CACHED,
401	QCOW2_OVERLAP_CHECK_MODE_ALL,
402	QCOW2_OVERLAP_CHECK_MODE__MAX,
403	} Qcow2OverlapCheckMode;
404
405	#define Qcow2OverlapCheckMode_str(val) \
406	qapi_enum_lookup(&Qcow2OverlapCheckMode_lookup, (val))
407
408	extern const QEnumLookup Qcow2OverlapCheckMode_lookup;
409
410	typedef struct Qcow2OverlapCheckFlags Qcow2OverlapCheckFlags;
411
412	typedef struct Qcow2OverlapChecks Qcow2OverlapChecks;
413
414	typedef enum BlockdevQcowEncryptionFormat {
415	BLOCKDEV_QCOW_ENCRYPTION_FORMAT_AES,
416	BLOCKDEV_QCOW_ENCRYPTION_FORMAT__MAX,
417	} BlockdevQcowEncryptionFormat;
418
419	#define BlockdevQcowEncryptionFormat_str(val) \
420	qapi_enum_lookup(&BlockdevQcowEncryptionFormat_lookup, (val))
421
422	extern const QEnumLookup BlockdevQcowEncryptionFormat_lookup;
423
424	typedef struct q_obj_BlockdevQcowEncryption_base q_obj_BlockdevQcowEncryption_base;
425
426	typedef struct BlockdevQcowEncryption BlockdevQcowEncryption;
427
428	typedef struct BlockdevOptionsQcow BlockdevOptionsQcow;
429
430	typedef enum BlockdevQcow2EncryptionFormat {
431	BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_AES,
432	BLOCKDEV_QCOW2_ENCRYPTION_FORMAT_LUKS,
433	BLOCKDEV_QCOW2_ENCRYPTION_FORMAT__MAX,
434	} BlockdevQcow2EncryptionFormat;
435
436	#define BlockdevQcow2EncryptionFormat_str(val) \
437	qapi_enum_lookup(&BlockdevQcow2EncryptionFormat_lookup, (val))
438
439	extern const QEnumLookup BlockdevQcow2EncryptionFormat_lookup;
440
441	typedef struct q_obj_BlockdevQcow2Encryption_base q_obj_BlockdevQcow2Encryption_base;
442
443	typedef struct BlockdevQcow2Encryption BlockdevQcow2Encryption;
444
445	typedef struct BlockdevOptionsQcow2 BlockdevOptionsQcow2;
446
447	typedef enum SshHostKeyCheckMode {
448	SSH_HOST_KEY_CHECK_MODE_NONE,
449	SSH_HOST_KEY_CHECK_MODE_HASH,
450	SSH_HOST_KEY_CHECK_MODE_KNOWN_HOSTS,
451	SSH_HOST_KEY_CHECK_MODE__MAX,
452	} SshHostKeyCheckMode;
453
454	#define SshHostKeyCheckMode_str(val) \
455	qapi_enum_lookup(&SshHostKeyCheckMode_lookup, (val))
456
457	extern const QEnumLookup SshHostKeyCheckMode_lookup;
458
459	typedef enum SshHostKeyCheckHashType {
460	SSH_HOST_KEY_CHECK_HASH_TYPE_MD5,
461	SSH_HOST_KEY_CHECK_HASH_TYPE_SHA1,
462	SSH_HOST_KEY_CHECK_HASH_TYPE__MAX,
463	} SshHostKeyCheckHashType;
464
465	#define SshHostKeyCheckHashType_str(val) \
466	qapi_enum_lookup(&SshHostKeyCheckHashType_lookup, (val))
467
468	extern const QEnumLookup SshHostKeyCheckHashType_lookup;
469
470	typedef struct SshHostKeyHash SshHostKeyHash;
471
472	typedef struct q_obj_SshHostKeyCheck_base q_obj_SshHostKeyCheck_base;
473
474	typedef struct SshHostKeyCheck SshHostKeyCheck;
475
476	typedef struct BlockdevOptionsSsh BlockdevOptionsSsh;
477
478	typedef enum BlkdebugEvent {
479	BLKDBG_L1_UPDATE,
480	BLKDBG_L1_GROW_ALLOC_TABLE,
481	BLKDBG_L1_GROW_WRITE_TABLE,
482	BLKDBG_L1_GROW_ACTIVATE_TABLE,
483	BLKDBG_L2_LOAD,
484	BLKDBG_L2_UPDATE,
485	BLKDBG_L2_UPDATE_COMPRESSED,
486	BLKDBG_L2_ALLOC_COW_READ,
487	BLKDBG_L2_ALLOC_WRITE,
488	BLKDBG_READ_AIO,
489	BLKDBG_READ_BACKING_AIO,
490	BLKDBG_READ_COMPRESSED,
491	BLKDBG_WRITE_AIO,
492	BLKDBG_WRITE_COMPRESSED,
493	BLKDBG_VMSTATE_LOAD,
494	BLKDBG_VMSTATE_SAVE,
495	BLKDBG_COW_READ,
496	BLKDBG_COW_WRITE,
497	BLKDBG_REFTABLE_LOAD,
498	BLKDBG_REFTABLE_GROW,
499	BLKDBG_REFTABLE_UPDATE,
500	BLKDBG_REFBLOCK_LOAD,
501	BLKDBG_REFBLOCK_UPDATE,
502	BLKDBG_REFBLOCK_UPDATE_PART,
503	BLKDBG_REFBLOCK_ALLOC,
504	BLKDBG_REFBLOCK_ALLOC_HOOKUP,
505	BLKDBG_REFBLOCK_ALLOC_WRITE,
506	BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS,
507	BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE,
508	BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE,
509	BLKDBG_CLUSTER_ALLOC,
510	BLKDBG_CLUSTER_ALLOC_BYTES,
511	BLKDBG_CLUSTER_FREE,
512	BLKDBG_FLUSH_TO_OS,
513	BLKDBG_FLUSH_TO_DISK,
514	BLKDBG_PWRITEV_RMW_HEAD,
515	BLKDBG_PWRITEV_RMW_AFTER_HEAD,
516	BLKDBG_PWRITEV_RMW_TAIL,
517	BLKDBG_PWRITEV_RMW_AFTER_TAIL,
518	BLKDBG_PWRITEV,
519	BLKDBG_PWRITEV_ZERO,
520	BLKDBG_PWRITEV_DONE,
521	BLKDBG_EMPTY_IMAGE_PREPARE,
522	BLKDBG_L1_SHRINK_WRITE_TABLE,
523	BLKDBG_L1_SHRINK_FREE_L2_CLUSTERS,
524	BLKDBG_COR_WRITE,
525	BLKDBG_CLUSTER_ALLOC_SPACE,
526	BLKDBG_NONE,
527	BLKDBG__MAX,
528	} BlkdebugEvent;
529
530	#define BlkdebugEvent_str(val) \
531	qapi_enum_lookup(&BlkdebugEvent_lookup, (val))
532
533	extern const QEnumLookup BlkdebugEvent_lookup;
534
535	typedef enum BlkdebugIOType {
536	BLKDEBUG_IO_TYPE_READ,
537	BLKDEBUG_IO_TYPE_WRITE,
538	BLKDEBUG_IO_TYPE_WRITE_ZEROES,
539	BLKDEBUG_IO_TYPE_DISCARD,
540	BLKDEBUG_IO_TYPE_FLUSH,
541	BLKDEBUG_IO_TYPE_BLOCK_STATUS,
542	BLKDEBUG_IO_TYPE__MAX,
543	} BlkdebugIOType;
544
545	#define BlkdebugIOType_str(val) \
546	qapi_enum_lookup(&BlkdebugIOType_lookup, (val))
547
548	extern const QEnumLookup BlkdebugIOType_lookup;
549
550	typedef struct BlkdebugInjectErrorOptions BlkdebugInjectErrorOptions;
551
552	typedef struct BlkdebugSetStateOptions BlkdebugSetStateOptions;
553
554	typedef struct BlkdebugInjectErrorOptionsList BlkdebugInjectErrorOptionsList;
555
556	typedef struct BlkdebugSetStateOptionsList BlkdebugSetStateOptionsList;
557
558	typedef struct BlockdevOptionsBlkdebug BlockdevOptionsBlkdebug;
559
560	typedef struct BlockdevOptionsBlklogwrites BlockdevOptionsBlklogwrites;
561
562	typedef struct BlockdevOptionsBlkverify BlockdevOptionsBlkverify;
563
564	typedef enum QuorumReadPattern {
565	QUORUM_READ_PATTERN_QUORUM,
566	QUORUM_READ_PATTERN_FIFO,
567	QUORUM_READ_PATTERN__MAX,
568	} QuorumReadPattern;
569
570	#define QuorumReadPattern_str(val) \
571	qapi_enum_lookup(&QuorumReadPattern_lookup, (val))
572
573	extern const QEnumLookup QuorumReadPattern_lookup;
574
575	typedef struct BlockdevRefList BlockdevRefList;
576
577	typedef struct BlockdevOptionsQuorum BlockdevOptionsQuorum;
578
579	typedef struct BlockdevOptionsGluster BlockdevOptionsGluster;
580
581	typedef enum IscsiTransport {
582	ISCSI_TRANSPORT_TCP,
583	ISCSI_TRANSPORT_ISER,
584	ISCSI_TRANSPORT__MAX,
585	} IscsiTransport;
586
587	#define IscsiTransport_str(val) \
588	qapi_enum_lookup(&IscsiTransport_lookup, (val))
589
590	extern const QEnumLookup IscsiTransport_lookup;
591
592	typedef enum IscsiHeaderDigest {
593	QAPI_ISCSI_HEADER_DIGEST_CRC32C,
594	QAPI_ISCSI_HEADER_DIGEST_NONE,
595	QAPI_ISCSI_HEADER_DIGEST_CRC32C_NONE,
596	QAPI_ISCSI_HEADER_DIGEST_NONE_CRC32C,
597	QAPI_ISCSI_HEADER_DIGEST__MAX,
598	} IscsiHeaderDigest;
599
600	#define IscsiHeaderDigest_str(val) \
601	qapi_enum_lookup(&IscsiHeaderDigest_lookup, (val))
602
603	extern const QEnumLookup IscsiHeaderDigest_lookup;
604
605	typedef struct BlockdevOptionsIscsi BlockdevOptionsIscsi;
606
607	typedef enum RbdAuthMode {
608	RBD_AUTH_MODE_CEPHX,
609	RBD_AUTH_MODE_NONE,
610	RBD_AUTH_MODE__MAX,
611	} RbdAuthMode;
612
613	#define RbdAuthMode_str(val) \
614	qapi_enum_lookup(&RbdAuthMode_lookup, (val))
615
616	extern const QEnumLookup RbdAuthMode_lookup;
617
618	typedef struct RbdAuthModeList RbdAuthModeList;
619
620	typedef struct BlockdevOptionsRbd BlockdevOptionsRbd;
621
622	typedef struct BlockdevOptionsSheepdog BlockdevOptionsSheepdog;
623
624	#if defined(CONFIG_REPLICATION)
625	typedef enum ReplicationMode {
626	REPLICATION_MODE_PRIMARY,
627	REPLICATION_MODE_SECONDARY,
628	REPLICATION_MODE__MAX,
629	} ReplicationMode;
630
631	#define ReplicationMode_str(val) \
632	qapi_enum_lookup(&ReplicationMode_lookup, (val))
633
634	extern const QEnumLookup ReplicationMode_lookup;
635	#endif /* defined(CONFIG_REPLICATION) */
636
637	#if defined(CONFIG_REPLICATION)
638	typedef struct BlockdevOptionsReplication BlockdevOptionsReplication;
639	#endif /* defined(CONFIG_REPLICATION) */
640
641	typedef enum NFSTransport {
642	NFS_TRANSPORT_INET,
643	NFS_TRANSPORT__MAX,
644	} NFSTransport;
645
646	#define NFSTransport_str(val) \
647	qapi_enum_lookup(&NFSTransport_lookup, (val))
648
649	extern const QEnumLookup NFSTransport_lookup;
650
651	typedef struct NFSServer NFSServer;
652
653	typedef struct BlockdevOptionsNfs BlockdevOptionsNfs;
654
655	typedef struct BlockdevOptionsCurlBase BlockdevOptionsCurlBase;
656
657	typedef struct BlockdevOptionsCurlHttp BlockdevOptionsCurlHttp;
658
659	typedef struct BlockdevOptionsCurlHttps BlockdevOptionsCurlHttps;
660
661	typedef struct BlockdevOptionsCurlFtp BlockdevOptionsCurlFtp;
662
663	typedef struct BlockdevOptionsCurlFtps BlockdevOptionsCurlFtps;
664
665	typedef struct BlockdevOptionsNbd BlockdevOptionsNbd;
666
667	typedef struct BlockdevOptionsRaw BlockdevOptionsRaw;
668
669	typedef struct BlockdevOptionsVxHS BlockdevOptionsVxHS;
670
671	typedef struct BlockdevOptionsThrottle BlockdevOptionsThrottle;
672
673	typedef struct q_obj_BlockdevOptions_base q_obj_BlockdevOptions_base;
674
675	typedef struct BlockdevOptions BlockdevOptions;
676
677	typedef struct BlockdevRef BlockdevRef;
678
679	typedef struct BlockdevRefOrNull BlockdevRefOrNull;
680
681	typedef struct q_obj_blockdev_del_arg q_obj_blockdev_del_arg;
682
683	typedef struct BlockdevCreateOptionsFile BlockdevCreateOptionsFile;
684
685	typedef struct BlockdevCreateOptionsGluster BlockdevCreateOptionsGluster;
686
687	typedef struct BlockdevCreateOptionsLUKS BlockdevCreateOptionsLUKS;
688
689	typedef struct BlockdevCreateOptionsNfs BlockdevCreateOptionsNfs;
690
691	typedef struct BlockdevCreateOptionsParallels BlockdevCreateOptionsParallels;
692
693	typedef struct BlockdevCreateOptionsQcow BlockdevCreateOptionsQcow;
694
695	typedef enum BlockdevQcow2Version {
696	BLOCKDEV_QCOW2_VERSION_V2,
697	BLOCKDEV_QCOW2_VERSION_V3,
698	BLOCKDEV_QCOW2_VERSION__MAX,
699	} BlockdevQcow2Version;
700
701	#define BlockdevQcow2Version_str(val) \
702	qapi_enum_lookup(&BlockdevQcow2Version_lookup, (val))
703
704	extern const QEnumLookup BlockdevQcow2Version_lookup;
705
706	typedef struct BlockdevCreateOptionsQcow2 BlockdevCreateOptionsQcow2;
707
708	typedef struct BlockdevCreateOptionsQed BlockdevCreateOptionsQed;
709
710	typedef struct BlockdevCreateOptionsRbd BlockdevCreateOptionsRbd;
711
712	typedef enum BlockdevVmdkSubformat {
713	BLOCKDEV_VMDK_SUBFORMAT_MONOLITHICSPARSE,
714	BLOCKDEV_VMDK_SUBFORMAT_MONOLITHICFLAT,
715	BLOCKDEV_VMDK_SUBFORMAT_TWOGBMAXEXTENTSPARSE,
716	BLOCKDEV_VMDK_SUBFORMAT_TWOGBMAXEXTENTFLAT,
717	BLOCKDEV_VMDK_SUBFORMAT_STREAMOPTIMIZED,
718	BLOCKDEV_VMDK_SUBFORMAT__MAX,
719	} BlockdevVmdkSubformat;
720
721	#define BlockdevVmdkSubformat_str(val) \
722	qapi_enum_lookup(&BlockdevVmdkSubformat_lookup, (val))
723
724	extern const QEnumLookup BlockdevVmdkSubformat_lookup;
725
726	typedef enum BlockdevVmdkAdapterType {
727	BLOCKDEV_VMDK_ADAPTER_TYPE_IDE,
728	BLOCKDEV_VMDK_ADAPTER_TYPE_BUSLOGIC,
729	BLOCKDEV_VMDK_ADAPTER_TYPE_LSILOGIC,
730	BLOCKDEV_VMDK_ADAPTER_TYPE_LEGACYESX,
731	BLOCKDEV_VMDK_ADAPTER_TYPE__MAX,
732	} BlockdevVmdkAdapterType;
733
734	#define BlockdevVmdkAdapterType_str(val) \
735	qapi_enum_lookup(&BlockdevVmdkAdapterType_lookup, (val))
736
737	extern const QEnumLookup BlockdevVmdkAdapterType_lookup;
738
739	typedef struct BlockdevCreateOptionsVmdk BlockdevCreateOptionsVmdk;
740
741	typedef enum SheepdogRedundancyType {
742	SHEEPDOG_REDUNDANCY_TYPE_FULL,
743	SHEEPDOG_REDUNDANCY_TYPE_ERASURE_CODED,
744	SHEEPDOG_REDUNDANCY_TYPE__MAX,
745	} SheepdogRedundancyType;
746
747	#define SheepdogRedundancyType_str(val) \
748	qapi_enum_lookup(&SheepdogRedundancyType_lookup, (val))
749
750	extern const QEnumLookup SheepdogRedundancyType_lookup;
751
752	typedef struct SheepdogRedundancyFull SheepdogRedundancyFull;
753
754	typedef struct SheepdogRedundancyErasureCoded SheepdogRedundancyErasureCoded;
755
756	typedef struct q_obj_SheepdogRedundancy_base q_obj_SheepdogRedundancy_base;
757
758	typedef struct SheepdogRedundancy SheepdogRedundancy;
759
760	typedef struct BlockdevCreateOptionsSheepdog BlockdevCreateOptionsSheepdog;
761
762	typedef struct BlockdevCreateOptionsSsh BlockdevCreateOptionsSsh;
763
764	typedef struct BlockdevCreateOptionsVdi BlockdevCreateOptionsVdi;
765
766	typedef enum BlockdevVhdxSubformat {
767	BLOCKDEV_VHDX_SUBFORMAT_DYNAMIC,
768	BLOCKDEV_VHDX_SUBFORMAT_FIXED,
769	BLOCKDEV_VHDX_SUBFORMAT__MAX,
770	} BlockdevVhdxSubformat;
771
772	#define BlockdevVhdxSubformat_str(val) \
773	qapi_enum_lookup(&BlockdevVhdxSubformat_lookup, (val))
774
775	extern const QEnumLookup BlockdevVhdxSubformat_lookup;
776
777	typedef struct BlockdevCreateOptionsVhdx BlockdevCreateOptionsVhdx;
778
779	typedef enum BlockdevVpcSubformat {
780	BLOCKDEV_VPC_SUBFORMAT_DYNAMIC,
781	BLOCKDEV_VPC_SUBFORMAT_FIXED,
782	BLOCKDEV_VPC_SUBFORMAT__MAX,
783	} BlockdevVpcSubformat;
784
785	#define BlockdevVpcSubformat_str(val) \
786	qapi_enum_lookup(&BlockdevVpcSubformat_lookup, (val))
787
788	extern const QEnumLookup BlockdevVpcSubformat_lookup;
789
790	typedef struct BlockdevCreateOptionsVpc BlockdevCreateOptionsVpc;
791
792	typedef struct q_obj_BlockdevCreateOptions_base q_obj_BlockdevCreateOptions_base;
793
794	typedef struct BlockdevCreateOptions BlockdevCreateOptions;
795
796	typedef struct q_obj_blockdev_create_arg q_obj_blockdev_create_arg;
797
798	typedef struct q_obj_blockdev_open_tray_arg q_obj_blockdev_open_tray_arg;
799
800	typedef struct q_obj_blockdev_close_tray_arg q_obj_blockdev_close_tray_arg;
801
802	typedef struct q_obj_blockdev_remove_medium_arg q_obj_blockdev_remove_medium_arg;
803
804	typedef struct q_obj_blockdev_insert_medium_arg q_obj_blockdev_insert_medium_arg;
805
806	typedef enum BlockdevChangeReadOnlyMode {
807	BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN,
808	BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_ONLY,
809	BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_WRITE,
810	BLOCKDEV_CHANGE_READ_ONLY_MODE__MAX,
811	} BlockdevChangeReadOnlyMode;
812
813	#define BlockdevChangeReadOnlyMode_str(val) \
814	qapi_enum_lookup(&BlockdevChangeReadOnlyMode_lookup, (val))
815
816	extern const QEnumLookup BlockdevChangeReadOnlyMode_lookup;
817
818	typedef struct q_obj_blockdev_change_medium_arg q_obj_blockdev_change_medium_arg;
819
820	typedef enum BlockErrorAction {
821	BLOCK_ERROR_ACTION_IGNORE,
822	BLOCK_ERROR_ACTION_REPORT,
823	BLOCK_ERROR_ACTION_STOP,
824	BLOCK_ERROR_ACTION__MAX,
825	} BlockErrorAction;
826
827	#define BlockErrorAction_str(val) \
828	qapi_enum_lookup(&BlockErrorAction_lookup, (val))
829
830	extern const QEnumLookup BlockErrorAction_lookup;
831
832	typedef struct q_obj_BLOCK_IMAGE_CORRUPTED_arg q_obj_BLOCK_IMAGE_CORRUPTED_arg;
833
834	typedef struct q_obj_BLOCK_IO_ERROR_arg q_obj_BLOCK_IO_ERROR_arg;
835
836	typedef struct q_obj_BLOCK_JOB_COMPLETED_arg q_obj_BLOCK_JOB_COMPLETED_arg;
837
838	typedef struct q_obj_BLOCK_JOB_CANCELLED_arg q_obj_BLOCK_JOB_CANCELLED_arg;
839
840	typedef struct q_obj_BLOCK_JOB_ERROR_arg q_obj_BLOCK_JOB_ERROR_arg;
841
842	typedef struct q_obj_BLOCK_JOB_READY_arg q_obj_BLOCK_JOB_READY_arg;
843
844	typedef struct q_obj_BLOCK_JOB_PENDING_arg q_obj_BLOCK_JOB_PENDING_arg;
845
846	typedef enum PreallocMode {
847	PREALLOC_MODE_OFF,
848	PREALLOC_MODE_METADATA,
849	PREALLOC_MODE_FALLOC,
850	PREALLOC_MODE_FULL,
851	PREALLOC_MODE__MAX,
852	} PreallocMode;
853
854	#define PreallocMode_str(val) \
855	qapi_enum_lookup(&PreallocMode_lookup, (val))
856
857	extern const QEnumLookup PreallocMode_lookup;
858
859	typedef struct q_obj_BLOCK_WRITE_THRESHOLD_arg q_obj_BLOCK_WRITE_THRESHOLD_arg;
860
861	typedef struct q_obj_block_set_write_threshold_arg q_obj_block_set_write_threshold_arg;
862
863	typedef struct q_obj_x_blockdev_change_arg q_obj_x_blockdev_change_arg;
864
865	typedef struct q_obj_x_blockdev_set_iothread_arg q_obj_x_blockdev_set_iothread_arg;
866
867	struct SnapshotInfo {
868	char *id;
869	char *name;
870	int64_t vm_state_size;
871	int64_t date_sec;
872	int64_t date_nsec;
873	int64_t vm_clock_sec;
874	int64_t vm_clock_nsec;
875	};
876
877	void qapi_free_SnapshotInfo(SnapshotInfo *obj);
878
879	struct ImageInfoSpecificQCow2EncryptionBase {
880	BlockdevQcow2EncryptionFormat format;
881	};
882
883	void qapi_free_ImageInfoSpecificQCow2EncryptionBase(ImageInfoSpecificQCow2EncryptionBase *obj);
884
885	struct ImageInfoSpecificQCow2Encryption {
886	/ Members inherited from ImageInfoSpecificQCow2EncryptionBase: /
887	BlockdevQcow2EncryptionFormat format;
888	/ Own members: /
889	union { / union tag is @format /
890	QCryptoBlockInfoLUKS luks;
891	} u;
892	};
893
894	static inline ImageInfoSpecificQCow2EncryptionBase qapi_ImageInfoSpecificQCow2Encryption_base(const* ImageInfoSpecificQCow2Encryption *obj)
895	{
896	return (ImageInfoSpecificQCow2EncryptionBase *)obj;
897	}
898
899	void qapi_free_ImageInfoSpecificQCow2Encryption(ImageInfoSpecificQCow2Encryption *obj);
900
901	struct Qcow2BitmapInfoList {
902	Qcow2BitmapInfoList *next;
903	Qcow2BitmapInfo *value;
904	};
905
906	void qapi_free_Qcow2BitmapInfoList(Qcow2BitmapInfoList *obj);
907
908	struct ImageInfoSpecificQCow2 {
909	char *compat;
910	bool has_data_file;
911	char *data_file;
912	bool has_data_file_raw;
913	bool data_file_raw;
914	bool has_lazy_refcounts;
915	bool lazy_refcounts;
916	bool has_corrupt;
917	bool corrupt;
918	int64_t refcount_bits;
919	bool has_encrypt;
920	ImageInfoSpecificQCow2Encryption *encrypt;
921	bool has_bitmaps;
922	Qcow2BitmapInfoList *bitmaps;
923	};
924
925	void qapi_free_ImageInfoSpecificQCow2(ImageInfoSpecificQCow2 *obj);
926
927	struct ImageInfoList {
928	ImageInfoList *next;
929	ImageInfo *value;
930	};
931
932	void qapi_free_ImageInfoList(ImageInfoList *obj);
933
934	struct ImageInfoSpecificVmdk {
935	char *create_type;
936	int64_t cid;
937	int64_t parent_cid;
938	ImageInfoList *extents;
939	};
940
941	void qapi_free_ImageInfoSpecificVmdk(ImageInfoSpecificVmdk *obj);
942
943	struct q_obj_ImageInfoSpecificQCow2_wrapper {
944	ImageInfoSpecificQCow2 *data;
945	};
946
947	struct q_obj_ImageInfoSpecificVmdk_wrapper {
948	ImageInfoSpecificVmdk *data;
949	};
950
951	struct q_obj_QCryptoBlockInfoLUKS_wrapper {
952	QCryptoBlockInfoLUKS *data;
953	};
954
955	struct ImageInfoSpecific {
956	ImageInfoSpecificKind type;
957	union { / union tag is @type /
958	q_obj_ImageInfoSpecificQCow2_wrapper qcow2;
959	q_obj_ImageInfoSpecificVmdk_wrapper vmdk;
960	q_obj_QCryptoBlockInfoLUKS_wrapper luks;
961	} u;
962	};
963
964	void qapi_free_ImageInfoSpecific(ImageInfoSpecific *obj);
965
966	struct SnapshotInfoList {
967	SnapshotInfoList *next;
968	SnapshotInfo *value;
969	};
970
971	void qapi_free_SnapshotInfoList(SnapshotInfoList *obj);
972
973	struct ImageInfo {
974	char *filename;
975	char *format;
976	bool has_dirty_flag;
977	bool dirty_flag;
978	bool has_actual_size;
979	int64_t actual_size;
980	int64_t virtual_size;
981	bool has_cluster_size;
982	int64_t cluster_size;
983	bool has_encrypted;
984	bool encrypted;
985	bool has_compressed;
986	bool compressed;
987	bool has_backing_filename;
988	char *backing_filename;
989	bool has_full_backing_filename;
990	char *full_backing_filename;
991	bool has_backing_filename_format;
992	char *backing_filename_format;
993	bool has_snapshots;
994	SnapshotInfoList *snapshots;
995	bool has_backing_image;
996	ImageInfo *backing_image;
997	bool has_format_specific;
998	ImageInfoSpecific *format_specific;
999	};
1000
1001	void qapi_free_ImageInfo(ImageInfo *obj);
1002
1003	struct ImageCheck {
1004	char *filename;
1005	char *format;
1006	int64_t check_errors;
1007	bool has_image_end_offset;
1008	int64_t image_end_offset;
1009	bool has_corruptions;
1010	int64_t corruptions;
1011	bool has_leaks;
1012	int64_t leaks;
1013	bool has_corruptions_fixed;
1014	int64_t corruptions_fixed;
1015	bool has_leaks_fixed;
1016	int64_t leaks_fixed;
1017	bool has_total_clusters;
1018	int64_t total_clusters;
1019	bool has_allocated_clusters;
1020	int64_t allocated_clusters;
1021	bool has_fragmented_clusters;
1022	int64_t fragmented_clusters;
1023	bool has_compressed_clusters;
1024	int64_t compressed_clusters;
1025	};
1026
1027	void qapi_free_ImageCheck(ImageCheck *obj);
1028
1029	struct MapEntry {
1030	int64_t start;
1031	int64_t length;
1032	bool data;
1033	bool zero;
1034	int64_t depth;
1035	bool has_offset;
1036	int64_t offset;
1037	bool has_filename;
1038	char *filename;
1039	};
1040
1041	void qapi_free_MapEntry(MapEntry *obj);
1042
1043	struct BlockdevCacheInfo {
1044	bool writeback;
1045	bool direct;
1046	bool no_flush;
1047	};
1048
1049	void qapi_free_BlockdevCacheInfo(BlockdevCacheInfo *obj);
1050
1051	struct BlockDirtyInfoList {
1052	BlockDirtyInfoList *next;
1053	BlockDirtyInfo *value;
1054	};
1055
1056	void qapi_free_BlockDirtyInfoList(BlockDirtyInfoList *obj);
1057
1058	struct BlockDeviceInfo {
1059	char *file;
1060	bool has_node_name;
1061	char *node_name;
1062	bool ro;
1063	char *drv;
1064	bool has_backing_file;
1065	char *backing_file;
1066	int64_t backing_file_depth;
1067	bool encrypted;
1068	bool encryption_key_missing;
1069	BlockdevDetectZeroesOptions detect_zeroes;
1070	int64_t bps;
1071	int64_t bps_rd;
1072	int64_t bps_wr;
1073	int64_t iops;
1074	int64_t iops_rd;
1075	int64_t iops_wr;
1076	ImageInfo *image;
1077	bool has_bps_max;
1078	int64_t bps_max;
1079	bool has_bps_rd_max;
1080	int64_t bps_rd_max;
1081	bool has_bps_wr_max;
1082	int64_t bps_wr_max;
1083	bool has_iops_max;
1084	int64_t iops_max;
1085	bool has_iops_rd_max;
1086	int64_t iops_rd_max;
1087	bool has_iops_wr_max;
1088	int64_t iops_wr_max;
1089	bool has_bps_max_length;
1090	int64_t bps_max_length;
1091	bool has_bps_rd_max_length;
1092	int64_t bps_rd_max_length;
1093	bool has_bps_wr_max_length;
1094	int64_t bps_wr_max_length;
1095	bool has_iops_max_length;
1096	int64_t iops_max_length;
1097	bool has_iops_rd_max_length;
1098	int64_t iops_rd_max_length;
1099	bool has_iops_wr_max_length;
1100	int64_t iops_wr_max_length;
1101	bool has_iops_size;
1102	int64_t iops_size;
1103	bool has_group;
1104	char *group;
1105	BlockdevCacheInfo *cache;
1106	int64_t write_threshold;
1107	bool has_dirty_bitmaps;
1108	BlockDirtyInfoList *dirty_bitmaps;
1109	};
1110
1111	void qapi_free_BlockDeviceInfo(BlockDeviceInfo *obj);
1112
1113	struct BlockDeviceMapEntry {
1114	int64_t start;
1115	int64_t length;
1116	int64_t depth;
1117	bool zero;
1118	bool data;
1119	bool has_offset;
1120	int64_t offset;
1121	};
1122
1123	void qapi_free_BlockDeviceMapEntry(BlockDeviceMapEntry *obj);
1124
1125	struct BlockDirtyInfo {
1126	bool has_name;
1127	char *name;
1128	int64_t count;
1129	uint32_t granularity;
1130	bool recording;
1131	bool busy;
1132	DirtyBitmapStatus status;
1133	bool persistent;
1134	bool has_inconsistent;
1135	bool inconsistent;
1136	};
1137
1138	void qapi_free_BlockDirtyInfo(BlockDirtyInfo *obj);
1139
1140	struct Qcow2BitmapInfoFlagsList {
1141	Qcow2BitmapInfoFlagsList *next;
1142	Qcow2BitmapInfoFlags value;
1143	};
1144
1145	void qapi_free_Qcow2BitmapInfoFlagsList(Qcow2BitmapInfoFlagsList *obj);
1146
1147	struct Qcow2BitmapInfo {
1148	char *name;
1149	uint32_t granularity;
1150	Qcow2BitmapInfoFlagsList *flags;
1151	};
1152
1153	void qapi_free_Qcow2BitmapInfo(Qcow2BitmapInfo *obj);
1154
1155	struct BlockLatencyHistogramInfo {
1156	uint64List *boundaries;
1157	uint64List *bins;
1158	};
1159
1160	void qapi_free_BlockLatencyHistogramInfo(BlockLatencyHistogramInfo *obj);
1161
1162	struct q_obj_block_latency_histogram_set_arg {
1163	char *id;
1164	bool has_boundaries;
1165	uint64List *boundaries;
1166	bool has_boundaries_read;
1167	uint64List *boundaries_read;
1168	bool has_boundaries_write;
1169	uint64List *boundaries_write;
1170	bool has_boundaries_flush;
1171	uint64List *boundaries_flush;
1172	};
1173
1174	struct BlockInfo {
1175	char *device;
1176	bool has_qdev;
1177	char *qdev;
1178	char *type;
1179	bool removable;
1180	bool locked;
1181	bool has_inserted;
1182	BlockDeviceInfo *inserted;
1183	bool has_tray_open;
1184	bool tray_open;
1185	bool has_io_status;
1186	BlockDeviceIoStatus io_status;
1187	bool has_dirty_bitmaps;
1188	BlockDirtyInfoList *dirty_bitmaps;
1189	};
1190
1191	void qapi_free_BlockInfo(BlockInfo *obj);
1192
1193	struct BlockMeasureInfo {
1194	int64_t required;
1195	int64_t fully_allocated;
1196	};
1197
1198	void qapi_free_BlockMeasureInfo(BlockMeasureInfo *obj);
1199
1200	struct BlockInfoList {
1201	BlockInfoList *next;
1202	BlockInfo *value;
1203	};
1204
1205	void qapi_free_BlockInfoList(BlockInfoList *obj);
1206
1207	struct BlockDeviceTimedStats {
1208	int64_t interval_length;
1209	int64_t min_rd_latency_ns;
1210	int64_t max_rd_latency_ns;
1211	int64_t avg_rd_latency_ns;
1212	int64_t min_wr_latency_ns;
1213	int64_t max_wr_latency_ns;
1214	int64_t avg_wr_latency_ns;
1215	int64_t min_flush_latency_ns;
1216	int64_t max_flush_latency_ns;
1217	int64_t avg_flush_latency_ns;
1218	double avg_rd_queue_depth;
1219	double avg_wr_queue_depth;
1220	};
1221
1222	void qapi_free_BlockDeviceTimedStats(BlockDeviceTimedStats *obj);
1223
1224	struct BlockDeviceTimedStatsList {
1225	BlockDeviceTimedStatsList *next;
1226	BlockDeviceTimedStats *value;
1227	};
1228
1229	void qapi_free_BlockDeviceTimedStatsList(BlockDeviceTimedStatsList *obj);
1230
1231	struct BlockDeviceStats {
1232	int64_t rd_bytes;
1233	int64_t wr_bytes;
1234	int64_t rd_operations;
1235	int64_t wr_operations;
1236	int64_t flush_operations;
1237	int64_t flush_total_time_ns;
1238	int64_t wr_total_time_ns;
1239	int64_t rd_total_time_ns;
1240	int64_t wr_highest_offset;
1241	int64_t rd_merged;
1242	int64_t wr_merged;
1243	bool has_idle_time_ns;
1244	int64_t idle_time_ns;
1245	int64_t failed_rd_operations;
1246	int64_t failed_wr_operations;
1247	int64_t failed_flush_operations;
1248	int64_t invalid_rd_operations;
1249	int64_t invalid_wr_operations;
1250	int64_t invalid_flush_operations;
1251	bool account_invalid;
1252	bool account_failed;
1253	BlockDeviceTimedStatsList *timed_stats;
1254	bool has_rd_latency_histogram;
1255	BlockLatencyHistogramInfo *rd_latency_histogram;
1256	bool has_wr_latency_histogram;
1257	BlockLatencyHistogramInfo *wr_latency_histogram;
1258	bool has_flush_latency_histogram;
1259	BlockLatencyHistogramInfo *flush_latency_histogram;
1260	};
1261
1262	void qapi_free_BlockDeviceStats(BlockDeviceStats *obj);
1263
1264	struct BlockStats {
1265	bool has_device;
1266	char *device;
1267	bool has_qdev;
1268	char *qdev;
1269	bool has_node_name;
1270	char *node_name;
1271	BlockDeviceStats *stats;
1272	bool has_parent;
1273	BlockStats *parent;
1274	bool has_backing;
1275	BlockStats *backing;
1276	};
1277
1278	void qapi_free_BlockStats(BlockStats *obj);
1279
1280	struct q_obj_query_blockstats_arg {
1281	bool has_query_nodes;
1282	bool query_nodes;
1283	};
1284
1285	struct BlockStatsList {
1286	BlockStatsList *next;
1287	BlockStats *value;
1288	};
1289
1290	void qapi_free_BlockStatsList(BlockStatsList *obj);
1291
1292	struct BlockJobInfo {
1293	char *type;
1294	char *device;
1295	int64_t len;
1296	int64_t offset;
1297	bool busy;
1298	bool paused;
1299	int64_t speed;
1300	BlockDeviceIoStatus io_status;
1301	bool ready;
1302	JobStatus status;
1303	bool auto_finalize;
1304	bool auto_dismiss;
1305	bool has_error;
1306	char *error;
1307	};
1308
1309	void qapi_free_BlockJobInfo(BlockJobInfo *obj);
1310
1311	struct BlockJobInfoList {
1312	BlockJobInfoList *next;
1313	BlockJobInfo *value;
1314	};
1315
1316	void qapi_free_BlockJobInfoList(BlockJobInfoList *obj);
1317
1318	struct q_obj_block_passwd_arg {
1319	bool has_device;
1320	char *device;
1321	bool has_node_name;
1322	char *node_name;
1323	char *password;
1324	};
1325
1326	struct q_obj_block_resize_arg {
1327	bool has_device;
1328	char *device;
1329	bool has_node_name;
1330	char *node_name;
1331	int64_t size;
1332	};
1333
1334	struct BlockdevSnapshotSync {
1335	bool has_device;
1336	char *device;
1337	bool has_node_name;
1338	char *node_name;
1339	char *snapshot_file;
1340	bool has_snapshot_node_name;
1341	char *snapshot_node_name;
1342	bool has_format;
1343	char *format;
1344	bool has_mode;
1345	NewImageMode mode;
1346	};
1347
1348	void qapi_free_BlockdevSnapshotSync(BlockdevSnapshotSync *obj);
1349
1350	struct BlockdevSnapshot {
1351	char *node;
1352	char *overlay;
1353	};
1354
1355	void qapi_free_BlockdevSnapshot(BlockdevSnapshot *obj);
1356
1357	struct BackupCommon {
1358	bool has_job_id;
1359	char *job_id;
1360	char *device;
1361	MirrorSyncMode sync;
1362	bool has_speed;
1363	int64_t speed;
1364	bool has_bitmap;
1365	char *bitmap;
1366	bool has_bitmap_mode;
1367	BitmapSyncMode bitmap_mode;
1368	bool has_compress;
1369	bool compress;
1370	bool has_on_source_error;
1371	BlockdevOnError on_source_error;
1372	bool has_on_target_error;
1373	BlockdevOnError on_target_error;
1374	bool has_auto_finalize;
1375	bool auto_finalize;
1376	bool has_auto_dismiss;
1377	bool auto_dismiss;
1378	};
1379
1380	void qapi_free_BackupCommon(BackupCommon *obj);
1381
1382	struct DriveBackup {
1383	/ Members inherited from BackupCommon: /
1384	bool has_job_id;
1385	char *job_id;
1386	char *device;
1387	MirrorSyncMode sync;
1388	bool has_speed;
1389	int64_t speed;
1390	bool has_bitmap;
1391	char *bitmap;
1392	bool has_bitmap_mode;
1393	BitmapSyncMode bitmap_mode;
1394	bool has_compress;
1395	bool compress;
1396	bool has_on_source_error;
1397	BlockdevOnError on_source_error;
1398	bool has_on_target_error;
1399	BlockdevOnError on_target_error;
1400	bool has_auto_finalize;
1401	bool auto_finalize;
1402	bool has_auto_dismiss;
1403	bool auto_dismiss;
1404	/ Own members: /
1405	char *target;
1406	bool has_format;
1407	char *format;
1408	bool has_mode;
1409	NewImageMode mode;
1410	};
1411
1412	static inline BackupCommon qapi_DriveBackup_base(const* DriveBackup *obj)
1413	{
1414	return (BackupCommon *)obj;
1415	}
1416
1417	void qapi_free_DriveBackup(DriveBackup *obj);
1418
1419	struct BlockdevBackup {
1420	/ Members inherited from BackupCommon: /
1421	bool has_job_id;
1422	char *job_id;
1423	char *device;
1424	MirrorSyncMode sync;
1425	bool has_speed;
1426	int64_t speed;
1427	bool has_bitmap;
1428	char *bitmap;
1429	bool has_bitmap_mode;
1430	BitmapSyncMode bitmap_mode;
1431	bool has_compress;
1432	bool compress;
1433	bool has_on_source_error;
1434	BlockdevOnError on_source_error;
1435	bool has_on_target_error;
1436	BlockdevOnError on_target_error;
1437	bool has_auto_finalize;
1438	bool auto_finalize;
1439	bool has_auto_dismiss;
1440	bool auto_dismiss;
1441	/ Own members: /
1442	char *target;
1443	};
1444
1445	static inline BackupCommon qapi_BlockdevBackup_base(const* BlockdevBackup *obj)
1446	{
1447	return (BackupCommon *)obj;
1448	}
1449
1450	void qapi_free_BlockdevBackup(BlockdevBackup *obj);
1451
1452	struct q_obj_change_backing_file_arg {
1453	char *device;
1454	char *image_node_name;
1455	char *backing_file;
1456	};
1457
1458	struct q_obj_block_commit_arg {
1459	bool has_job_id;
1460	char *job_id;
1461	char *device;
1462	bool has_base_node;
1463	char *base_node;
1464	bool has_base;
1465	char *base;
1466	bool has_top_node;
1467	char *top_node;
1468	bool has_top;
1469	char *top;
1470	bool has_backing_file;
1471	char *backing_file;
1472	bool has_speed;
1473	int64_t speed;
1474	bool has_filter_node_name;
1475	char *filter_node_name;
1476	bool has_auto_finalize;
1477	bool auto_finalize;
1478	bool has_auto_dismiss;
1479	bool auto_dismiss;
1480	};
1481
1482	struct BlockDeviceInfoList {
1483	BlockDeviceInfoList *next;
1484	BlockDeviceInfo *value;
1485	};
1486
1487	void qapi_free_BlockDeviceInfoList(BlockDeviceInfoList *obj);
1488
1489	struct XDbgBlockGraphNode {
1490	uint64_t id;
1491	XDbgBlockGraphNodeType type;
1492	char *name;
1493	};
1494
1495	void qapi_free_XDbgBlockGraphNode(XDbgBlockGraphNode *obj);
1496
1497	struct BlockPermissionList {
1498	BlockPermissionList *next;
1499	BlockPermission value;
1500	};
1501
1502	void qapi_free_BlockPermissionList(BlockPermissionList *obj);
1503
1504	struct XDbgBlockGraphEdge {
1505	uint64_t parent;
1506	uint64_t child;
1507	char *name;
1508	BlockPermissionList *perm;
1509	BlockPermissionList *shared_perm;
1510	};
1511
1512	void qapi_free_XDbgBlockGraphEdge(XDbgBlockGraphEdge *obj);
1513
1514	struct XDbgBlockGraphNodeList {
1515	XDbgBlockGraphNodeList *next;
1516	XDbgBlockGraphNode *value;
1517	};
1518
1519	void qapi_free_XDbgBlockGraphNodeList(XDbgBlockGraphNodeList *obj);
1520
1521	struct XDbgBlockGraphEdgeList {
1522	XDbgBlockGraphEdgeList *next;
1523	XDbgBlockGraphEdge *value;
1524	};
1525
1526	void qapi_free_XDbgBlockGraphEdgeList(XDbgBlockGraphEdgeList *obj);
1527
1528	struct XDbgBlockGraph {
1529	XDbgBlockGraphNodeList *nodes;
1530	XDbgBlockGraphEdgeList *edges;
1531	};
1532
1533	void qapi_free_XDbgBlockGraph(XDbgBlockGraph *obj);
1534
1535	struct DriveMirror {
1536	bool has_job_id;
1537	char *job_id;
1538	char *device;
1539	char *target;
1540	bool has_format;
1541	char *format;
1542	bool has_node_name;
1543	char *node_name;
1544	bool has_replaces;
1545	char *replaces;
1546	MirrorSyncMode sync;
1547	bool has_mode;
1548	NewImageMode mode;
1549	bool has_speed;
1550	int64_t speed;
1551	bool has_granularity;
1552	uint32_t granularity;
1553	bool has_buf_size;
1554	int64_t buf_size;
1555	bool has_on_source_error;
1556	BlockdevOnError on_source_error;
1557	bool has_on_target_error;
1558	BlockdevOnError on_target_error;
1559	bool has_unmap;
1560	bool unmap;
1561	bool has_copy_mode;
1562	MirrorCopyMode copy_mode;
1563	bool has_auto_finalize;
1564	bool auto_finalize;
1565	bool has_auto_dismiss;
1566	bool auto_dismiss;
1567	};
1568
1569	void qapi_free_DriveMirror(DriveMirror *obj);
1570
1571	struct BlockDirtyBitmap {
1572	char *node;
1573	char *name;
1574	};
1575
1576	void qapi_free_BlockDirtyBitmap(BlockDirtyBitmap *obj);
1577
1578	struct BlockDirtyBitmapAdd {
1579	char *node;
1580	char *name;
1581	bool has_granularity;
1582	uint32_t granularity;
1583	bool has_persistent;
1584	bool persistent;
1585	bool has_autoload;
1586	bool autoload;
1587	bool has_disabled;
1588	bool disabled;
1589	};
1590
1591	void qapi_free_BlockDirtyBitmapAdd(BlockDirtyBitmapAdd *obj);
1592
1593	struct BlockDirtyBitmapMergeSource {
1594	QType type;
1595	union { / union tag is @type /
1596	char *local;
1597	BlockDirtyBitmap external;
1598	} u;
1599	};
1600
1601	void qapi_free_BlockDirtyBitmapMergeSource(BlockDirtyBitmapMergeSource *obj);
1602
1603	struct BlockDirtyBitmapMergeSourceList {
1604	BlockDirtyBitmapMergeSourceList *next;
1605	BlockDirtyBitmapMergeSource *value;
1606	};
1607
1608	void qapi_free_BlockDirtyBitmapMergeSourceList(BlockDirtyBitmapMergeSourceList *obj);
1609
1610	struct BlockDirtyBitmapMerge {
1611	char *node;
1612	char *target;
1613	BlockDirtyBitmapMergeSourceList *bitmaps;
1614	};
1615
1616	void qapi_free_BlockDirtyBitmapMerge(BlockDirtyBitmapMerge *obj);
1617
1618	struct BlockDirtyBitmapSha256 {
1619	char *sha256;
1620	};
1621
1622	void qapi_free_BlockDirtyBitmapSha256(BlockDirtyBitmapSha256 *obj);
1623
1624	struct q_obj_blockdev_mirror_arg {
1625	bool has_job_id;
1626	char *job_id;
1627	char *device;
1628	char *target;
1629	bool has_replaces;
1630	char *replaces;
1631	MirrorSyncMode sync;
1632	bool has_speed;
1633	int64_t speed;
1634	bool has_granularity;
1635	uint32_t granularity;
1636	bool has_buf_size;
1637	int64_t buf_size;
1638	bool has_on_source_error;
1639	BlockdevOnError on_source_error;
1640	bool has_on_target_error;
1641	BlockdevOnError on_target_error;
1642	bool has_filter_node_name;
1643	char *filter_node_name;
1644	bool has_copy_mode;
1645	MirrorCopyMode copy_mode;
1646	bool has_auto_finalize;
1647	bool auto_finalize;
1648	bool has_auto_dismiss;
1649	bool auto_dismiss;
1650	};
1651
1652	struct BlockIOThrottle {
1653	bool has_device;
1654	char *device;
1655	bool has_id;
1656	char *id;
1657	int64_t bps;
1658	int64_t bps_rd;
1659	int64_t bps_wr;
1660	int64_t iops;
1661	int64_t iops_rd;
1662	int64_t iops_wr;
1663	bool has_bps_max;
1664	int64_t bps_max;
1665	bool has_bps_rd_max;
1666	int64_t bps_rd_max;
1667	bool has_bps_wr_max;
1668	int64_t bps_wr_max;
1669	bool has_iops_max;
1670	int64_t iops_max;
1671	bool has_iops_rd_max;
1672	int64_t iops_rd_max;
1673	bool has_iops_wr_max;
1674	int64_t iops_wr_max;
1675	bool has_bps_max_length;
1676	int64_t bps_max_length;
1677	bool has_bps_rd_max_length;
1678	int64_t bps_rd_max_length;
1679	bool has_bps_wr_max_length;
1680	int64_t bps_wr_max_length;
1681	bool has_iops_max_length;
1682	int64_t iops_max_length;
1683	bool has_iops_rd_max_length;
1684	int64_t iops_rd_max_length;
1685	bool has_iops_wr_max_length;
1686	int64_t iops_wr_max_length;
1687	bool has_iops_size;
1688	int64_t iops_size;
1689	bool has_group;
1690	char *group;
1691	};
1692
1693	void qapi_free_BlockIOThrottle(BlockIOThrottle *obj);
1694
1695	struct ThrottleLimits {
1696	bool has_iops_total;
1697	int64_t iops_total;
1698	bool has_iops_total_max;
1699	int64_t iops_total_max;
1700	bool has_iops_total_max_length;
1701	int64_t iops_total_max_length;
1702	bool has_iops_read;
1703	int64_t iops_read;
1704	bool has_iops_read_max;
1705	int64_t iops_read_max;
1706	bool has_iops_read_max_length;
1707	int64_t iops_read_max_length;
1708	bool has_iops_write;
1709	int64_t iops_write;
1710	bool has_iops_write_max;
1711	int64_t iops_write_max;
1712	bool has_iops_write_max_length;
1713	int64_t iops_write_max_length;
1714	bool has_bps_total;
1715	int64_t bps_total;
1716	bool has_bps_total_max;
1717	int64_t bps_total_max;
1718	bool has_bps_total_max_length;
1719	int64_t bps_total_max_length;
1720	bool has_bps_read;
1721	int64_t bps_read;
1722	bool has_bps_read_max;
1723	int64_t bps_read_max;
1724	bool has_bps_read_max_length;
1725	int64_t bps_read_max_length;
1726	bool has_bps_write;
1727	int64_t bps_write;
1728	bool has_bps_write_max;
1729	int64_t bps_write_max;
1730	bool has_bps_write_max_length;
1731	int64_t bps_write_max_length;
1732	bool has_iops_size;
1733	int64_t iops_size;
1734	};
1735
1736	void qapi_free_ThrottleLimits(ThrottleLimits *obj);
1737
1738	struct q_obj_block_stream_arg {
1739	bool has_job_id;
1740	char *job_id;
1741	char *device;
1742	bool has_base;
1743	char *base;
1744	bool has_base_node;
1745	char *base_node;
1746	bool has_backing_file;
1747	char *backing_file;
1748	bool has_speed;
1749	int64_t speed;
1750	bool has_on_error;
1751	BlockdevOnError on_error;
1752	bool has_auto_finalize;
1753	bool auto_finalize;
1754	bool has_auto_dismiss;
1755	bool auto_dismiss;
1756	};
1757
1758	struct q_obj_block_job_set_speed_arg {
1759	char *device;
1760	int64_t speed;
1761	};
1762
1763	struct q_obj_block_job_cancel_arg {
1764	char *device;
1765	bool has_force;
1766	bool force;
1767	};
1768
1769	struct q_obj_block_job_pause_arg {
1770	char *device;
1771	};
1772
1773	struct q_obj_block_job_resume_arg {
1774	char *device;
1775	};
1776
1777	struct q_obj_block_job_complete_arg {
1778	char *device;
1779	};
1780
1781	struct q_obj_block_job_dismiss_arg {
1782	char *id;
1783	};
1784
1785	struct q_obj_block_job_finalize_arg {
1786	char *id;
1787	};
1788
1789	struct BlockdevCacheOptions {
1790	bool has_direct;
1791	bool direct;
1792	bool has_no_flush;
1793	bool no_flush;
1794	};
1795
1796	void qapi_free_BlockdevCacheOptions(BlockdevCacheOptions *obj);
1797
1798	struct BlockdevOptionsFile {
1799	char *filename;
1800	bool has_pr_manager;
1801	char *pr_manager;
1802	bool has_locking;
1803	OnOffAuto locking;
1804	bool has_aio;
1805	BlockdevAioOptions aio;
1806	#if defined(CONFIG_LINUX)
1807	bool has_drop_cache;
1808	bool drop_cache;
1809	#endif /* defined(CONFIG_LINUX) */
1810	bool has_x_check_cache_dropped;
1811	bool x_check_cache_dropped;
1812	};
1813
1814	void qapi_free_BlockdevOptionsFile(BlockdevOptionsFile *obj);
1815
1816	struct BlockdevOptionsNull {
1817	bool has_size;
1818	int64_t size;
1819	bool has_latency_ns;
1820	uint64_t latency_ns;
1821	bool has_read_zeroes;
1822	bool read_zeroes;
1823	};
1824
1825	void qapi_free_BlockdevOptionsNull(BlockdevOptionsNull *obj);
1826
1827	struct BlockdevOptionsNVMe {
1828	char *device;
1829	int64_t q_namespace;
1830	};
1831
1832	void qapi_free_BlockdevOptionsNVMe(BlockdevOptionsNVMe *obj);
1833
1834	struct BlockdevOptionsVVFAT {
1835	char *dir;
1836	bool has_fat_type;
1837	int64_t fat_type;
1838	bool has_floppy;
1839	bool floppy;
1840	bool has_label;
1841	char *label;
1842	bool has_rw;
1843	bool rw;
1844	};
1845
1846	void qapi_free_BlockdevOptionsVVFAT(BlockdevOptionsVVFAT *obj);
1847
1848	struct BlockdevOptionsGenericFormat {
1849	BlockdevRef *file;
1850	};
1851
1852	void qapi_free_BlockdevOptionsGenericFormat(BlockdevOptionsGenericFormat *obj);
1853
1854	struct BlockdevOptionsLUKS {
1855	/ Members inherited from BlockdevOptionsGenericFormat: /
1856	BlockdevRef *file;
1857	/ Own members: /
1858	bool has_key_secret;
1859	char *key_secret;
1860	};
1861
1862	static inline BlockdevOptionsGenericFormat qapi_BlockdevOptionsLUKS_base(const* BlockdevOptionsLUKS *obj)
1863	{
1864	return (BlockdevOptionsGenericFormat *)obj;
1865	}
1866
1867	void qapi_free_BlockdevOptionsLUKS(BlockdevOptionsLUKS *obj);
1868
1869	struct BlockdevOptionsGenericCOWFormat {
1870	/ Members inherited from BlockdevOptionsGenericFormat: /
1871	BlockdevRef *file;
1872	/ Own members: /
1873	bool has_backing;
1874	BlockdevRefOrNull *backing;
1875	};
1876
1877	static inline BlockdevOptionsGenericFormat qapi_BlockdevOptionsGenericCOWFormat_base(const* BlockdevOptionsGenericCOWFormat *obj)
1878	{
1879	return (BlockdevOptionsGenericFormat *)obj;
1880	}
1881
1882	void qapi_free_BlockdevOptionsGenericCOWFormat(BlockdevOptionsGenericCOWFormat *obj);
1883
1884	struct Qcow2OverlapCheckFlags {
1885	bool has_q_template;
1886	Qcow2OverlapCheckMode q_template;
1887	bool has_main_header;
1888	bool main_header;
1889	bool has_active_l1;
1890	bool active_l1;
1891	bool has_active_l2;
1892	bool active_l2;
1893	bool has_refcount_table;
1894	bool refcount_table;
1895	bool has_refcount_block;
1896	bool refcount_block;
1897	bool has_snapshot_table;
1898	bool snapshot_table;
1899	bool has_inactive_l1;
1900	bool inactive_l1;
1901	bool has_inactive_l2;
1902	bool inactive_l2;
1903	bool has_bitmap_directory;
1904	bool bitmap_directory;
1905	};
1906
1907	void qapi_free_Qcow2OverlapCheckFlags(Qcow2OverlapCheckFlags *obj);
1908
1909	struct Qcow2OverlapChecks {
1910	QType type;
1911	union { / union tag is @type /
1912	Qcow2OverlapCheckFlags flags;
1913	Qcow2OverlapCheckMode mode;
1914	} u;
1915	};
1916
1917	void qapi_free_Qcow2OverlapChecks(Qcow2OverlapChecks *obj);
1918
1919	struct q_obj_BlockdevQcowEncryption_base {
1920	BlockdevQcowEncryptionFormat format;
1921	};
1922
1923	struct BlockdevQcowEncryption {
1924	BlockdevQcowEncryptionFormat format;
1925	union { / union tag is @format /
1926	QCryptoBlockOptionsQCow aes;
1927	} u;
1928	};
1929
1930	void qapi_free_BlockdevQcowEncryption(BlockdevQcowEncryption *obj);
1931
1932	struct BlockdevOptionsQcow {
1933	/ Members inherited from BlockdevOptionsGenericCOWFormat: /
1934	BlockdevRef *file;
1935	bool has_backing;
1936	BlockdevRefOrNull *backing;
1937	/ Own members: /
1938	bool has_encrypt;
1939	BlockdevQcowEncryption *encrypt;
1940	};
1941
1942	static inline BlockdevOptionsGenericCOWFormat qapi_BlockdevOptionsQcow_base(const* BlockdevOptionsQcow *obj)
1943	{
1944	return (BlockdevOptionsGenericCOWFormat *)obj;
1945	}
1946
1947	void qapi_free_BlockdevOptionsQcow(BlockdevOptionsQcow *obj);
1948
1949	struct q_obj_BlockdevQcow2Encryption_base {
1950	BlockdevQcow2EncryptionFormat format;
1951	};
1952
1953	struct BlockdevQcow2Encryption {
1954	BlockdevQcow2EncryptionFormat format;
1955	union { / union tag is @format /
1956	QCryptoBlockOptionsQCow aes;
1957	QCryptoBlockOptionsLUKS luks;
1958	} u;
1959	};
1960
1961	void qapi_free_BlockdevQcow2Encryption(BlockdevQcow2Encryption *obj);
1962
1963	struct BlockdevOptionsQcow2 {
1964	/ Members inherited from BlockdevOptionsGenericCOWFormat: /
1965	BlockdevRef *file;
1966	bool has_backing;
1967	BlockdevRefOrNull *backing;
1968	/ Own members: /
1969	bool has_lazy_refcounts;
1970	bool lazy_refcounts;
1971	bool has_pass_discard_request;
1972	bool pass_discard_request;
1973	bool has_pass_discard_snapshot;
1974	bool pass_discard_snapshot;
1975	bool has_pass_discard_other;
1976	bool pass_discard_other;
1977	bool has_overlap_check;
1978	Qcow2OverlapChecks *overlap_check;
1979	bool has_cache_size;
1980	int64_t cache_size;
1981	bool has_l2_cache_size;
1982	int64_t l2_cache_size;
1983	bool has_l2_cache_entry_size;
1984	int64_t l2_cache_entry_size;
1985	bool has_refcount_cache_size;
1986	int64_t refcount_cache_size;
1987	bool has_cache_clean_interval;
1988	int64_t cache_clean_interval;
1989	bool has_encrypt;
1990	BlockdevQcow2Encryption *encrypt;
1991	bool has_data_file;
1992	BlockdevRef *data_file;
1993	};
1994
1995	static inline BlockdevOptionsGenericCOWFormat qapi_BlockdevOptionsQcow2_base(const* BlockdevOptionsQcow2 *obj)
1996	{
1997	return (BlockdevOptionsGenericCOWFormat *)obj;
1998	}
1999
2000	void qapi_free_BlockdevOptionsQcow2(BlockdevOptionsQcow2 *obj);
2001
2002	struct SshHostKeyHash {
2003	SshHostKeyCheckHashType type;
2004	char *hash;
2005	};
2006
2007	void qapi_free_SshHostKeyHash(SshHostKeyHash *obj);
2008
2009	struct q_obj_SshHostKeyCheck_base {
2010	SshHostKeyCheckMode mode;
2011	};
2012
2013	struct SshHostKeyCheck {
2014	SshHostKeyCheckMode mode;
2015	union { / union tag is @mode /
2016	SshHostKeyHash hash;
2017	} u;
2018	};
2019
2020	void qapi_free_SshHostKeyCheck(SshHostKeyCheck *obj);
2021
2022	struct BlockdevOptionsSsh {
2023	InetSocketAddress *server;
2024	char *path;
2025	bool has_user;
2026	char *user;
2027	bool has_host_key_check;
2028	SshHostKeyCheck *host_key_check;
2029	};
2030
2031	void qapi_free_BlockdevOptionsSsh(BlockdevOptionsSsh *obj);
2032
2033	struct BlkdebugInjectErrorOptions {
2034	BlkdebugEvent event;
2035	bool has_state;
2036	int64_t state;
2037	bool has_iotype;
2038	BlkdebugIOType iotype;
2039	bool has_q_errno;
2040	int64_t q_errno;
2041	bool has_sector;
2042	int64_t sector;
2043	bool has_once;
2044	bool once;
2045	bool has_immediately;
2046	bool immediately;
2047	};
2048
2049	void qapi_free_BlkdebugInjectErrorOptions(BlkdebugInjectErrorOptions *obj);
2050
2051	struct BlkdebugSetStateOptions {
2052	BlkdebugEvent event;
2053	bool has_state;
2054	int64_t state;
2055	int64_t new_state;
2056	};
2057
2058	void qapi_free_BlkdebugSetStateOptions(BlkdebugSetStateOptions *obj);
2059
2060	struct BlkdebugInjectErrorOptionsList {
2061	BlkdebugInjectErrorOptionsList *next;
2062	BlkdebugInjectErrorOptions *value;
2063	};
2064
2065	void qapi_free_BlkdebugInjectErrorOptionsList(BlkdebugInjectErrorOptionsList *obj);
2066
2067	struct BlkdebugSetStateOptionsList {
2068	BlkdebugSetStateOptionsList *next;
2069	BlkdebugSetStateOptions *value;
2070	};
2071
2072	void qapi_free_BlkdebugSetStateOptionsList(BlkdebugSetStateOptionsList *obj);
2073
2074	struct BlockdevOptionsBlkdebug {
2075	BlockdevRef *image;
2076	bool has_config;
2077	char *config;
2078	bool has_align;
2079	int64_t align;
2080	bool has_max_transfer;
2081	int32_t max_transfer;
2082	bool has_opt_write_zero;
2083	int32_t opt_write_zero;
2084	bool has_max_write_zero;
2085	int32_t max_write_zero;
2086	bool has_opt_discard;
2087	int32_t opt_discard;
2088	bool has_max_discard;
2089	int32_t max_discard;
2090	bool has_inject_error;
2091	BlkdebugInjectErrorOptionsList *inject_error;
2092	bool has_set_state;
2093	BlkdebugSetStateOptionsList *set_state;
2094	};
2095
2096	void qapi_free_BlockdevOptionsBlkdebug(BlockdevOptionsBlkdebug *obj);
2097
2098	struct BlockdevOptionsBlklogwrites {
2099	BlockdevRef *file;
2100	BlockdevRef *log;
2101	bool has_log_sector_size;
2102	uint32_t log_sector_size;
2103	bool has_log_append;
2104	bool log_append;
2105	bool has_log_super_update_interval;
2106	uint64_t log_super_update_interval;
2107	};
2108
2109	void qapi_free_BlockdevOptionsBlklogwrites(BlockdevOptionsBlklogwrites *obj);
2110
2111	struct BlockdevOptionsBlkverify {
2112	BlockdevRef *test;
2113	BlockdevRef *raw;
2114	};
2115
2116	void qapi_free_BlockdevOptionsBlkverify(BlockdevOptionsBlkverify *obj);
2117
2118	struct BlockdevRefList {
2119	BlockdevRefList *next;
2120	BlockdevRef *value;
2121	};
2122
2123	void qapi_free_BlockdevRefList(BlockdevRefList *obj);
2124
2125	struct BlockdevOptionsQuorum {
2126	bool has_blkverify;
2127	bool blkverify;
2128	BlockdevRefList *children;
2129	int64_t vote_threshold;
2130	bool has_rewrite_corrupted;
2131	bool rewrite_corrupted;
2132	bool has_read_pattern;
2133	QuorumReadPattern read_pattern;
2134	};
2135
2136	void qapi_free_BlockdevOptionsQuorum(BlockdevOptionsQuorum *obj);
2137
2138	struct BlockdevOptionsGluster {
2139	char *volume;
2140	char *path;
2141	SocketAddressList *server;
2142	bool has_debug;
2143	int64_t debug;
2144	bool has_logfile;
2145	char *logfile;
2146	};
2147
2148	void qapi_free_BlockdevOptionsGluster(BlockdevOptionsGluster *obj);
2149
2150	struct BlockdevOptionsIscsi {
2151	IscsiTransport transport;
2152	char *portal;
2153	char *target;
2154	bool has_lun;
2155	int64_t lun;
2156	bool has_user;
2157	char *user;
2158	bool has_password_secret;
2159	char *password_secret;
2160	bool has_initiator_name;
2161	char *initiator_name;
2162	bool has_header_digest;
2163	IscsiHeaderDigest header_digest;
2164	bool has_timeout;
2165	int64_t timeout;
2166	};
2167
2168	void qapi_free_BlockdevOptionsIscsi(BlockdevOptionsIscsi *obj);
2169
2170	struct RbdAuthModeList {
2171	RbdAuthModeList *next;
2172	RbdAuthMode value;
2173	};
2174
2175	void qapi_free_RbdAuthModeList(RbdAuthModeList *obj);
2176
2177	struct BlockdevOptionsRbd {
2178	char *pool;
2179	char *image;
2180	bool has_conf;
2181	char *conf;
2182	bool has_snapshot;
2183	char *snapshot;
2184	bool has_user;
2185	char *user;
2186	bool has_auth_client_required;
2187	RbdAuthModeList *auth_client_required;
2188	bool has_key_secret;
2189	char *key_secret;
2190	bool has_server;
2191	InetSocketAddressBaseList *server;
2192	};
2193
2194	void qapi_free_BlockdevOptionsRbd(BlockdevOptionsRbd *obj);
2195
2196	struct BlockdevOptionsSheepdog {
2197	SocketAddress *server;
2198	char *vdi;
2199	bool has_snap_id;
2200	uint32_t snap_id;
2201	bool has_tag;
2202	char *tag;
2203	};
2204
2205	void qapi_free_BlockdevOptionsSheepdog(BlockdevOptionsSheepdog *obj);
2206
2207	#if defined(CONFIG_REPLICATION)
2208	struct BlockdevOptionsReplication {
2209	/ Members inherited from BlockdevOptionsGenericFormat: /
2210	BlockdevRef *file;
2211	/ Own members: /
2212	ReplicationMode mode;
2213	bool has_top_id;
2214	char *top_id;
2215	};
2216	#endif /* defined(CONFIG_REPLICATION) */
2217
2218	#if defined(CONFIG_REPLICATION)
2219	static inline BlockdevOptionsGenericFormat qapi_BlockdevOptionsReplication_base(const* BlockdevOptionsReplication *obj)
2220	{
2221	return (BlockdevOptionsGenericFormat *)obj;
2222	}
2223
2224	void qapi_free_BlockdevOptionsReplication(BlockdevOptionsReplication *obj);
2225	#endif /* defined(CONFIG_REPLICATION) */
2226
2227	struct NFSServer {
2228	NFSTransport type;
2229	char *host;
2230	};
2231
2232	void qapi_free_NFSServer(NFSServer *obj);
2233
2234	struct BlockdevOptionsNfs {
2235	NFSServer *server;
2236	char *path;
2237	bool has_user;
2238	int64_t user;
2239	bool has_group;
2240	int64_t group;
2241	bool has_tcp_syn_count;
2242	int64_t tcp_syn_count;
2243	bool has_readahead_size;
2244	int64_t readahead_size;
2245	bool has_page_cache_size;
2246	int64_t page_cache_size;
2247	bool has_debug;
2248	int64_t debug;
2249	};
2250
2251	void qapi_free_BlockdevOptionsNfs(BlockdevOptionsNfs *obj);
2252
2253	struct BlockdevOptionsCurlBase {
2254	char *url;
2255	bool has_readahead;
2256	int64_t readahead;
2257	bool has_timeout;
2258	int64_t timeout;
2259	bool has_username;
2260	char *username;
2261	bool has_password_secret;
2262	char *password_secret;
2263	bool has_proxy_username;
2264	char *proxy_username;
2265	bool has_proxy_password_secret;
2266	char *proxy_password_secret;
2267	};
2268
2269	void qapi_free_BlockdevOptionsCurlBase(BlockdevOptionsCurlBase *obj);
2270
2271	struct BlockdevOptionsCurlHttp {
2272	/ Members inherited from BlockdevOptionsCurlBase: /
2273	char *url;
2274	bool has_readahead;
2275	int64_t readahead;
2276	bool has_timeout;
2277	int64_t timeout;
2278	bool has_username;
2279	char *username;
2280	bool has_password_secret;
2281	char *password_secret;
2282	bool has_proxy_username;
2283	char *proxy_username;
2284	bool has_proxy_password_secret;
2285	char *proxy_password_secret;
2286	/ Own members: /
2287	bool has_cookie;
2288	char *cookie;
2289	bool has_cookie_secret;
2290	char *cookie_secret;
2291	};
2292
2293	static inline BlockdevOptionsCurlBase qapi_BlockdevOptionsCurlHttp_base(const* BlockdevOptionsCurlHttp *obj)
2294	{
2295	return (BlockdevOptionsCurlBase *)obj;
2296	}
2297
2298	void qapi_free_BlockdevOptionsCurlHttp(BlockdevOptionsCurlHttp *obj);
2299
2300	struct BlockdevOptionsCurlHttps {
2301	/ Members inherited from BlockdevOptionsCurlBase: /
2302	char *url;
2303	bool has_readahead;
2304	int64_t readahead;
2305	bool has_timeout;
2306	int64_t timeout;
2307	bool has_username;
2308	char *username;
2309	bool has_password_secret;
2310	char *password_secret;
2311	bool has_proxy_username;
2312	char *proxy_username;
2313	bool has_proxy_password_secret;
2314	char *proxy_password_secret;
2315	/ Own members: /
2316	bool has_cookie;
2317	char *cookie;
2318	bool has_sslverify;
2319	bool sslverify;
2320	bool has_cookie_secret;
2321	char *cookie_secret;
2322	};
2323
2324	static inline BlockdevOptionsCurlBase qapi_BlockdevOptionsCurlHttps_base(const* BlockdevOptionsCurlHttps *obj)
2325	{
2326	return (BlockdevOptionsCurlBase *)obj;
2327	}
2328
2329	void qapi_free_BlockdevOptionsCurlHttps(BlockdevOptionsCurlHttps *obj);
2330
2331	struct BlockdevOptionsCurlFtp {
2332	/ Members inherited from BlockdevOptionsCurlBase: /
2333	char *url;
2334	bool has_readahead;
2335	int64_t readahead;
2336	bool has_timeout;
2337	int64_t timeout;
2338	bool has_username;
2339	char *username;
2340	bool has_password_secret;
2341	char *password_secret;
2342	bool has_proxy_username;
2343	char *proxy_username;
2344	bool has_proxy_password_secret;
2345	char *proxy_password_secret;
2346	/ Own members: /
2347	};
2348
2349	static inline BlockdevOptionsCurlBase qapi_BlockdevOptionsCurlFtp_base(const* BlockdevOptionsCurlFtp *obj)
2350	{
2351	return (BlockdevOptionsCurlBase *)obj;
2352	}
2353
2354	void qapi_free_BlockdevOptionsCurlFtp(BlockdevOptionsCurlFtp *obj);
2355
2356	struct BlockdevOptionsCurlFtps {
2357	/ Members inherited from BlockdevOptionsCurlBase: /
2358	char *url;
2359	bool has_readahead;
2360	int64_t readahead;
2361	bool has_timeout;
2362	int64_t timeout;
2363	bool has_username;
2364	char *username;
2365	bool has_password_secret;
2366	char *password_secret;
2367	bool has_proxy_username;
2368	char *proxy_username;
2369	bool has_proxy_password_secret;
2370	char *proxy_password_secret;
2371	/ Own members: /
2372	bool has_sslverify;
2373	bool sslverify;
2374	};
2375
2376	static inline BlockdevOptionsCurlBase qapi_BlockdevOptionsCurlFtps_base(const* BlockdevOptionsCurlFtps *obj)
2377	{
2378	return (BlockdevOptionsCurlBase *)obj;
2379	}
2380
2381	void qapi_free_BlockdevOptionsCurlFtps(BlockdevOptionsCurlFtps *obj);
2382
2383	struct BlockdevOptionsNbd {
2384	SocketAddress *server;
2385	bool has_export;
2386	char *export;
2387	bool has_tls_creds;
2388	char *tls_creds;
2389	bool has_x_dirty_bitmap;
2390	char *x_dirty_bitmap;
2391	bool has_reconnect_delay;
2392	uint32_t reconnect_delay;
2393	};
2394
2395	void qapi_free_BlockdevOptionsNbd(BlockdevOptionsNbd *obj);
2396
2397	struct BlockdevOptionsRaw {
2398	/ Members inherited from BlockdevOptionsGenericFormat: /
2399	BlockdevRef *file;
2400	/ Own members: /
2401	bool has_offset;
2402	int64_t offset;
2403	bool has_size;
2404	int64_t size;
2405	};
2406
2407	static inline BlockdevOptionsGenericFormat qapi_BlockdevOptionsRaw_base(const* BlockdevOptionsRaw *obj)
2408	{
2409	return (BlockdevOptionsGenericFormat *)obj;
2410	}
2411
2412	void qapi_free_BlockdevOptionsRaw(BlockdevOptionsRaw *obj);
2413
2414	struct BlockdevOptionsVxHS {
2415	char *vdisk_id;
2416	InetSocketAddressBase *server;
2417	bool has_tls_creds;
2418	char *tls_creds;
2419	};
2420
2421	void qapi_free_BlockdevOptionsVxHS(BlockdevOptionsVxHS *obj);
2422
2423	struct BlockdevOptionsThrottle {
2424	char *throttle_group;
2425	BlockdevRef *file;
2426	};
2427
2428	void qapi_free_BlockdevOptionsThrottle(BlockdevOptionsThrottle *obj);
2429
2430	struct q_obj_BlockdevOptions_base {
2431	BlockdevDriver driver;
2432	bool has_node_name;
2433	char *node_name;
2434	bool has_discard;
2435	BlockdevDiscardOptions discard;
2436	bool has_cache;
2437	BlockdevCacheOptions *cache;
2438	bool has_read_only;
2439	bool read_only;
2440	bool has_auto_read_only;
2441	bool auto_read_only;
2442	bool has_force_share;
2443	bool force_share;
2444	bool has_detect_zeroes;
2445	BlockdevDetectZeroesOptions detect_zeroes;
2446	};
2447
2448	struct BlockdevOptions {
2449	BlockdevDriver driver;
2450	bool has_node_name;
2451	char *node_name;
2452	bool has_discard;
2453	BlockdevDiscardOptions discard;
2454	bool has_cache;
2455	BlockdevCacheOptions *cache;
2456	bool has_read_only;
2457	bool read_only;
2458	bool has_auto_read_only;
2459	bool auto_read_only;
2460	bool has_force_share;
2461	bool force_share;
2462	bool has_detect_zeroes;
2463	BlockdevDetectZeroesOptions detect_zeroes;
2464	union { / union tag is @driver /
2465	BlockdevOptionsBlkdebug blkdebug;
2466	BlockdevOptionsBlklogwrites blklogwrites;
2467	BlockdevOptionsBlkverify blkverify;
2468	BlockdevOptionsGenericFormat bochs;
2469	BlockdevOptionsGenericFormat cloop;
2470	BlockdevOptionsGenericFormat copy_on_read;
2471	BlockdevOptionsGenericFormat dmg;
2472	BlockdevOptionsFile file;
2473	BlockdevOptionsCurlFtp ftp;
2474	BlockdevOptionsCurlFtps ftps;
2475	BlockdevOptionsGluster gluster;
2476	BlockdevOptionsFile host_cdrom;
2477	BlockdevOptionsFile host_device;
2478	BlockdevOptionsCurlHttp http;
2479	BlockdevOptionsCurlHttps https;
2480	BlockdevOptionsIscsi iscsi;
2481	BlockdevOptionsLUKS luks;
2482	BlockdevOptionsNbd nbd;
2483	BlockdevOptionsNfs nfs;
2484	BlockdevOptionsNull null_aio;
2485	BlockdevOptionsNull null_co;
2486	BlockdevOptionsNVMe nvme;
2487	BlockdevOptionsGenericFormat parallels;
2488	BlockdevOptionsQcow2 qcow2;
2489	BlockdevOptionsQcow qcow;
2490	BlockdevOptionsGenericCOWFormat qed;
2491	BlockdevOptionsQuorum quorum;
2492	BlockdevOptionsRaw raw;
2493	BlockdevOptionsRbd rbd;
2494	#if defined(CONFIG_REPLICATION)
2495	BlockdevOptionsReplication replication;
2496	#endif /* defined(CONFIG_REPLICATION) */
2497	BlockdevOptionsSheepdog sheepdog;
2498	BlockdevOptionsSsh ssh;
2499	BlockdevOptionsThrottle throttle;
2500	BlockdevOptionsGenericFormat vdi;
2501	BlockdevOptionsGenericFormat vhdx;
2502	BlockdevOptionsGenericCOWFormat vmdk;
2503	BlockdevOptionsGenericFormat vpc;
2504	BlockdevOptionsVVFAT vvfat;
2505	BlockdevOptionsVxHS vxhs;
2506	} u;
2507	};
2508
2509	void qapi_free_BlockdevOptions(BlockdevOptions *obj);
2510
2511	struct BlockdevRef {
2512	QType type;
2513	union { / union tag is @type /
2514	BlockdevOptions definition;
2515	char *reference;
2516	} u;
2517	};
2518
2519	void qapi_free_BlockdevRef(BlockdevRef *obj);
2520
2521	struct BlockdevRefOrNull {
2522	QType type;
2523	union { / union tag is @type /
2524	BlockdevOptions definition;
2525	char *reference;
2526	QNull *null;
2527	} u;
2528	};
2529
2530	void qapi_free_BlockdevRefOrNull(BlockdevRefOrNull *obj);
2531
2532	struct q_obj_blockdev_del_arg {
2533	char *node_name;
2534	};
2535
2536	struct BlockdevCreateOptionsFile {
2537	char *filename;
2538	uint64_t size;
2539	bool has_preallocation;
2540	PreallocMode preallocation;
2541	bool has_nocow;
2542	bool nocow;
2543	};
2544
2545	void qapi_free_BlockdevCreateOptionsFile(BlockdevCreateOptionsFile *obj);
2546
2547	struct BlockdevCreateOptionsGluster {
2548	BlockdevOptionsGluster *location;
2549	uint64_t size;
2550	bool has_preallocation;
2551	PreallocMode preallocation;
2552	};
2553
2554	void qapi_free_BlockdevCreateOptionsGluster(BlockdevCreateOptionsGluster *obj);
2555
2556	struct BlockdevCreateOptionsLUKS {
2557	/ Members inherited from QCryptoBlockCreateOptionsLUKS: /
2558	bool has_key_secret;
2559	char *key_secret;
2560	bool has_cipher_alg;
2561	QCryptoCipherAlgorithm cipher_alg;
2562	bool has_cipher_mode;
2563	QCryptoCipherMode cipher_mode;
2564	bool has_ivgen_alg;
2565	QCryptoIVGenAlgorithm ivgen_alg;
2566	bool has_ivgen_hash_alg;
2567	QCryptoHashAlgorithm ivgen_hash_alg;
2568	bool has_hash_alg;
2569	QCryptoHashAlgorithm hash_alg;
2570	bool has_iter_time;
2571	int64_t iter_time;
2572	/ Own members: /
2573	BlockdevRef *file;
2574	uint64_t size;
2575	bool has_preallocation;
2576	PreallocMode preallocation;
2577	};
2578
2579	static inline QCryptoBlockCreateOptionsLUKS qapi_BlockdevCreateOptionsLUKS_base(const* BlockdevCreateOptionsLUKS *obj)
2580	{
2581	return (QCryptoBlockCreateOptionsLUKS *)obj;
2582	}
2583
2584	void qapi_free_BlockdevCreateOptionsLUKS(BlockdevCreateOptionsLUKS *obj);
2585
2586	struct BlockdevCreateOptionsNfs {
2587	BlockdevOptionsNfs *location;
2588	uint64_t size;
2589	};
2590
2591	void qapi_free_BlockdevCreateOptionsNfs(BlockdevCreateOptionsNfs *obj);
2592
2593	struct BlockdevCreateOptionsParallels {
2594	BlockdevRef *file;
2595	uint64_t size;
2596	bool has_cluster_size;
2597	uint64_t cluster_size;
2598	};
2599
2600	void qapi_free_BlockdevCreateOptionsParallels(BlockdevCreateOptionsParallels *obj);
2601
2602	struct BlockdevCreateOptionsQcow {
2603	BlockdevRef *file;
2604	uint64_t size;
2605	bool has_backing_file;
2606	char *backing_file;
2607	bool has_encrypt;
2608	QCryptoBlockCreateOptions *encrypt;
2609	};
2610
2611	void qapi_free_BlockdevCreateOptionsQcow(BlockdevCreateOptionsQcow *obj);
2612
2613	struct BlockdevCreateOptionsQcow2 {
2614	BlockdevRef *file;
2615	bool has_data_file;
2616	BlockdevRef *data_file;
2617	bool has_data_file_raw;
2618	bool data_file_raw;
2619	uint64_t size;
2620	bool has_version;
2621	BlockdevQcow2Version version;
2622	bool has_backing_file;
2623	char *backing_file;
2624	bool has_backing_fmt;
2625	BlockdevDriver backing_fmt;
2626	bool has_encrypt;
2627	QCryptoBlockCreateOptions *encrypt;
2628	bool has_cluster_size;
2629	uint64_t cluster_size;
2630	bool has_preallocation;
2631	PreallocMode preallocation;
2632	bool has_lazy_refcounts;
2633	bool lazy_refcounts;
2634	bool has_refcount_bits;
2635	int64_t refcount_bits;
2636	};
2637
2638	void qapi_free_BlockdevCreateOptionsQcow2(BlockdevCreateOptionsQcow2 *obj);
2639
2640	struct BlockdevCreateOptionsQed {
2641	BlockdevRef *file;
2642	uint64_t size;
2643	bool has_backing_file;
2644	char *backing_file;
2645	bool has_backing_fmt;
2646	BlockdevDriver backing_fmt;
2647	bool has_cluster_size;
2648	uint64_t cluster_size;
2649	bool has_table_size;
2650	int64_t table_size;
2651	};
2652
2653	void qapi_free_BlockdevCreateOptionsQed(BlockdevCreateOptionsQed *obj);
2654
2655	struct BlockdevCreateOptionsRbd {
2656	BlockdevOptionsRbd *location;
2657	uint64_t size;
2658	bool has_cluster_size;
2659	uint64_t cluster_size;
2660	};
2661
2662	void qapi_free_BlockdevCreateOptionsRbd(BlockdevCreateOptionsRbd *obj);
2663
2664	struct BlockdevCreateOptionsVmdk {
2665	BlockdevRef *file;
2666	uint64_t size;
2667	bool has_extents;
2668	BlockdevRefList *extents;
2669	bool has_subformat;
2670	BlockdevVmdkSubformat subformat;
2671	bool has_backing_file;
2672	char *backing_file;
2673	bool has_adapter_type;
2674	BlockdevVmdkAdapterType adapter_type;
2675	bool has_hwversion;
2676	char *hwversion;
2677	bool has_zeroed_grain;
2678	bool zeroed_grain;
2679	};
2680
2681	void qapi_free_BlockdevCreateOptionsVmdk(BlockdevCreateOptionsVmdk *obj);
2682
2683	struct SheepdogRedundancyFull {
2684	int64_t copies;
2685	};
2686
2687	void qapi_free_SheepdogRedundancyFull(SheepdogRedundancyFull *obj);
2688
2689	struct SheepdogRedundancyErasureCoded {
2690	int64_t data_strips;
2691	int64_t parity_strips;
2692	};
2693
2694	void qapi_free_SheepdogRedundancyErasureCoded(SheepdogRedundancyErasureCoded *obj);
2695
2696	struct q_obj_SheepdogRedundancy_base {
2697	SheepdogRedundancyType type;
2698	};
2699
2700	struct SheepdogRedundancy {
2701	SheepdogRedundancyType type;
2702	union { / union tag is @type /
2703	SheepdogRedundancyFull full;
2704	SheepdogRedundancyErasureCoded erasure_coded;
2705	} u;
2706	};
2707
2708	void qapi_free_SheepdogRedundancy(SheepdogRedundancy *obj);
2709
2710	struct BlockdevCreateOptionsSheepdog {
2711	BlockdevOptionsSheepdog *location;
2712	uint64_t size;
2713	bool has_backing_file;
2714	char *backing_file;
2715	bool has_preallocation;
2716	PreallocMode preallocation;
2717	bool has_redundancy;
2718	SheepdogRedundancy *redundancy;
2719	bool has_object_size;
2720	uint64_t object_size;
2721	};
2722
2723	void qapi_free_BlockdevCreateOptionsSheepdog(BlockdevCreateOptionsSheepdog *obj);
2724
2725	struct BlockdevCreateOptionsSsh {
2726	BlockdevOptionsSsh *location;
2727	uint64_t size;
2728	};
2729
2730	void qapi_free_BlockdevCreateOptionsSsh(BlockdevCreateOptionsSsh *obj);
2731
2732	struct BlockdevCreateOptionsVdi {
2733	BlockdevRef *file;
2734	uint64_t size;
2735	bool has_preallocation;
2736	PreallocMode preallocation;
2737	};
2738
2739	void qapi_free_BlockdevCreateOptionsVdi(BlockdevCreateOptionsVdi *obj);
2740
2741	struct BlockdevCreateOptionsVhdx {
2742	BlockdevRef *file;
2743	uint64_t size;
2744	bool has_log_size;
2745	uint64_t log_size;
2746	bool has_block_size;
2747	uint64_t block_size;
2748	bool has_subformat;
2749	BlockdevVhdxSubformat subformat;
2750	bool has_block_state_zero;
2751	bool block_state_zero;
2752	};
2753
2754	void qapi_free_BlockdevCreateOptionsVhdx(BlockdevCreateOptionsVhdx *obj);
2755
2756	struct BlockdevCreateOptionsVpc {
2757	BlockdevRef *file;
2758	uint64_t size;
2759	bool has_subformat;
2760	BlockdevVpcSubformat subformat;
2761	bool has_force_size;
2762	bool force_size;
2763	};
2764
2765	void qapi_free_BlockdevCreateOptionsVpc(BlockdevCreateOptionsVpc *obj);
2766
2767	struct q_obj_BlockdevCreateOptions_base {
2768	BlockdevDriver driver;
2769	};
2770
2771	struct BlockdevCreateOptions {
2772	BlockdevDriver driver;
2773	union { / union tag is @driver /
2774	BlockdevCreateOptionsFile file;
2775	BlockdevCreateOptionsGluster gluster;
2776	BlockdevCreateOptionsLUKS luks;
2777	BlockdevCreateOptionsNfs nfs;
2778	BlockdevCreateOptionsParallels parallels;
2779	BlockdevCreateOptionsQcow qcow;
2780	BlockdevCreateOptionsQcow2 qcow2;
2781	BlockdevCreateOptionsQed qed;
2782	BlockdevCreateOptionsRbd rbd;
2783	BlockdevCreateOptionsSheepdog sheepdog;
2784	BlockdevCreateOptionsSsh ssh;
2785	BlockdevCreateOptionsVdi vdi;
2786	BlockdevCreateOptionsVhdx vhdx;
2787	BlockdevCreateOptionsVmdk vmdk;
2788	BlockdevCreateOptionsVpc vpc;
2789	} u;
2790	};
2791
2792	void qapi_free_BlockdevCreateOptions(BlockdevCreateOptions *obj);
2793
2794	struct q_obj_blockdev_create_arg {
2795	char *job_id;
2796	BlockdevCreateOptions *options;
2797	};
2798
2799	struct q_obj_blockdev_open_tray_arg {
2800	bool has_device;
2801	char *device;
2802	bool has_id;
2803	char *id;
2804	bool has_force;
2805	bool force;
2806	};
2807
2808	struct q_obj_blockdev_close_tray_arg {
2809	bool has_device;
2810	char *device;
2811	bool has_id;
2812	char *id;
2813	};
2814
2815	struct q_obj_blockdev_remove_medium_arg {
2816	char *id;
2817	};
2818
2819	struct q_obj_blockdev_insert_medium_arg {
2820	char *id;
2821	char *node_name;
2822	};
2823
2824	struct q_obj_blockdev_change_medium_arg {
2825	bool has_device;
2826	char *device;
2827	bool has_id;
2828	char *id;
2829	char *filename;
2830	bool has_format;
2831	char *format;
2832	bool has_read_only_mode;
2833	BlockdevChangeReadOnlyMode read_only_mode;
2834	};
2835
2836	struct q_obj_BLOCK_IMAGE_CORRUPTED_arg {
2837	char *device;
2838	bool has_node_name;
2839	char *node_name;
2840	char *msg;
2841	bool has_offset;
2842	int64_t offset;
2843	bool has_size;
2844	int64_t size;
2845	bool fatal;
2846	};
2847
2848	struct q_obj_BLOCK_IO_ERROR_arg {
2849	char *device;
2850	bool has_node_name;
2851	char *node_name;
2852	IoOperationType operation;
2853	BlockErrorAction action;
2854	bool has_nospace;
2855	bool nospace;
2856	char *reason;
2857	};
2858
2859	struct q_obj_BLOCK_JOB_COMPLETED_arg {
2860	JobType type;
2861	char *device;
2862	int64_t len;
2863	int64_t offset;
2864	int64_t speed;
2865	bool has_error;
2866	char *error;
2867	};
2868
2869	struct q_obj_BLOCK_JOB_CANCELLED_arg {
2870	JobType type;
2871	char *device;
2872	int64_t len;
2873	int64_t offset;
2874	int64_t speed;
2875	};
2876
2877	struct q_obj_BLOCK_JOB_ERROR_arg {
2878	char *device;
2879	IoOperationType operation;
2880	BlockErrorAction action;
2881	};
2882
2883	struct q_obj_BLOCK_JOB_READY_arg {
2884	JobType type;
2885	char *device;
2886	int64_t len;
2887	int64_t offset;
2888	int64_t speed;
2889	};
2890
2891	struct q_obj_BLOCK_JOB_PENDING_arg {
2892	JobType type;
2893	char *id;
2894	};
2895
2896	struct q_obj_BLOCK_WRITE_THRESHOLD_arg {
2897	char *node_name;
2898	uint64_t amount_exceeded;
2899	uint64_t write_threshold;
2900	};
2901
2902	struct q_obj_block_set_write_threshold_arg {
2903	char *node_name;
2904	uint64_t write_threshold;
2905	};
2906
2907	struct q_obj_x_blockdev_change_arg {
2908	char *parent;
2909	bool has_child;
2910	char *child;
2911	bool has_node;
2912	char *node;
2913	};
2914
2915	struct q_obj_x_blockdev_set_iothread_arg {
2916	char *node_name;
2917	StrOrNull *iothread;
2918	bool has_force;
2919	bool force;
2920	};
2921
2922	#endif /* QAPI_TYPES_BLOCK_CORE_H */
2923

Browse the source code of qemu/build/qapi/qapi-types-block-core.h