KVM / virsh Cheatsheet

# Check KVM, IOMMU and cgroup support in one go (PASS / WARN / FAIL per line)
virt-host-validate qemu

# CPU virtualization extensions (vmx = Intel VT-x, svm = AMD-V); 0 means none or disabled in firmware
grep -cE 'vmx|svm' /proc/cpuinfo

# KVM modules loaded and the device present
lsmod | grep kvm
ls -l /dev/kvm

# Create VM from ISO
virt-install \
    --name myvm \
    --ram 2048 \
    --vcpus 2 \
    --disk path=/var/lib/libvirt/images/myvm.qcow2,size=20 \
    --os-variant ubuntu22.04 \
    --network bridge=br0 \
    --graphics vnc,listen=0.0.0.0 \
    --cdrom /path/to/installer.iso

# Create VM with default NAT network
virt-install \
    --name myvm \
    --ram 2048 \
    --vcpus 2 \
    --disk path=/var/lib/libvirt/images/myvm.qcow2,size=20 \
    --os-variant rocky9.0 \
    --network network=default \
    --graphics spice \
    --cdrom /path/to/installer.iso

# Headless VM (serial console, no graphics)
virt-install \
    --name headless \
    --ram 1024 \
    --vcpus 1 \
    --disk path=/var/lib/libvirt/images/headless.qcow2,size=10 \
    --os-variant generic \
    --network network=default \
    --graphics none \
    --extra-args='console=ttyS0,115200n8 serial' \
    --location /path/to/installer.iso

# Import existing disk image (no install)
virt-install \
    --name imported \
    --ram 2048 \
    --vcpus 2 \
    --disk path=/var/lib/libvirt/images/existing.qcow2 \
    --os-variant generic \
    --network network=default \
    --import \
    --graphics vnc

# Create VM with multiple disks
virt-install \
    --name multi-disk \
    --ram 4096 \
    --vcpus 4 \
    --disk path=/var/lib/libvirt/images/root.qcow2,size=30 \
    --disk path=/var/lib/libvirt/images/data.qcow2,size=100 \
    --os-variant rocky9.0 \
    --network network=default \
    --cdrom /path/to/installer.iso

# Create VM with cloud-init (NoCloud datasource)
virt-install \
    --name cloud-vm \
    --ram 2048 \
    --vcpus 2 \
    --disk path=/var/lib/libvirt/images/cloud.qcow2 \
    --os-variant ubuntu22.04 \
    --network network=default \
    --cloud-init user-data=/path/to/user-data.yaml \
    --import

# List available OS variants
osinfo-query os
osinfo-query os | grep -i ubuntu
osinfo-query os | grep -i rhel
osinfo-query os | grep -i rocky

cd /var/lib/libvirt/images

# Download a cloud image once, as the base for all VMs
# (Rocky: https://dl.rockylinux.org/pub/rocky/9/images/x86_64/Rocky-9-GenericCloud-Base.latest.x86_64.qcow2)
sudo curl -LO https://cloud-images.ubuntu.com/noble/current/noble-server-cloudimg-amd64.img

# Per VM: a 20 GB overlay on top of the base (the base itself is never written to)
sudo qemu-img create -f qcow2 -b noble-server-cloudimg-amd64.img -F qcow2 vm01.qcow2 20G

# Create and boot the VM
virt-install \
    --name vm01 \
    --memory 4096 \
    --vcpus 2 \
    --disk path=/var/lib/libvirt/images/vm01.qcow2 \
    --os-variant ubuntu24.04 \
    --network network=default \
    --cloud-init user-data=user-data.yaml \
    --import \
    --noautoconsole

#cloud-config
hostname: vm01
users:
  - name: admin
    sudo: ALL=(ALL) NOPASSWD:ALL
    shell: /bin/bash
    ssh_authorized_keys:
      - ssh-ed25519 AAAA... you@laptop

# Memory (MiB) and vCPUs
virt-xml <vm-name> --edit --memory memory=4096,currentMemory=4096
virt-xml <vm-name> --edit --vcpus 4

# Add a new 20 GB disk, or a NIC on the default network
virt-xml <vm-name> --add-device --disk size=20
virt-xml <vm-name> --add-device --network network=default,model=virtio

# Preview a change as a diff, without applying it
virt-xml <vm-name> --edit --vcpus 4 --print-diff

