L6 – VM Disk Image Formats: Cross-Platform Cheat Sheet

● cpx June 12, 2026 13 min read Virtualization Platforms

Pragmatic reference for creating, converting, mounting, resizing, shrinking, and migrating virtual machine disk images on Windows, Linux, and macOS, anchored to a logical architecture model.

1. Logical architecture

A disk image is a block device serialized into a file, wrapped in container metadata. Every operation in this sheet acts on exactly one layer of the stack below. Knowing which layer you are touching prevents most accidents.

┌─────────────────────────────────────────────────────────────────┐
│ L7  Guest files              /etc/fstab, C:\Windows\...          │
│ L6  Guest filesystem         ext4, XFS, NTFS, ReFS, APFS         │
│ L5  Guest volume management  LVM, Storage Spaces, APFS container │
│ L4  Guest partition table    GPT or MBR                          │
╞═════════════════════════════ guest / host boundary ═════════════╡
│ L3  Virtual block device     virtio-blk/scsi, NVMe, SATA, IDE    │
│ L2  Image container format   raw, qcow2, VMDK, VHD/VHDX, VDI     │
│     (allocation map, CoW clusters, snapshots, backing chain)     │
│ L1  Host volume / filesystem ext4, XFS, NTFS, APFS, ZFS, LVM     │
│ L0  Physical media           NVMe, SATA SSD, HDD, SAN/NAS        │
└─────────────────────────────────────────────────────────────────┘

Five working principles

#	Principle	Practical consequence
1	The container (L2) wraps the byte stream the guest sees at L3. Everything from L4 upward belongs to the guest.	Format conversion never touches partitions, filesystems, or the installed OS. The guest data stays bit-identical.
2	Conversion changes only L2.	`qemu-img convert` rewrites allocation metadata and re-packs allocated clusters. It also restores sparseness by skipping zero clusters.
3	Mounting an image on the host means re-implementing L3 in the host kernel.	Linux: loop or nbd device. Windows: Attach VHD. macOS: `hdiutil attach`. The host then parses L4 to L6 like any physical disk.
4	Space reclamation must traverse the full stack.	Guest trim (L6) → discard on the virtual controller (L3) → cluster unmap in the container (L2) → hole punch on the host FS (L1). Any layer that drops the discard leaves the file bloated.
5	Copy-on-write can live at L2 (qcow2, VMDK deltas, AVHDX), at L1 (ZFS, Btrfs, LVM-thin), or both.	Pick one layer to own snapshots. Stacked CoW multiplies write amplification and fragmentation.

2. Format reference

Format	Extension	Native ecosystem	Max virtual size	Allocation	Snapshot mechanism	qemu-img driver name	Notes
Raw	.img, .raw	Universal (every hypervisor, dd, loop)	Host FS limit	Sparse via FS holes, or fully preallocated	None at L2; use LVM/ZFS/FS at L1	`raw`	Zero metadata overhead, fastest, trivially mountable. Sparseness is fragile in transit.
QCOW2	.qcow2	QEMU/KVM, Proxmox, UTM, libvirt	Effectively unlimited (EB scale)	CoW clusters, 64 KiB default	Internal snapshots and external overlays with backing files	`qcow2`	Compression (zlib, zstd), LUKS encryption, dirty bitmaps for incremental backup. The feature-rich choice.
VMDK	.vmdk	VMware ESXi, Workstation, Fusion	62 TB (ESXi 5.5+)	Sparse (growable) or flat; thin, lazy zeroed, eager zeroed on VMFS	Delta extents (`disk-000001.vmdk`)	`vmdk`	A descriptor plus one or more extents. Subformat matters: `monolithicSparse`, `monolithicFlat`, `twoGbMaxExtentSparse/Flat`, `streamOptimized` (the OVA payload).
VHD	.vhd	Legacy Microsoft, Azure upload	2040 GB (~2 TB)	Fixed, dynamic, differencing	Differencing disks (parent/child)	`vpc`	Footer at end of file. Azure still requires fixed-size VHD for image upload.
VHDX	.vhdx	Hyper-V 2012+, native Windows mount	64 TB	Fixed, dynamic, differencing	AVHDX checkpoint chain	`vhdx`	Internal log makes it resilient to power loss. Supports 4 KiB logical sectors. WSL2 distro disks are VHDX.
VDI	.vdi	VirtualBox	Multi-TB	Dynamic or fixed	VirtualBox snapshot machinery	`vdi`	Simple and fine inside VirtualBox; convert when leaving the ecosystem.
Parallels HDD	.hdd (inside .pvm bundle)	Parallels Desktop (macOS)	Multi-TB	Expanding or plain	Parallels snapshots in the .pvm bundle	`parallels`	Managed with `prl_disk_tool`.
DMG family	.dmg, .sparseimage, .sparsebundle	macOS disk images (not hypervisor formats, same L2 idea)	FS limit	UDZO compressed, UDRW read-write, sparse, sparse bundle (banded files)	None	`dmg` (read-only)	Sparse bundles store data in 8 MB bands, which syncs and backs up well.
ASIF	.asif	Apple Virtualization framework, macOS 26 Tahoe	Multi-TB	Sparse	None	n/a	New Apple sparse format for VMs and containers; created with `diskutil image create blank --format ASIF`.

