qcow2

type BDRVState struct {
	ClusterBits       int    // int
	ClusterSize       int    // int
	ClusterSectors    int    // int
	L2Bits            int    // int
	L2Size            int    // int
	L1Size            int    // int
	L1VmStateIndex    int    // int
	RefcountBlockBits int    // int
	RefcountBlockSize int    // int
	Csize_shift       int    // int
	Csize_mask        int    // int
	ClusterOffsetMask uint64 // uint64_t
	L1TableOffset     uint64 // uint64_t
	L1Table           uint64 // uint64_t

	L2TableCache       *Cache // *Qcow2Cache
	RefcountBlockCache *Cache // *Qcow2Cache
	// cache_clean_timer    *QEMUTimer
	CacheCleanInterval uintptr // unsigned

	ClusterCache       uint8  // uint8_t
	ClusterData        uint8  // uint8_t
	ClusterCacheOffset uint64 // uint64_t

	// RefcountTable       map[uint64]int64 // uint64_t
	RefcountTable       [8][]byte // uint64_t
	RefcountTableOffset uint64    // uint64_t
	RefcountTableSize   uint32    // uint32_t
	FreeClusterIndex    uint64    // uint64_t
	FreeByteOffset      uint64    // uint64_t

	// cipher              *QCryptoCipher // current cipher, nil if no key yet
	CryptMethodHeader uint32  // uint32_t
	SnapshotsOffset   uint64  // uint64_t
	SnapshotsSize     int     // int
	NbSnapshots       uintptr // unsigend int

	Flags            int     // int
	Version          Version // int
	UseLazyRefcounts bool    // bool
	RefcountOrder    int     // int
	RefcountBits     int     // int
	RefcountMax      uint64  // uint64_t

	GetRefcount func(refcountArray interface{}, index uint64) uint64        // *Qcow2GetRefcountFunc
	SetRefcount func(refcountArray interface{}, index uint64, value uint64) // *Qcow2SetRefcountFunc

	DiscardPassthrough bool // bool discard_passthrough[QCOW2_DISCARD_MAX]

	OverlapCheck       int  // int: bitmask of Qcow2MetadataOverlap values
	SignaledCorruption bool // bool

	IncompatibleFeatures uint64 // uint64_t
	CompatibleFeatures   uint64 // uint64_t
	AutoclearFeatures    uint64 // uint64_t

	UnknownheaderFieldsSize int    // size_t
	UnknownHeaderFields     []byte // void*
	// unknown_header_ext QLIST_HEAD(, Qcow2UnknownHeaderExtension)
	// discards QTAILQ_HEAD (, Qcow2DiscardRegion)
	CacheDiscards bool // bool

	// Backing file path and format as stored in the image (this is not the
	// effective path/format, which may be the result of a runtime option
	// override)
	ImageBackingFile   string // char *
	ImageBackingFormat []byte // char *
}

type BdrvChild struct {
	Name string
	// Role   *BdrvChildRole
	Opaque *BDRVState
	// contains filtered or unexported fields
}

type BitmapExtension struct {
	// NbBitmaps the number of bitmaps contained in the image. Must be greater than ro equal to 1. [1:4]
	NbBitmaps int
	// Reserved reserved, must be zero. [4:8]
	Reserved int
	// BitmapDirectorySize size of the bitmap directory in bytes. It is the cumulative size of all (nb_bitmaps) bitmap headers. [8:16]
	BitmapDirectorySize int
	// BitmapDirectoryOffset offste into the image file at which the bitmap directory starts. [16:24]
	BitmapDirectoryOffset int
}

type BlockBackend struct {
	File   *os.File
	Header Header

	BlockDriverState *BlockDriverState

	Error error
	// contains filtered or unexported fields
}

type BlockDriver struct {
	// contains filtered or unexported fields
}

type BlockDriverInfo struct {
	// contains filtered or unexported fields
}