# Also apply it to the running VM, where hot-plug is supported
virt-xml <vm-name> --add-device --disk size=20 --update

# Clone a VM (must be shut down)
virt-clone --original <source-vm> --name <new-vm> --auto-clone

# Clone with specific disk path
virt-clone --original <source-vm> --name <new-vm> \
    --file /var/lib/libvirt/images/new-vm.qcow2

# Clone with multiple disks
virt-clone --original <source-vm> --name <new-vm> \
    --file /var/lib/libvirt/images/new-root.qcow2 \
    --file /var/lib/libvirt/images/new-data.qcow2

# Before the clone's first boot: reset machine-id, SSH host keys, MAC config, DHCP leases, ...
virt-sysprep -d <new-vm>

# Only selected operations, and set a new hostname
virt-sysprep -d <new-vm> --operations machine-id,ssh-hostkeys,net-hwaddr,dhcp-client-state --hostname <new-vm>

# Define network from XML
cat > /tmp/my-network.xml << EOF
<network>
  <name>isolated</name>
  <bridge name="virbr1"/>
  <ip address="10.10.10.1" netmask="255.255.255.0">
    <dhcp>
      <range start="10.10.10.100" end="10.10.10.200"/>
    </dhcp>
  </ip>
</network>
EOF

virsh net-define /tmp/my-network.xml
virsh net-start isolated
virsh net-autostart isolated

# Change NIC network
virsh domiflist <vm-name>
virsh detach-interface <vm-name> --type network --mac <mac-addr> --persistent
virsh attach-interface <vm-name> --type network --source new-network --model virtio --persistent

# Create directory-based pool
virsh pool-define-as mypool dir - - - - /data/vms
virsh pool-build mypool
virsh pool-start mypool
virsh pool-autostart mypool

# Delete and recreate default pool
virsh pool-destroy default
virsh pool-undefine default
virsh pool-define-as --name default --type dir --target /new-path
virsh pool-autostart default
virsh pool-start default

# Method 1: Snapshot-based backup
virsh snapshot-create-as <vm-name> --name backup --disk-only --quiesce
cp /var/lib/libvirt/images/myvm.qcow2 /backup/myvm-backup.qcow2
virsh blockcommit <vm-name> vda --active --pivot
virsh snapshot-delete <vm-name> backup --metadata   # the snapshot no longer has its overlay
rm /var/lib/libvirt/images/myvm.backup              # the overlay file (path in snapshot-dumpxml)

# Method 2: Dump XML + copy disk (VM must be off)
virsh dumpxml <vm-name> > /backup/myvm.xml
cp /var/lib/libvirt/images/myvm.qcow2 /backup/

# Restore from backup
cp /backup/myvm.qcow2 /var/lib/libvirt/images/
virsh define /backup/myvm.xml
virsh start <vm-name>

# Method 3: Save/restore (includes RAM state)
virsh save <vm-name> /backup/myvm-state
# Restore later:
virsh restore /backup/myvm-state

# All VM memory stats
for vm in $(virsh list --name); do echo "=== $vm ==="; virsh dommemstat $vm; done

# Start all stopped VMs
virsh list --inactive --name | xargs -I{} virsh start {}

# Shutdown all running VMs
virsh list --name | xargs -I{} virsh shutdown {}

# Force stop all running VMs
virsh list --name | xargs -I{} virsh destroy {}

# Set autostart on all VMs
virsh list --all --name | xargs -I{} virsh autostart {}

# Running VMs sorted by memory (balloon "actual" size, MB)
for vm in $(virsh list --name); do
    echo "$(virsh dommemstat "$vm" | awk '/^actual/{print int($2/1024)}') MB  $vm"
done | sort -rn

# Snapshot all running VMs
for vm in $(virsh list --name); do
    virsh snapshot-create-as "$vm" --name "bulk-$(date +%Y%m%d)" --description "Scheduled backup"
done

# Copy VM to remote host (offline)
virsh dumpxml <vm-name> > vm.xml
scp vm.xml user@remote:/tmp/
scp /var/lib/libvirt/images/myvm.qcow2 user@remote:/var/lib/libvirt/images/
ssh user@remote "virsh define /tmp/vm.xml"