Choosing a format

If you run	Pick	Why
KVM, QEMU, Proxmox, UTM	qcow2	Snapshots, backing files, compression, thin by default
KVM with maximum I/O performance	raw on LVM-thin or a ZFS zvol	No container overhead; snapshots move to L1
Hyper-V	VHDX dynamic	Power-loss resilience, 64 TB, double-click mount in Windows
Azure image upload	VHD fixed	Hard platform requirement
VMware ESXi	VMDK thin on VMFS	Native; manage with `vmkfstools`
VMware Workstation or Fusion	VMDK monolithicSparse	Default, full snapshot support
VirtualBox	VDI (or VMDK for dual use with VMware)	Native
Shipping or archiving an appliance	OVA (streamOptimized VMDK inside) or compressed qcow2	Smallest portable form
Physical disk imaging, forensics	raw	Universal and tool-agnostic

3. The universal tool: qemu-img

One tool reads and writes nearly every format on all three operating systems. Learn it once.

OS	Install
Linux	`apt install qemu-utils` / `dnf install qemu-img`
macOS	`brew install qemu`
Windows	`winget install qemu` (or the official QEMU for Windows installer); `qemu-img.exe` lands in the install directory

Task	Command
Identify any image, virtual vs actual size	`qemu-img info disk.qcow2`
Show a full snapshot/backing chain	`qemu-img info --backing-chain top.qcow2`
Create a 100 GB thin qcow2	`qemu-img create -f qcow2 disk.qcow2 100G`
Create fully preallocated	`qemu-img create -f qcow2 -o preallocation=full disk.qcow2 100G`
Create an overlay on a base image	`qemu-img create -f qcow2 -b base.qcow2 -F qcow2 overlay.qcow2`
Convert between formats (progress bar)	`qemu-img convert -p -f vmdk -O qcow2 in.vmdk out.qcow2`
Convert with compression (qcow2 target)	`qemu-img convert -p -c -O qcow2 in.raw out.qcow2`
Grow an image	`qemu-img resize disk.qcow2 +50G`
Shrink an image (dangerous, see section 7)	`qemu-img resize --shrink disk.qcow2 80G`
List / create / apply / delete internal snapshots	`qemu-img snapshot -l/-c NAME/-a NAME/-d NAME disk.qcow2`
Check and repair qcow2 metadata	`qemu-img check -r all disk.qcow2`
Repoint an overlay to a moved backing file	`qemu-img rebase -u -b /new/path/base.qcow2 -F qcow2 overlay.qcow2`
Merge an overlay down into its backing file	`qemu-img commit overlay.qcow2`
Predict required size before converting	`qemu-img measure -O qcow2 in.vmdk`
Compare two images content-wise	`qemu-img compare a.qcow2 b.raw`