type BlockDriverState struct {
	TotalSectors int64 // int64_t: if we are reading a disk image, give its size in sectors
	OpenFlags    int   // int:     flags used to open the file, re-used for re-open
	ReadOnly     bool  // bool:    if true, the media is read only
	Encrypted    bool  // bool:    if true, the media is encrypted
	ValidKey     bool  // bool:    if true, a valid encryption key has been set
	SG           bool  // bool:    if true, the device is a /dev/sg* (scsi-generic devices)
	Probed       bool  // bool:    if true, format was probed rather than specified

	CopyOnRead int // int: if nonzero, copy read backing sectors into image. note this is a reference count.

	// flush_queue // CoQueue: Serializing flush queue // TODO
	// active_flush_req // *BdrvTrackedRequest: Flush request in flight // TODO
	WriteGen   uint // unsigned int: Current data generation
	FlushedGen uint // unsigned int: Flushed write generation

	Drv    *BlockDriver // BlockDriver *: NULL means no media
	Opaque *BDRVState   // void *

	// long-running tasks intended to always use the same AioContext as this
	// BDS may register themselves in this list to be notified of changes
	// regarding this BDS's context
	// AioNotifiers QLIST_HEAD(, BdrvAioNotifier) // TODO
	WalkingAioNotifiers bool // bool: to make removal during iteration safe

	Filename      string // char: filename[PATH_MAX]
	BackingFile   string // char: if non zero, the image is a diff of this file image
	BackingFormat string // char: if non-zero and backing_file exists

	// FullOpenOptions *QDict // *QDict * TODO
	ExactFilename string // char: exact_filename[PATH_MAX]

	Backing *BdrvChild
	File    *os.File

	// SerialisingInFlight number of in-flight serialising requests
	SerialisingInFlight uint // unsigned int

	// Offset after the highest byte written to
	WrHighestOffset uint64 // uint64_t

	// I/O Limits
	BL BlockLimits

	// unsigned int: Flags honored during pwrite (so far: BDRV_REQ_FUA)
	SupportedWriteFlags uint
	// unsigned int: Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA, *BDRV_REQ_MAY_UNMAP)
	SupportedZeroFlags uint

	// NodeName the following member gives a name to every node on the bs graph.
	NodeName string // char node_name[32]
	// NodeList element of the list of named nodes building the graph
	// NodeList QTAILQ_ENTRY(BlockDriverState) // TODO
	// BsList element of the list of all BlockDriverStates (all_bdrv_states)
	// BsList QTAILQ_ENTRY(BlockDriverState) // TODO
	// MonitorList element of the list of monitor-owned BDS
	// MonitorList QTAILQ_ENTRY(BlockDriverState) // TODO
	// DirtyBitmaps QLIST_HEAD(, BdrvDirtyBitmap) // TODO
	Refcnt int // int

	// The error object in use for blocking operations on backing_hd
	BackingBlocker error

	// threshold limit for writes, in bytes. "High water mark"
	WriteThresholdOffset uint64

	// Counters for nested bdrv_io_plug and bdrv_io_unplugged_begin
	IOPlugged      uintptr // unsigned: TODO
	IOPlugDisabled uintptr // unsigned: TODO

	QuiesceCounter int // int
	// contains filtered or unexported fields
}