# List all VM IPs (requires guest agent)
for vm in $(virsh list --name); do
    ip=$(virsh domifaddr "$vm" --source agent 2>/dev/null | awk '/ipv4/{print $4}' | cut -d/ -f1)
    echo "$vm: ${ip:-N/A}"
done

# Find which VM uses a disk image
virsh list --all --name | while read vm; do
    [ -n "$vm" ] && virsh domblklist "$vm" 2>/dev/null | grep -q "/path/to/disk" && echo "$vm"
done

# Get total resources used by all VMs
echo "Total vCPUs: $(virsh list --name | xargs -I{} virsh vcpucount {} --current 2>/dev/null | paste -sd+ | bc)"
echo "VMs running: $(virsh list --name | wc -l)"

# Export a VM (disks + libvirt XML) with virt-v2v; there is no OVA output (-of is raw or qcow2)
virsh shutdown <vm-name>   # wait until it is shut off
virt-v2v -i libvirt <vm-name> -o local -os /tmp/export -of qcow2

# Check QEMU version
qemu-system-x86_64 --version

# Check libvirt version
virsh version

# View host capabilities
virsh capabilities | head -50

virsh shutdown vm01   # returns at once: wait until 'virsh domstate vm01' says shut off
virsh undefine vm01
virsh vol-delete --pool default vm01.qcow2

virsh dominfo vm01
virsh shutdown vm01   # wait until shut off
# Give a unit: a plain number is KiB, so "2048" would mean 2 MiB
virsh setmaxmem vm01 2G --config
virsh setmem vm01 2G --config
virsh dominfo vm01
virsh start vm01

virsh dominfo vm01
virsh shutdown vm01   # wait until shut off
virsh setvcpus --domain vm01 --maximum 2 --config
virsh setvcpus --domain vm01 --count 2 --config
virsh dominfo vm01
virsh start vm01

virsh shutdown vm01   # wait until shut off
virt-clone --original vm01 --name vm01-clone --file /var/lib/libvirt/images/vm01-clone.qcow2
virt-sysprep -d vm01-clone --hostname vm01-clone

for i in $(virsh list | grep running | awk '{print $2}'); do
    virsh shutdown $i
done

qemu-img create -f qcow2 /var/lib/libvirt/images/vm01-data.qcow2 50G
virsh attach-disk vm01 /var/lib/libvirt/images/vm01-data.qcow2 vdb \
    --driver qemu --subdriver qcow2 --persistent

virsh dumpxml vm01 > vm01.xml
scp vm01.xml user@new-host:/tmp/
scp /var/lib/libvirt/images/vm01.qcow2 user@new-host:/var/lib/libvirt/images/
ssh user@new-host "virsh define /tmp/vm01.xml && virsh start vm01"

# Allocate 2MB hugepages
echo 4096 | sudo tee /proc/sys/vm/nr_hugepages

# Verify
cat /proc/meminfo | grep Huge

# Make persistent (add to /etc/sysctl.conf)
echo "vm.nr_hugepages = 4096" | sudo tee -a /etc/sysctl.conf

<memoryBacking>
  <hugepages>
    <page size="2048" unit="KiB"/>
  </hugepages>
  <locked/>
</memoryBacking>

<cpu mode="host-passthrough">
  <!-- topoext exists only on AMD CPUs -->
  <feature policy="require" name="topoext"/>
</cpu>
<cputune>
  <vcpupin vcpu="0" cpuset="2-3"/>
  <emulatorpin cpuset="0-1"/>
  <iothreadpin iothread="1" cpuset="4"/>
</cputune>

# Full backup that also creates checkpoint cp1 (the start point for incremental backups)
virsh backup-begin <vm-name> --checkpointxml checkpoint.xml

# Later: incremental backup of everything changed since cp1
virsh backup-begin <vm-name> backup.xml

# Progress, or cancel (a push-mode backup ends on its own when done)
virsh domjobinfo <vm-name>
virsh domjobabort <vm-name>

# List checkpoints
virsh checkpoint-list <vm-name>

<domaincheckpoint>
  <name>cp1</name>
</domaincheckpoint>

<domainbackup>
  <incremental>cp1</incremental>
  <disks>
    <disk name="vda" backup="yes" type="file">
      <target file="/backup/vda-inc.qcow2"/>
      <driver type="qcow2"/>
    </disk>
  </disks>