Preallocation modes for -o preallocation=: off (thin), metadata (qcow2 tables only), falloc (fast reserve), full (write zeros, best latency).

4. Per-OS toolbox

4.1 Windows

VHD and VHDX are first-class citizens: Explorer mounts them on double-click, Disk Management has Attach VHD, and the Hyper-V PowerShell module does the rest. Everything else gets handled by qemu-img.

Task	Command (elevated PowerShell unless noted)
Create dynamic VHDX	`New-VHD -Path D:\vm\d.vhdx -SizeBytes 100GB -Dynamic`
Convert VHD to VHDX	`Convert-VHD -Path a.vhd -DestinationPath a.vhdx -VHDType Dynamic`
Convert dynamic to fixed (e.g. for Azure, target VHD)	`Convert-VHD -Path a.vhdx -DestinationPath a.vhd -VHDType Fixed`
Grow	`Resize-VHD -Path d.vhdx -SizeBytes 200GB`
Shrink container to minimum possible	`Resize-VHD -Path d.vhdx -ToMinimumSize` (shrink the guest partition first)
Compact a dynamic VHDX	`Optimize-VHD -Path d.vhdx -Mode Full` (detach from the VM first; mounting read-only beforehand improves results)
Mount / unmount	`Mount-VHD -Path d.vhdx [-ReadOnly]` / `Dismount-VHD -Path d.vhdx`
Merge a checkpoint chain (AVHDX into parent)	`Merge-VHD -Path child.avhdx -DestinationPath parent.vhdx`
diskpart equivalents (no Hyper-V module needed)	`diskpart` → `select vdisk file="C:\d.vhdx"` → `attach vdisk` / `compact vdisk` / `expand vdisk maximum=200000` / `detach vdisk`
Physical to virtual (P2V)	Sysinternals Disk2vhd → produces VHDX from a live machine
Inspect or convert foreign formats	`qemu-img info x.qcow2`, `qemu-img convert -p -O vhdx -o subformat=dynamic x.qcow2 x.vhdx`
Quick read-only file extraction from VMDK/VHD/VDI	Open the image in 7-Zip and copy files out

WSL2 disk maintenance (the distro lives in an ext4.vhdx):

wsl --shutdown
# Option A (modern WSL): keep it sparse automatically
wsl --manage <DistroName> --set-sparse true
# Option B: one-off compaction
Optimize-VHD -Path "$env:LOCALAPPDATA\...\ext4.vhdx" -Mode Full
# Option C without Hyper-V module: diskpart -> select vdisk -> compact vdisk

4.2 Linux

Task	Command
Install the toolbox	`apt install qemu-utils libguestfs-tools`
Mount a qcow2/vmdk/vhdx via NBD	`modprobe nbd max_part=16` → `qemu-nbd -c /dev/nbd0 disk.qcow2` → `mount /dev/nbd0p2 /mnt` → `umount /mnt && qemu-nbd -d /dev/nbd0`
Mount a raw image with partitions	`losetup -fP --show disk.img` → mount `/dev/loopXp1`
Mount any format without root, auto-detect OS partitions	`guestmount -a disk.qcow2 -i --ro /mnt/vm` → `guestunmount /mnt/vm`
List partitions and filesystems inside an image	`virt-filesystems -a disk.img --all --long`
Free space inside an image without booting it	`virt-df -a disk.qcow2 -h`
Copy files out without mounting	`guestfish --ro -a win.vmdk -i copy-out /Users/lp/Documents /tmp/out`
Resize image and grow the partition in one pass	`virt-resize --expand /dev/sda2 old.img new.img`
Re-sparsify in place (after trim or zeroing)	`virt-sparsify --in-place disk.qcow2`
Punch holes in a raw file whose guest zeroed space	`fallocate --dig-holes disk.img`
Copy while preserving sparseness	`cp --sparse=always src.img dst.img` or `rsync -S`
Full cross-hypervisor migration incl. driver fixes	`virt-v2v -i vmx guest.vmx -o local -os /var/lib/libvirt/images` (also accepts `-i ova`)
Avoid CoW-on-CoW on Btrfs hosts	`chattr +C /var/lib/libvirt/images` before creating images there