type BlockLimits struct {
	// RequestAlignment alignment requirement, in bytes, for offset/length of I/O
	// requests. Must be a power of 2 less than INT_MAX; defaults to
	// 1 for drivers with modern byte interfaces, and to 512
	// otherwise.
	RequestAlignment uint32 // uint32_t

	// MaxPdiscard maximum number of bytes that can be discarded at once (since it
	// is signed, it must be < 2G, if set). Must be multiple of
	// pdiscard_alignment, but need not be power of 2. May be 0 if no
	// inherent 32-bit limit
	MaxPdiscard int32 // int32_t

	// PdiscardAlignment optimal alignment for discard requests in bytes. A power of 2
	// is best but not mandatory.  Must be a multiple of
	// bl.request_alignment, and must be less than max_pdiscard if
	// that is set. May be 0 if bl.request_alignment is good enough
	PdiscardAlignment uint32 // uint32_t

	// MaxPwriteZeroes maximum number of bytes that can zeroized at once (since it is
	// signed, it must be < 2G, if set). Must be multiple of
	// pwrite_zeroes_alignment. May be 0 if no inherent 32-bit limit
	MaxPwriteZeroes int32 // int32_t

	// PwriteZeroesAlignment optimal alignment for write zeroes requests in bytes. A power
	// of 2 is best but not mandatory.  Must be a multiple of
	// bl.request_alignment, and must be less than max_pwrite_zeroes
	// if that is set. May be 0 if bl.request_alignment is good
	// enough
	PwriteZeroesAlignment uint32 // uint32_t

	// OptTransfer optimal transfer length in bytes.  A power of 2 is best but not
	// mandatory.  Must be a multiple of bl.request_alignment, or 0 if
	// no preferred size
	OptTransfer uint32 // uint32_t

	// MaxTransfer maximal transfer length in bytes.  Need not be power of 2, but
	// must be multiple of opt_transfer and bl.request_alignment, or 0
	// for no 32-bit limit.  For now, anything larger than INT_MAX is
	// clamped down.
	MaxTransfer uint32 // uint32_t

	// MinMemAlignment memory alignment, in bytes so that no bounce buffer is needed
	MinMemAlignment uint32 // size_t

	// OptMemAlignment memory alignment, in bytes, for bounce buffer
	OptMemAlignment uint32 // size_t

	// MaxIov maximum number of iovec elements
	MaxIov int // int
}

type BlockOption struct {
	Driver BlockDriver
}

type CLUSTER uint64

type Cache struct {
}

type CryptMethod uint32

type DiscardRegion struct {
	Bs     *BlockDriverState
	Offset uint64 // uint64_t
	// contains filtered or unexported fields
}

type DiscardType int

type DriverFmt string

type Extension struct {
	Magic HeaderExtensionType // [:4] Header extension type
	Len   uint32              // [4:8] Length of the header extension data
}

type Feature struct {
	Type uint8  // uint8_t
	Bit  uint8  // uint8_t
	Name string // char    name[46];
	// contains filtered or unexported fields
}

type FeatureNameTable struct {
	// Type type of feature [0:1]
	Type int
	// BitNumber bit number within the selected feature bitmap [1:2]
	BitNumber int
	// FeatureName feature name. padded with zeros [2:48]
	FeatureName int
}

type FeatureType uint8

type Header struct {
	Magic                 uint32      //     [0:3] magic: QCOW magic string ("QFI\xfb")
	Version               Version     //     [4:7] Version number
	BackingFileOffset     uint64      //    [8:15] Offset into the image file at which the backing file name is stored.
	BackingFileSize       uint32      //   [16:19] Length of the backing file name in bytes.
	ClusterBits           uint32      //   [20:23] Number of bits that are used for addressing an offset whithin a cluster.
	Size                  uint64      //   [24:31] Virtual disk size in bytes
	CryptMethod           CryptMethod //   [32:35] Crypt method
	L1Size                uint32      //   [36:39] Number of entries in the active L1 table
	L1TableOffset         uint64      //   [40:47] Offset into the image file at which the active L1 table starts
	RefcountTableOffset   uint64      //   [48:55] Offset into the image file at which the refcount table starts
	RefcountTableClusters uint32      //   [56:59] Number of clusters that the refcount table occupies
	NbSnapshots           uint32      //   [60:63] Number of snapshots contained in the image
	SnapshotsOffset       uint64      //   [64:71] Offset into the image file at which the snapshot table starts
	IncompatibleFeatures  uint64      //   [72:79] for version >= 3: Bitmask of incomptible feature
	CompatibleFeatures    uint64      //   [80:87] for version >= 3: Bitmask of compatible feature
	AutoclearFeatures     uint64      //   [88:95] for version >= 3: Bitmask of auto-clear feature
	RefcountOrder         uint32      //   [96:99] for version >= 3: Describes the width of a reference count block entry
	HeaderLength          uint32      // [100:103] for version >= 3: Length of the header structure in bytes
}

type HeaderExtensionType uint32