</domainbackup>

# Load the nbd module, then connect the disk image as a block device
sudo modprobe nbd max_part=8
sudo qemu-nbd --connect=/dev/nbd0 disk.qcow2

# Access with guestfish
guestfish --ro -a /dev/nbd0 -i

# Disconnect
sudo qemu-nbd --disconnect /dev/nbd0

# Intel
intel_iommu=on iommu=pt

# AMD
amd_iommu=on iommu=pt

# Find the device and its [vendor:device] ID, e.g. [10de:1eb8]
lspci -nn | grep -i nvidia  # or your device

# Load vfio-pci and unbind the device from its current driver
sudo modprobe vfio-pci
echo "0000:3b:00.0" | sudo tee /sys/bus/pci/devices/0000:3b:00.0/driver/unbind

# Bind to vfio-pci, using the vendor and device ID from lspci
echo "10de 1eb8" | sudo tee /sys/bus/pci/drivers/vfio-pci/new_id

# List PCI devices
virsh nodedev-list | grep pci

# Detach from host
virsh nodedev-detach pci_0000_3b_00_0

# Attach to VM (via XML)
virsh attach-device <vm-name> pci-device.xml --live

<hostdev mode="subsystem" type="pci" managed="yes">
  <source>
    <address domain="0x0000" bus="0x3b" slot="0x00" function="0x0"/>
  </source>
</hostdev>

# Create Virtual Functions
echo 4 | sudo tee /sys/class/net/enp3s0f0/device/sriov_numvfs

# Verify VFs created
lspci | grep "Virtual Function"
ip link show enp3s0f0

# Attach macvtap interface (guest gets own MAC on physical network)
virsh attach-interface <vm-name> --type direct --source eth0 --model virtio --live

# Create OVS bridge
ovs-vsctl add-br ovsbr0
ovs-vsctl add-port ovsbr0 enp3s0

# Define libvirt network using OVS (ovs-network.xml)
virsh net-define ovs-network.xml
virsh net-start ovs
virsh net-autostart ovs

virt-install \
    --name vm-uefi \
    --ram 4096 \
    --vcpus 4 \
    --os-variant rocky9.0 \
    --cpu host-passthrough \
    --machine q35 \
    --boot uefi \
    --disk size=40,format=qcow2,bus=virtio \
    --cdrom /path/to/installer.iso \
    --network network=default,model=virtio

# Create seed ISO for cloud images
cloud-localds seed.iso user-data meta-data

# Attach to VM before it boots (CD-ROM hot-plug isn't supported on SATA/IDE)
virsh attach-disk <vm-name> /var/lib/libvirt/images/seed.iso sdb --type cdrom --config

<memoryBacking>
  <source type="memfd"/>
  <access mode="shared"/>
</memoryBacking>

<filesystem type="mount" accessmode="passthrough">
  <source dir="/srv/share"/>
  <target dir="shared"/>
  <driver type="virtiofs"/>
</filesystem>

mount -t virtiofs shared /mnt

# Check libvirtd logs
journalctl -u libvirtd --no-pager -e

# Modular daemons (RHEL 9, Fedora): the QEMU driver runs as virtqemud
journalctl -u virtqemud --no-pager -e

# Per-VM QEMU log (startup errors, crashes)
sudo tail -f /var/log/libvirt/qemu/<vm-name>.log

# Also useful: virsh domjobinfo (Migration), virsh domblkerror (I/O Tuning),
# virsh domif-getlink (Interface Tuning), virsh reset (VM Lifecycle)

sudo qemu-system-x86_64 \
    -enable-kvm \
    -cpu host \
    -smp 8,sockets=1,cores=8,threads=1 \
    -m 16G \
    -object memory-backend-file,id=mem0,size=16G,mem-path=/dev/hugepages,share=on \
    -numa node,memdev=mem0,cpus=0-7 \
    -drive if=virtio,file=disk.qcow2,cache=none,aio=native,format=qcow2 \
    -netdev tap,id=n0,ifname=tap0,script=no,downscript=no,vhost=on,queues=4 \
    -device virtio-net-pci,netdev=n0,mq=on,vectors=10,rx_queue_size=1024,tx_queue_size=1024 \
    -machine q35,accel=kvm \
    -display none \
    -serial mon:stdio