Discard path on KVM so trims reach the host: virtio-scsi or modern virtio-blk, discard=unmap on the drive, then fstrim -av inside the guest.

4.3 macOS

Task	Command
Get qemu-img	`brew install qemu` (identical syntax to Linux/Windows)
Create a sparse bundle	`hdiutil create -size 100g -type SPARSEBUNDLE -fs APFS -volname Data data.sparsebundle`
Attach / detach an image	`hdiutil attach data.sparsebundle` / `hdiutil detach /dev/diskN`
Attach a raw VM image	`hdiutil attach -imagekey diskimage-class=CRawDiskImage -nomount disk.img` then `diskutil mountDisk /dev/diskN`
Reclaim space in a sparse image	`hdiutil compact data.sparseimage`
Convert between DMG variants	`hdiutil convert in.dmg -format UDSB -o out.sparsebundle`
New Apple sparse VM format (macOS 26)	`diskutil image create blank --format ASIF --size 100G disk.asif`
Parallels: compact an expanding disk	`prl_disk_tool compact --hdd "~/Parallels/Win11.pvm/harddisk.hdd"`
Parallels: resize	`prl_disk_tool resize --hdd harddisk.hdd --size 200G`
Parallels: plain ↔ expanding	`prl_disk_tool convert --hdd harddisk.hdd --expanding` (or `--plain`)

Practical notes for macOS:

Topic	Guidance
UTM	QEMU backend uses qcow2; the Apple Virtualization backend uses raw .img (and ASIF on Tahoe). Both sit inside the .utm bundle.
Mounting qcow2 on the host	No nbd kernel driver exists. Convert to raw and `hdiutil attach`, or run `guestmount` inside a Lima/Docker Linux VM, or attach the disk to a throwaway UTM VM.
Guest trim	Works in UTM/QEMU with virtio and discard enabled, then `fstrim` (Linux guest) or `defrag /L` (Windows guest), then re-sparsify or compact on the host.

5. Conversion

Pre-flight checklist

Step	Why
Shut the VM down cleanly	Converting a running or crash-state disk produces a dirty filesystem
Consolidate or delete snapshots first	Converters typically read one layer; orphaned chains lose data or fail
Record firmware type (BIOS vs UEFI) and controller type	More migrations break on firmware and driver mismatch than on disk bits
Install target-platform drivers in advance (virtio-win, Hyper-V ICs, VMware Tools) or plan to use `virt-v2v`	A Windows guest without the boot-critical storage driver blue-screens with INACCESSIBLE_BOOT_DEVICE
Verify free space ≥ virtual size of the source	`qemu-img measure` predicts the target size
Work on a copy	Conversion is read-only on the source, but mistakes with paths are not

Conversion matrix (qemu-img does almost everything)

Target	Command
→ qcow2	`qemu-img convert -p -O qcow2 src.vmdk dst.qcow2`
→ qcow2 compressed	`qemu-img convert -p -c -O qcow2 src.img dst.qcow2`
→ raw	`qemu-img convert -p -O raw src.qcow2 dst.img`
→ VHDX (Hyper-V)	`qemu-img convert -p -O vhdx -o subformat=dynamic src.qcow2 dst.vhdx`
→ VHD fixed (Azure)	`qemu-img convert -p -O vpc -o subformat=fixed,force_size src.qcow2 dst.vhd`
→ VMDK for Workstation/Fusion	`qemu-img convert -p -O vmdk -o subformat=monolithicSparse src.qcow2 dst.vmdk`
→ VMDK for OVA packaging	`qemu-img convert -p -O vmdk -o subformat=streamOptimized src.qcow2 dst.vmdk`
→ VDI	`qemu-img convert -p -O vdi src.vmdk dst.vdi`