type Opt struct {
	Name string
	Str  string

	Value struct {
		Boolean bool
		// contains filtered or unexported fields
	}

	Opts *Opts
	// contains filtered or unexported fields
}

type OptDesc struct {
	Name        string
	Type        OptType
	Help        string
	DefValueStr string
}

type OptType int

type Opts struct {
	// Filename filename of create image.
	Filename string
	// Fmt format of create image.
	Fmt DriverFmt
	// BaseFliename base filename of create image.
	BaseFilename string
	// BaseFmt base format of create image.
	BaseFmt string

	// BLOCK_OPT
	// Size size of create image virtual size.
	Size int64

	//  Encryption option is if this option is set to "on", the image is encrypted with 128-bit AES-CBC.
	Encryption bool

	//  BackingFile file name of a base image (see create subcommand).
	BackingFile string

	//  BackingFormat image format of the base image.
	BackingFormat string

	//  ClusterSize option is changes the qcow2 cluster size (must be between 512 and 2M).
	//  Smaller cluster sizes can improve the image file size whereas larger cluster sizes generally provide better performance.
	ClusterSize int

	TableSize int

	//  Preallocation mode of pre-allocation metadata (allowed values: "off", "metadata", "falloc", "full").
	//  An image with preallocated metadata is initially larger but can improve performance when the image needs to grow.
	//  "falloc" and "full" preallocations are like the same options of "raw" format, but sets up metadata also.
	Preallocation PreallocMode

	SubFormat string

	//  Compat QCow2 image format compatible. "compat=0.10": uses the traditional image format that can be read by any QEMU since 0.10.
	//  "compat=1.1":  enables image format extensions that only QEMU 1.1 and newer understand (this is the default).
	Compat string

	//  LazyRefcounts option is if this option is set to "on", reference count updates are postponed with the goal of avoiding metadata I/O and improving performance.
	//  This is particularly interesting with cache=writethrough which doesn't batch metadata updates.
	//  The tradeoff is that after a host crash, the reference count tables must be rebuilt,
	//  i.e. on the next open an (automatic) "qemu-img check -r all" is required, which may take some time.
	//  This option can only be enabled if "compat=1.1" is specified.
	LazyRefcounts bool // LazyRefcounts Avoiding metadata I/O and improving performance with the postponed updates reference count.

	AdapterType string

	Redundancy bool

	//  NoCow option is if this option is set to "on", it will turn off COW of the file. It's only valid on btrfs, no effect on other file systems.
	//  Btrfs has low performance when hosting a VM image file, even more when the guest on the VM also using btrfs as file system.
	//  Turning off COW is a way to mitigate this bad performance. Generally there are two ways to turn off COW on btrfs: a)
	//  Disable it by mounting with nodatacow, then all newly created files will be NOCOW. b)
	//  For an empty file, add the NOCOW file attribute. That's what this option does.
	//  Note: this option is only valid to new or empty files.
	//  If there is an existing file which is COW and has data blocks already, it couldn't be changed to NOCOW by setting "nocow=on".
	//  One can issue "lsattr filename" to check if the NOCOW flag is set or not (Capital 'C' is NOCOW flag).
	NoCow bool

	ObjectSize int

	RefcountBits int
}

type OptsList struct {
	Name           string
	ImpliedOptName string
	MergeLists     bool // Merge multiple uses of option into a single list?
	// head QTAILQ_HEAD(, QemuOpts)
	Desc []OptDesc
}

type PreallocMode int

type QCow2 struct {
	// contains filtered or unexported fields
}

type QDict struct {
	// contains filtered or unexported fields
}

type QObject struct {
	// contains filtered or unexported fields
}

type QType int

type QemuOpts struct {
	ID   string
	List *OptsList
}

type Snapshot struct {
}

type SnapshotExtraData struct {
}

type SnapshotHeader struct {
}

type Truncater interface {
	Truncate(bs *BlockDriverState, offset int64) error
}

type UnknownHeaderExtension struct {
	Magic uint32
	Len   uint32
	// Next QLIST_ENTRY(Qcow2UnknownHeaderExtension)
	Data []int8
}

type Version uint32