Ecosystem-native alternatives and special cases

Case	Command
VirtualBox clone/convert	`VBoxManage clonemedium disk in.vdi out.vmdk --format VMDK` (formats: VDI, VMDK, VHD, RAW)
VHD ↔ VHDX with Microsoft tooling	`Convert-VHD` (section 4.1)
Unpack an OVA	`tar xf appliance.ova` → convert the inner streamOptimized VMDK before running it on non-VMware platforms
Import a VMDK onto ESXi datastore properly	`vmkfstools -i uploaded.vmdk thin.vmdk -d thin` (uploaded streamOptimized/sparse images are not runnable as-is on VMFS)
VMware Workstation/Fusion defragment+shrink	`vmware-vdiskmanager -k disk.vmdk`; convert type with `vmware-vdiskmanager -r src.vmdk -t 0 dst.vmdk`
Full migration with driver injection	`virt-v2v` (reads VMware vmx/ova, fixes virtio drivers, outputs libvirt/qcow2)

6. Mounting and inspecting on the host (summary)

Host	Raw .img	qcow2	VMDK	VHD/VHDX	Read-only quick look
Linux	`losetup -fP`	`qemu-nbd` or `guestmount`	`qemu-nbd` or `guestmount`	`qemu-nbd` or `guestmount`	`virt-ls`, `guestfish`
Windows	Convert first, or 7-Zip	Convert first, or 7-Zip	VMware Workstation map drive, or 7-Zip	Native: Explorer double-click, `Mount-VHD`, diskpart	7-Zip opens most containers
macOS	`hdiutil attach` (CRawDiskImage)	Convert to raw first, or Linux helper VM	Convert, or Fusion	Convert	`hdiutil imageinfo`, `qemu-img info`

Identification: qemu-img info is authoritative for container type; file disk.img gives a fast hint.

7. Resizing and shrinking

Growing is safe and bottom-up. Shrinking is risky and top-down. Order is everything.

Grow (safe)

Step	Layer	Tool examples
1. Grow the container	L2	`qemu-img resize +50G`, `Resize-VHD`, `VBoxManage modifymedium --resize <MB>`, `prl_disk_tool resize`
2. Grow the partition	L4	`growpart /dev/vda 2`, GParted, Windows Disk Management, `diskutil`
3. Grow the filesystem	L6	`resize2fs`, `xfs_growfs`, NTFS extends with the partition, `diskutil apfs resizeContainer`

Shrink (reverse order, always on a backup copy)

Step	Layer	Notes
1. Shrink the guest filesystem	L6	`resize2fs /dev/vda2 80G` (XFS cannot shrink), Windows Disk Management shrink volume
2. Shrink the partition to match	L4	GParted or diskpart; leave a safety margin
3. Shrink the container	L2	`qemu-img resize --shrink disk.qcow2 81G`; `Resize-VHD -ToMinimumSize`

Cutting L2 below the end of valid L4 data destroys the guest. The --shrink flag exists precisely because this is irreversible.

Compact / reclaim (thin images that grew fat)

Universal principle: make free space zero or trimmed inside the guest, then compact at L2.

Format	Zero/trim step (in guest)	Compact step (on host)
qcow2	`fstrim -av` (with discard=unmap) or zero-fill	`virt-sparsify --in-place disk.qcow2`, or `qemu-img convert` to a fresh file
VHDX	`defrag C: /L` or `sdelete -z C:`	`Optimize-VHD -Mode Full` or diskpart `compact vdisk`
VDI	`zerofree` (Linux) / `sdelete -z` (Windows)	`VBoxManage modifymedium disk.vdi --compact`
VMDK (Workstation/Fusion)	VMware Tools shrink or `sdelete -z`	`vmware-vdiskmanager -k disk.vmdk`
VMDK (ESXi)	`fstrim` / `sdelete -z`	`vmkfstools --punchzero disk.vmdk` or Storage vMotion
Parallels HDD	Built-in Reclaim, or trim in guest	`prl_disk_tool compact`
raw	`fstrim` with discard, or zero-fill	`fallocate --dig-holes disk.img`

8. Snapshots, backing files, and chains

Operation	Command
Internal qcow2 snapshot (create/list/revert/delete)	`qemu-img snapshot -c clean / -l / -a clean / -d clean disk.qcow2`
External overlay (base stays read-only)	`qemu-img create -f qcow2 -b base.qcow2 -F qcow2 top.qcow2`
Inspect the whole chain	`qemu-img info --backing-chain top.qcow2`
Merge overlay down into base	`qemu-img commit top.qcow2`
Repoint after moving the base	`qemu-img rebase -u -b /new/base.qcow2 -F qcow2 top.qcow2`
Hyper-V: collapse checkpoints	Delete the checkpoint in Hyper-V Manager (auto-merges AVHDX), or `Merge-VHD`
VMware: consolidate deltas	Snapshot Manager → Delete All, or `vmkfstools` clone of the current state

Chain hygiene

Rule	Reason
Keep production chains shallow (≤ 3 links)	Every read may traverse the whole chain
Never rename or move a backing file without `rebase -u`	Overlays store the backing path; the chain silently breaks
Never plain-copy the disk of a running VM	The result is crash-consistent at best; snapshot first or use backup APIs/bitmaps
Backing chains are also a feature	One golden base + N overlays = instant linked clones for labs

9. Gotchas and performance notes

Gotcha	Mitigation
Sparse files balloon to full size over scp/SMB/USB copies	`rsync -S`, `cp --sparse=always`, tar with `-S`, or convert/compress for transport
qcow2 on Btrfs or ZFS doubles CoW	`chattr +C` on the images directory (Btrfs), or use raw on a zvol and let ZFS own snapshots
Trim never reaches the host file	Enable discard on the virtual controller (virtio-scsi `discard=unmap`), then trim in the guest, then sparsify/compact
streamOptimized VMDK refuses to boot	It is a transport subformat; convert to monolithicSparse or import with `vmkfstools -i`
Windows guest BSOD INACCESSIBLE_BOOT_DEVICE after moving hypervisors	Inject the target storage driver beforehand (virtio-win, Hyper-V ICs) or migrate with `virt-v2v`
BIOS/UEFI mismatch after migration	Recreate the VM with the same firmware as the source; converting MBR↔GPT is a separate guest-side task
BitLocker/TPM-bound guests	Suspend BitLocker before migration; vTPM state does not travel with the disk file
VHD 2 TB ceiling hit mid-growth	Convert to VHDX first, then grow
Azure upload rejected	Must be VHD, fixed, size aligned to 1 MiB; use the `vpc` + `force_size` recipe above
Deep snapshot chains crawl	Commit/consolidate regularly; monitor with `qemu-img info --backing-chain`
Old XP-era images misaligned (63-sector offset)	Realign once (`virt-resize` rebuilds layout) or accept the read-modify-write penalty
Network or USB-attached host storage for live images	Latency and locking issues; keep active images on local storage, archives anywhere

10. One-glance command crib

Intent	Linux/macOS	Windows
What is this file?	`qemu-img info x`	`qemu-img info x`
Convert	`qemu-img convert -p -O <fmt> in out`	same, or `Convert-VHD` for VHD↔VHDX
Mount	`guestmount -a x -i /mnt` (Linux), `hdiutil attach` (macOS raw)	Double-click VHDX / `Mount-VHD`
Grow	`qemu-img resize x +20G`	`Resize-VHD -SizeBytes`
Reclaim space	trim in guest → `virt-sparsify`	`sdelete -z` → `Optimize-VHD`
Snapshot	`qemu-img snapshot -c name x`	Hyper-V checkpoint
P2V	`dd` to raw, then convert; or `virt-p2v`	Disk2vhd

0 0 votes

Article Rating

0 Comments

Oldest

Newest Most Voted