QEMU System Emulation: Low-Level Virtualization on Linux

Mastering KVM Virtualization

# Create a virtual disk image
qemu-img create -f qcow2 mydisk.img 20G

# Launch a basic VM with 2GB RAM
qemu-system-x86_64 -enable-kvm -m 2048 -drive file=mydisk.img,format=qcow2

# Verify hardware virtualization capabilities
egrep -c '(vmx|svm)' /proc/cpuinfo
# Non-zero result indicates support

# Check if KVM modules are loaded
lsmod | grep kvm
# Should show kvm_intel or kvm_amd

# Test KVM access permissions
kvm-ok
# Should return: KVM acceleration can be used

# Alternative check
[ -e /dev/kvm ] && echo "KVM available" || echo "KVM not available"

# Load KVM kernel modules
sudo modprobe kvm
sudo modprobe kvm_intel  # For Intel processors
# sudo modprobe kvm_amd  # For AMD processors

# Verify module loading
dmesg | grep kvm
# Should show KVM initialization messages

# Check KVM device permissions
ls -l /dev/kvm
# Should be readable/writable by your user or virtualization group

# Enable KVM with optimal CPU settings
qemu-system-x86_64 \
  -enable-kvm \
  -cpu host \
  -smp 4,cores=2,threads=2 \
  -m 4096 \
  -drive file=vm.img,format=qcow2

# Pure emulation without KVM (slower, but works cross-architecture)
qemu-system-aarch64 \
  -M virt \
  -cpu cortex-a57 \
  -m 2048 \
  -drive file=arm64-vm.img,format=qcow2

# Allocate 8GB RAM to VM with huge pages support
qemu-system-x86_64 \
  -enable-kvm \
  -m 8192 \
  -mem-path /dev/hugepages \
  -mem-prealloc \
  -drive file=vm.img,format=qcow2

# Check huge pages configuration on host
cat /proc/meminfo | grep -i huge

# Update package repositories
sudo apt update

# Install QEMU system emulation with KVM support
sudo apt install qemu-system-x86 qemu-kvm libvirt-daemon-system \
  libvirt-clients bridge-utils virt-manager

# Install additional architecture support (optional)
sudo apt install qemu-system-arm qemu-system-aarch64 qemu-system-mips

# Add your user to required groups
sudo usermod -aG kvm $USER
sudo usermod -aG libvirt $USER

# Restart to apply group membership
# Or use: newgrp kvm && newgrp libvirt

# Verify QEMU installation
qemu-system-x86_64 --version
which qemu-img

# Enable required repositories (RHEL 8/9)
sudo subscription-manager repos --enable codeready-builder-for-rhel-9-x86_64-rpms

# Install QEMU with KVM (Fedora/RHEL 9)
sudo dnf install qemu-kvm libvirt virt-install virt-manager \
  virt-viewer bridge-utils

# For RHEL/CentOS 7
sudo yum install qemu-kvm qemu-img libvirt libvirt-python \
  libvirt-client virt-install virt-viewer bridge-utils

# Start and enable libvirt service
sudo systemctl enable --now libvirtd

# Add user to libvirt group
sudo usermod -aG libvirt $USER
sudo usermod -aG kvm $USER

# Verify virtualization support
virt-host-validate qemu

# Install QEMU and virtualization tools
sudo pacman -S qemu-full libvirt virt-manager dnsmasq bridge-utils

# Enable and start libvirt
sudo systemctl enable --now libvirtd

# Configure user permissions
sudo usermod -aG libvirt $USER
sudo usermod -aG kvm $USER

# Install optional UEFI support
sudo pacman -S edk2-ovmf

# Verify installation
qemu-system-x86_64 --version
virsh version

# Configure default libvirt network
sudo virsh net-list --all
sudo virsh net-start default
sudo virsh net-autostart default

# Configure KVM nested virtualization (if needed)
# For Intel CPUs:
echo "options kvm_intel nested=1" | sudo tee /etc/modprobe.d/kvm.conf

# For AMD CPUs:
echo "options kvm_amd nested=1" | sudo tee /etc/modprobe.d/kvm.conf

# Reload KVM modules
sudo modprobe -r kvm_intel && sudo modprobe kvm_intel
# Or for AMD: sudo modprobe -r kvm_amd && sudo modprobe kvm_amd

# Verify nested virtualization
cat /sys/module/kvm_intel/parameters/nested  # Should show Y or 1

# Create a 50GB QCOW2 image (thin provisioned)
qemu-img create -f qcow2 myvm.qcow2 50G

# Create QCOW2 with specific options
qemu-img create -f qcow2 \
  -o preallocation=metadata,cluster_size=64K,lazy_refcounts=on \
  optimized-vm.qcow2 100G

# Create encrypted QCOW2 image
qemu-img create -f qcow2 \
  -o encryption=on \
  encrypted-vm.qcow2 30G

# Check QCOW2 image information
qemu-img info myvm.qcow2

# Create RAW disk image (fully allocated)
qemu-img create -f raw rawdisk.img 20G

# Create sparse RAW image (thin provisioned)
dd if=/dev/zero of=sparse-raw.img bs=1 count=0 seek=50G

# Convert between formats
qemu-img convert -f qcow2 -O raw myvm.qcow2 myvm.raw

# Compare performance
time qemu-io -f qcow2 -c "read 0 1M" myvm.qcow2
time qemu-io -f raw -c "read 0 1M" myvm.raw

# Create VMDK format (VMware compatible)
qemu-img create -f vmdk vmware-compatible.vmdk 40G

# Create VDI format (VirtualBox compatible)
qemu-img create -f vdi virtualbox-compatible.vdi 40G

# Convert existing VM to VMDK
qemu-img convert -f qcow2 -O vmdk myvm.qcow2 myvm.vmdk

# Convert VMDK to QCOW2
qemu-img convert -f vmdk -O qcow2 imported.vmdk converted.qcow2

# Resize QCOW2 image (expand)
qemu-img resize myvm.qcow2 +10G

# Check for corruption and repair
qemu-img check -r all myvm.qcow2

# Compress QCOW2 image (reclaim unused space)
qemu-img convert -f qcow2 -O qcow2 -c original.qcow2 compressed.qcow2

# Create backing file chain for snapshots
qemu-img create -f qcow2 -b base-image.qcow2 -F qcow2 snapshot1.qcow2

# Commit changes from snapshot to backing file
qemu-img commit snapshot1.qcow2

# Rebase snapshot on different backing file
qemu-img rebase -b new-base.qcow2 -F qcow2 snapshot1.qcow2

# Create 30GB QCOW2 disk image for new VM
qemu-img create -f qcow2 ubuntu-server.qcow2 30G

# Verify image creation
qemu-img info ubuntu-server.qcow2

# Download Ubuntu Server ISO
wget https://releases.ubuntu.com/22.04/ubuntu-22.04.3-live-server-amd64.iso

# Verify ISO checksum
sha256sum ubuntu-22.04.3-live-server-amd64.iso

# Start VM installation with optimal settings
qemu-system-x86_64 \
  -enable-kvm \
  -m 4096 \
  -cpu host \
  -smp 4 \
  -drive file=ubuntu-server.qcow2,format=qcow2,if=virtio \
  -cdrom ubuntu-22.04.3-live-server-amd64.iso \
  -boot order=d,menu=on \
  -device virtio-net-pci,netdev=net0 \
  -netdev user,id=net0,hostfwd=tcp::2222-:22 \
  -vnc :0 \
  -monitor stdio

# Connect via VNC viewer (in another terminal)
vncviewer localhost:5900

# Or use SPICE for better performance
# Add to QEMU command: -spice port=5930,disable-ticketing
# Connect with: spicy -h localhost -p 5930

# Host CPU passthrough (best performance)
-cpu host

# Specific CPU model
-cpu Skylake-Client

# Multiple CPU cores and threads
-smp 8,cores=4,threads=2,sockets=1

# List available CPU models
qemu-system-x86_64 -cpu help

# 8GB RAM allocation
-m 8192

# 8GB with 2GB maximum hotplug
-m 8G,slots=4,maxmem=16G

# Enable memory ballooning
-device virtio-balloon-pci,id=balloon0

# VirtIO disk (best performance for Linux guests)
-drive file=vm.qcow2,format=qcow2,if=virtio

# IDE disk (broad compatibility)
-drive file=vm.qcow2,format=qcow2,if=ide

# Multiple disks
-drive file=system.qcow2,format=qcow2,if=virtio,index=0 \
-drive file=data.qcow2,format=qcow2,if=virtio,index=1

# Read-only disk
-drive file=shared-data.qcow2,format=qcow2,if=virtio,readonly=on

# Boot from hard disk
-boot order=c

# Boot from CD-ROM first, then hard disk
-boot order=dc,menu=on

# UEFI boot (requires OVMF)
-bios /usr/share/ovmf/OVMF.fd

# Enable USB support
-device qemu-xhci,id=xhci \
-device usb-tablet,bus=xhci.0

# Pass through USB device by vendor and product ID
-device usb-host,vendorid=0x1234,productid=0x5678

# List connected USB devices
lsusb

# Identify PCI device
lspci -nn | grep -i network

# Unbind from host driver and bind to VFIO
echo "0000:01:00.0" | sudo tee /sys/bus/pci/drivers/e1000e/unbind
echo "8086 10d3" | sudo tee /sys/bus/pci/drivers/vfio-pci/new_id

# Pass through to VM
-device vfio-pci,host=01:00.0

# VNC graphics (default)
-vnc :1

# SPICE graphics (better performance)
-spice port=5930,disable-ticketing \
-device qxl-vga,vgamem_mb=64

# No graphics (headless server)
-nographic

# Virtio GPU for 3D acceleration
-device virtio-vga-gl \
-display gtk,gl=on

#!/bin/bash
# production-vm-start.sh

VM_NAME="prod-web-server"
VM_DISK="/var/lib/libvirt/images/${VM_NAME}.qcow2"
ISO_FILE="/var/lib/libvirt/images/ubuntu-22.04-server.iso"
MEMORY="8192"
CPUS="4"
VNC_PORT="5901"

qemu-system-x86_64 \
  -name "${VM_NAME}" \
  -enable-kvm \
  -cpu host,kvm=on \
  -smp ${CPUS},cores=${CPUS},threads=1,sockets=1 \
  -m ${MEMORY} \
  -machine type=q35,accel=kvm \
  -drive file="${VM_DISK}",format=qcow2,if=virtio,cache=writeback \
  -device virtio-net-pci,netdev=net0,mac=52:54:00:12:34:56 \
  -netdev tap,id=net0,ifname=tap0,script=/etc/qemu-ifup \
  -device virtio-balloon-pci,id=balloon0 \
  -device virtio-rng-pci,rng=rng0 \
  -object rng-random,id=rng0,filename=/dev/urandom \
  -rtc base=utc,clock=host \
  -vnc :1 \
  -monitor unix:/var/run/qemu-${VM_NAME}.monitor,server,nowait \
  -pidfile /var/run/qemu-${VM_NAME}.pid \
  -daemonize

echo "VM ${VM_NAME} started on VNC port ${VNC_PORT}"
echo "Monitor socket: /var/run/qemu-${VM_NAME}.monitor"

# Always use KVM for same-architecture VMs
qemu-system-x86_64 -enable-kvm ...

# Alternative syntax
qemu-system-x86_64 -accel kvm ...

# Verify KVM is active inside VM
lscpu | grep Hypervisor
# Should show: Hypervisor vendor: KVM

# Pin vCPUs to specific physical cores
taskset -c 0-3 qemu-system-x86_64 \
  -enable-kvm \
  -cpu host \
  -smp 4 \
  -m 4096 \
  -drive file=vm.qcow2,format=qcow2,if=virtio

# Check CPU affinity
ps aux | grep qemu
taskset -cp <PID>

# Use host CPU model for best performance
-cpu host

# Enable all CPU features
-cpu host,+x2apic,+avx,+avx2

# List available CPU models
qemu-system-x86_64 -cpu help | less

# Check guest CPU features
# Inside VM:
cat /proc/cpuinfo | grep flags

# Use VirtIO for best I/O performance
-drive file=vm.qcow2,format=qcow2,if=virtio,cache=none,aio=native

# Multiple I/O threads
-drive file=vm.qcow2,format=qcow2,if=virtio,cache=none,aio=native \
-object iothread,id=iothread0 \
-device virtio-blk-pci,drive=drive0,iothread=iothread0

# Inside VM - test disk I/O
sudo apt install fio

# Random read/write test
fio --name=randrw --ioengine=libaio --iodepth=16 \
    --rw=randrw --bs=4k --direct=1 --size=1G \
    --numjobs=4 --runtime=60 --group_reporting

# Sequential write test
fio --name=seqwrite --ioengine=libaio --iodepth=32 \
    --rw=write --bs=1M --direct=1 --size=2G \
    --numjobs=1 --runtime=60 --group_reporting

# Enable huge pages on host
echo 1024 | sudo tee /proc/sys/vm/nr_hugepages

# Verify huge pages allocation
cat /proc/meminfo | grep -i huge

# Use huge pages in QEMU
qemu-system-x86_64 \
  -enable-kvm \
  -m 8192 \
  -mem-path /dev/hugepages \
  -mem-prealloc \
  -drive file=vm.qcow2,format=qcow2,if=virtio

# Enable memory ballooning device
-device virtio-balloon-pci,id=balloon0

# Inside VM - install balloon driver (usually automatic in modern kernels)
# On host - adjust VM memory dynamically
echo "balloon 4096" | socat - UNIX-CONNECT:/var/run/qemu-monitor.sock
echo "info balloon" | socat - UNIX-CONNECT:/var/run/qemu-monitor.sock

# Configure NUMA topology for multi-socket performance
qemu-system-x86_64 \
  -enable-kvm \
  -cpu host \
  -smp 16,cores=8,threads=2,sockets=1 \
  -m 32G \
  -numa node,memdev=mem0,cpus=0-7,nodeid=0 \
  -numa node,memdev=mem1,cpus=8-15,nodeid=1 \
  -object memory-backend-ram,size=16G,id=mem0 \
  -object memory-backend-ram,size=16G,id=mem1

# Use VirtIO network for best performance
-device virtio-net-pci,netdev=net0,mac=52:54:00:12:34:56 \
-netdev tap,id=net0,ifname=tap0,script=no,downscript=no,vhost=on

# Enable multi-queue VirtIO
-device virtio-net-pci,netdev=net0,mq=on,vectors=10 \
-netdev tap,id=net0,queues=4,vhost=on

# Install iperf3 on both host and guest
sudo apt install iperf3

# On host - start iperf3 server
iperf3 -s

# Inside VM - test throughput
iperf3 -c <host-ip> -t 60 -P 4

# Test latency with ping
ping -c 100 <host-ip> | tail -1

# Simple user mode networking with port forwarding
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm.qcow2,format=qcow2,if=virtio \
  -netdev user,id=net0,hostfwd=tcp::2222-:22,hostfwd=tcp::8080-:80 \
  -device virtio-net-pci,netdev=net0

# Access SSH from host
ssh -p 2222 user@localhost

# Access web server from host
curl http://localhost:8080

# Install bridge utilities
sudo apt install bridge-utils

# Create bridge configuration (Ubuntu with Netplan)
sudo nano /etc/netplan/01-bridge.yaml

network:
  version: 2
  ethernets:
    enp0s3:
      dhcp4: no
  bridges:
    br0:
      interfaces: [enp0s3]
      dhcp4: yes
      parameters:
        stp: false
        forward-delay: 0

# Apply bridge configuration
sudo netplan apply

# Verify bridge creation
ip addr show br0
brctl show

#!/bin/bash
# /etc/qemu-ifup
BRIDGE=br0
INTERFACE=$1

ip link set $INTERFACE up
brctl addif $BRIDGE $INTERFACE

#!/bin/bash
# /etc/qemu-ifdown
BRIDGE=br0
INTERFACE=$1

brctl delif $BRIDGE $INTERFACE
ip link set $INTERFACE down

sudo chmod +x /etc/qemu-ifup /etc/qemu-ifdown

# Start VM with bridged network
sudo qemu-system-x86_64 \
  -enable-kvm \
  -m 4096 \
  -cpu host \
  -smp 4 \
  -drive file=vm.qcow2,format=qcow2,if=virtio \
  -device virtio-net-pci,netdev=net0,mac=52:54:00:12:34:56 \
  -netdev tap,id=net0,ifname=tap0,script=/etc/qemu-ifup,downscript=/etc/qemu-ifdown \
  -vnc :0

# Verify TAP interface creation
ip link show tap0
brctl show br0

# Install VDE tools
sudo apt install vde2

# Start VDE switch
vde_switch -s /tmp/vde.ctl -daemon

# Connect VMs to VDE switch
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm1.qcow2,format=qcow2,if=virtio \
  -netdev vde,id=net0,sock=/tmp/vde.ctl \
  -device virtio-net-pci,netdev=net0,mac=52:54:00:11:11:11

# Second VM on same switch
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm2.qcow2,format=qcow2,if=virtio \
  -netdev vde,id=net0,sock=/tmp/vde.ctl \
  -device virtio-net-pci,netdev=net0,mac=52:54:00:22:22:22

# First VM (server)
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm1.qcow2,format=qcow2,if=virtio \
  -netdev socket,id=net0,listen=:1234 \
  -device virtio-net-pci,netdev=net0

# Second VM (client)
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm2.qcow2,format=qcow2,if=virtio \
  -netdev socket,id=net0,connect=:1234 \
  -device virtio-net-pci,netdev=net0

# Start VM with monitor on stdio
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm.qcow2,format=qcow2,if=virtio \
  -monitor stdio

# Or use Unix socket
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm.qcow2,format=qcow2,if=virtio \
  -monitor unix:/var/run/qemu-monitor.sock,server,nowait

# Connect to monitor socket
socat - UNIX-CONNECT:/var/run/qemu-monitor.sock

# Inside QEMU monitor:
(qemu) help                         # List all commands
(qemu) info status                  # Check VM status
(qemu) info cpus                    # Display CPU information
(qemu) info block                   # Show block devices
(qemu) info network                 # Display network devices
(qemu) info snapshots               # List snapshots
(qemu) info migrate                 # Migration status

# System control
(qemu) system_reset                 # Reboot VM
(qemu) system_powerdown             # Graceful shutdown
(qemu) stop                         # Pause VM
(qemu) cont                         # Resume VM
(qemu) quit                         # Terminate QEMU

# Snapshot management
(qemu) savevm snapshot1             # Create snapshot
(qemu) loadvm snapshot1             # Restore snapshot
(qemu) delvm snapshot1              # Delete snapshot

# Device hot-plugging
(qemu) device_add virtio-net-pci,netdev=net1,id=nic1
(qemu) device_del nic1

# Change removable media
(qemu) change ide1-cd0 /path/to/new.iso
(qemu) eject ide1-cd0

# Create internal snapshot
qemu-img snapshot -c snapshot1 vm.qcow2

# List existing snapshots
qemu-img snapshot -l vm.qcow2

# Apply snapshot (restore)
qemu-img snapshot -a snapshot1 vm.qcow2

# Delete snapshot
qemu-img snapshot -d snapshot1 vm.qcow2

# Get detailed snapshot information
qemu-img info vm.qcow2

# Create external snapshot (backing file)
qemu-img create -f qcow2 -b vm.qcow2 -F qcow2 vm-snapshot1.qcow2

# Use snapshot as active disk
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm-snapshot1.qcow2,format=qcow2,if=virtio

# Commit snapshot changes back to base
qemu-img commit vm-snapshot1.qcow2

# Create snapshot chain
qemu-img create -f qcow2 -b vm-snapshot1.qcow2 -F qcow2 vm-snapshot2.qcow2

#!/bin/bash
# /usr/local/bin/start-qemu-vm.sh

set -euo pipefail

VM_NAME="${1:-default-vm}"
VM_DIR="/var/lib/qemu/vms"
VM_DISK="${VM_DIR}/${VM_NAME}.qcow2"
PID_FILE="/var/run/qemu-${VM_NAME}.pid"
MONITOR_SOCK="/var/run/qemu-${VM_NAME}.monitor"
MEMORY="${2:-2048}"
CPUS="${3:-2}"
VNC_PORT="${4:-0}"

# Check if VM is already running
if [ -f "$PID_FILE" ]; then
    PID=$(cat "$PID_FILE")
    if kill -0 "$PID" 2>/dev/null; then
        echo "Error: VM $VM_NAME is already running (PID: $PID)"
        exit 1
    fi
    rm -f "$PID_FILE"
fi

# Verify disk image exists
if [ ! -f "$VM_DISK" ]; then
    echo "Error: VM disk $VM_DISK not found"
    exit 1
fi

echo "Starting VM: $VM_NAME"
echo "  Memory: ${MEMORY}MB"
echo "  CPUs: $CPUS"
echo "  VNC: localhost:${VNC_PORT}"

qemu-system-x86_64 \
    -name "$VM_NAME" \
    -enable-kvm \
    -cpu host \
    -smp "$CPUS" \
    -m "$MEMORY" \
    -drive file="$VM_DISK",format=qcow2,if=virtio,cache=writeback \
    -device virtio-net-pci,netdev=net0,mac=52:54:00:$(od -An -N3 -tx1 /dev/urandom | tr -d ' ') \
    -netdev tap,id=net0,script=/etc/qemu-ifup,downscript=/etc/qemu-ifdown \
    -device virtio-balloon-pci \
    -rtc base=utc,clock=host \
    -vnc ":${VNC_PORT}" \
    -monitor unix:"$MONITOR_SOCK",server,nowait \
    -pidfile "$PID_FILE" \
    -daemonize

# Verify startup
sleep 2
if [ -f "$PID_FILE" ]; then
    PID=$(cat "$PID_FILE")
    if kill -0 "$PID" 2>/dev/null; then
        echo "VM started successfully (PID: $PID)"
        echo "Monitor: $MONITOR_SOCK"
        echo "VNC: vncviewer localhost:$((5900 + VNC_PORT))"
        exit 0
    fi
fi

echo "Error: Failed to start VM"
exit 1

#!/bin/bash
# /usr/local/bin/stop-qemu-vm.sh

set -euo pipefail

VM_NAME="${1:-}"
MONITOR_SOCK="/var/run/qemu-${VM_NAME}.monitor"
PID_FILE="/var/run/qemu-${VM_NAME}.pid"
TIMEOUT=60

if [ -z "$VM_NAME" ]; then
    echo "Usage: $0 <vm-name>"
    exit 1
fi

# Check if VM is running
if [ ! -f "$PID_FILE" ]; then
    echo "VM $VM_NAME is not running"
    exit 0
fi

PID=$(cat "$PID_FILE")
if ! kill -0 "$PID" 2>/dev/null; then
    echo "VM $VM_NAME PID file exists but process not found"
    rm -f "$PID_FILE" "$MONITOR_SOCK"
    exit 0
fi

echo "Stopping VM: $VM_NAME (PID: $PID)"

# Try graceful shutdown via monitor
if [ -S "$MONITOR_SOCK" ]; then
    echo "system_powerdown" | socat - UNIX-CONNECT:"$MONITOR_SOCK" 2>/dev/null || true

    # Wait for shutdown
    for i in $(seq 1 $TIMEOUT); do
        if ! kill -0 "$PID" 2>/dev/null; then
            echo "VM stopped gracefully"
            rm -f "$PID_FILE" "$MONITOR_SOCK"
            exit 0
        fi
        sleep 1
    done

    echo "Timeout waiting for graceful shutdown"
fi

# Force termination
echo "Forcing VM termination..."
kill -TERM "$PID" 2>/dev/null || true
sleep 2

if kill -0 "$PID" 2>/dev/null; then
    kill -KILL "$PID" 2>/dev/null || true
fi

rm -f "$PID_FILE" "$MONITOR_SOCK"
echo "VM terminated"

sudo chmod +x /usr/local/bin/start-qemu-vm.sh
sudo chmod +x /usr/local/bin/stop-qemu-vm.sh

# Usage examples
sudo /usr/local/bin/start-qemu-vm.sh webserver 4096 4 1
sudo /usr/local/bin/stop-qemu-vm.sh webserver

# Convert QCOW2 to RAW
qemu-img convert -f qcow2 -O raw source.qcow2 destination.raw

# Convert VMDK to QCOW2
qemu-img convert -f vmdk -O qcow2 vmware.vmdk qemu.qcow2

# Compress during conversion
qemu-img convert -f qcow2 -O qcow2 -c original.qcow2 compressed.qcow2

# Intel CPUs
echo "options kvm_intel nested=1" | sudo tee /etc/modprobe.d/kvm.conf
sudo modprobe -r kvm_intel && sudo modprobe kvm_intel

# AMD CPUs
echo "options kvm_amd nested=1" | sudo tee /etc/modprobe.d/kvm.conf
sudo modprobe -r kvm_amd && sudo modprobe kvm_amd

# Then expose CPU virtualization features to guest
qemu-system-x86_64 -enable-kvm -cpu host,vmx=on ...

# Shut down VM and copy disk image (safest)
qemu-img convert -f qcow2 -O qcow2 vm.qcow2 backup.qcow2

# Create external snapshot for live backup
qemu-img create -f qcow2 -b vm.qcow2 -F qcow2 snapshot.qcow2
# Backup original vm.qcow2 while VM runs from snapshot
# Then commit snapshot: qemu-img commit snapshot.qcow2

# Use rsync for incremental backups
rsync -avP /var/lib/qemu/vms/ /backup/qemu/

# Check CPU virtualization support
egrep -c '(vmx|svm)' /proc/cpuinfo
# Should return non-zero value

# Check if KVM modules are loaded
lsmod | grep kvm

# Verify KVM device exists
ls -la /dev/kvm

# Test KVM accessibility
kvm-ok

# Enable virtualization in BIOS/UEFI first!

# Load KVM modules
sudo modprobe kvm
sudo modprobe kvm_intel  # or kvm_amd

# Fix permissions on /dev/kvm
sudo usermod -aG kvm $USER
newgrp kvm

# Verify access
[ -r /dev/kvm ] && [ -w /dev/kvm ] && echo "KVM accessible" || echo "KVM not accessible"

# Inside VM - check network interface
ip addr show
ip route show

# Check if VM received DHCP address (user mode networking)
cat /etc/resolv.conf

# On host - verify TAP interface (bridged networking)
ip link show tap0
brctl show br0

# Test connectivity from VM
ping -c 4 8.8.8.8
ping -c 4 google.com

# Restart VM with proper port forwarding
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm.qcow2,format=qcow2,if=virtio \
  -netdev user,id=net0,hostfwd=tcp::2222-:22,dns=8.8.8.8 \
  -device virtio-net-pci,netdev=net0

# Inside VM - verify networking
sudo dhclient eth0
systemctl restart systemd-networkd

# Recreate bridge on host
sudo ip link del br0
sudo ip link add name br0 type bridge
sudo ip link set enp0s3 master br0
sudo ip link set br0 up
sudo dhclient br0

# Fix TAP interface scripts
sudo chmod +x /etc/qemu-ifup /etc/qemu-ifdown

# Restart VM with sudo for TAP access
sudo qemu-system-x86_64 ...

# Check image for corruption
qemu-img check vm.qcow2

# Get detailed image information
qemu-img info vm.qcow2

# Verify file system integrity (if RAW format)
sudo fsck -f /dev/nbd0p1  # After mounting with qemu-nbd

# Attempt automatic repair
qemu-img check -r all vm.qcow2

# If repair fails, recover data to new image
qemu-img convert -f qcow2 -O qcow2 corrupted.qcow2 recovered.qcow2

# Restore from backup if available
cp backup-vm.qcow2 vm.qcow2

# Mount image with NBD to recover files
sudo modprobe nbd max_part=8
sudo qemu-nbd -c /dev/nbd0 vm.qcow2
sudo mount /dev/nbd0p1 /mnt/recovery
# Copy important files
sudo umount /mnt/recovery
sudo qemu-nbd -d /dev/nbd0

# Check overall system load
top
htop

# Identify QEMU processes
ps aux | grep qemu

# Check CPU usage per VM
top -p $(pgrep -d',' qemu)

# Verify KVM is being used
grep -i kvm /proc/$(pgrep qemu)/cmdline

# Ensure KVM acceleration is enabled
# Check QEMU command includes -enable-kvm

# Limit VM CPU usage with cgroups
sudo cgcreate -g cpu:/qemu-vms
sudo cgset -r cpu.shares=512 qemu-vms
sudo cgclassify -g cpu:qemu-vms $(pgrep qemu)

# Pin QEMU to specific CPU cores
taskset -c 0-3 qemu-system-x86_64 ...

# Reduce VM CPU count if overcommitted
# Change -smp 8 to -smp 4 in VM configuration

# Check if QEMU is listening on VNC port
sudo netstat -tlnp | grep qemu
sudo ss -tlnp | grep qemu

# Verify VNC display number
ps aux | grep qemu | grep vnc

# Test VNC port accessibility
telnet localhost 5900  # For VNC :0

# Restart VM with correct VNC settings
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm.qcow2,format=qcow2,if=virtio \
  -vnc :0,password  # Listen on all interfaces: -vnc 0.0.0.0:0

# Set VNC password in monitor
# Connect to QEMU monitor and run:
change vnc password
# Enter password when prompted

# Allow VNC through firewall
sudo ufw allow 5900/tcp
sudo firewall-cmd --add-port=5900/tcp --permanent

# Use SSH tunnel for remote access
ssh -L 5900:localhost:5900 user@remote-host
vncviewer localhost:5900

# Check monitor socket exists
ls -la /var/run/qemu-*.monitor

# Verify socket is accessible
file /var/run/qemu-vm.monitor

# Test socket connection
echo "info status" | socat - UNIX-CONNECT:/var/run/qemu-vm.monitor

# Restart VM with proper monitor configuration
qemu-system-x86_64 \
  -enable-kvm \
  -m 2048 \
  -drive file=vm.qcow2,format=qcow2,if=virtio \
  -monitor unix:/var/run/qemu-vm.monitor,server,nowait

# Fix socket permissions
sudo chmod 660 /var/run/qemu-vm.monitor
sudo chown $USER:kvm /var/run/qemu-vm.monitor

# Alternative: use stdio monitor
# Start with: -monitor stdio
# Monitor appears in QEMU process terminal

Feature	QEMU System Emulation	VirtualBox
Architecture Support	Multiple CPU architectures	x86/x86_64 only
Performance with KVM	Near-native speed	Good, but proprietary extensions
GUI Management	Command-line focused	User-friendly GUI
Licensing	GPL (fully open source)	GPL with proprietary additions
Use Case	Professional/embedded development	Desktop virtualization

Format	Snapshot Support	Compression	Encryption	Performance	Best Use Case
QCOW2	Yes	Yes	Yes	Good	General purpose, development
RAW	No	No	No	Excellent	Production, performance-critical
VMDK	Limited	No	No	Good	VMware migration
VDI	Limited	No	No	Good	VirtualBox migration
VHD/VHDX	Limited	No	No	Good	Hyper-V compatibility

Cache Mode	Host Cache	Guest Cache	Performance	Data Safety	Use Case
writeback	Yes	Yes	Best	Lower	Development/testing
writethrough	Yes	No	Good	Medium	General purpose
none	No	No	Medium	Best	Production databases
directsync	No	No	Lower	Highest	Critical data
unsafe	Yes	Yes	Highest	Lowest	Disposable VMs

Knowledge Overview

Prerequisites

Time Investment

Guide Content

Understanding QEMU System Emulation

Table of Contents

What is QEMU System Emulation and How Does It Differ from Other Virtualization?

Core QEMU Architecture

QEMU vs Other Virtualization Technologies

How Does QEMU System Emulation Work with KVM Acceleration?

The QEMU/KVM Integration Model

CPU Virtualization Modes

Memory Management in QEMU

How to Install QEMU on Major Linux Distributions?

Ubuntu/Debian Installation

Red Hat/CentOS/Fedora Installation

Arch Linux Installation

Post-Installation Configuration

What Are QEMU Image Formats and Which Should You Choose?

QCOW2: QEMU Copy-On-Write Version 2

RAW Format: Maximum Performance

VMDK and VDI: Cross-Platform Compatibility

Image Format Comparison Table

Advanced Image Management

How to Create and Configure Virtual Machines with QEMU?

Basic VM Creation Workflow

Essential QEMU Command-Line Options

Advanced VM Configuration

Creating Production-Ready VMs

How to Optimize QEMU System Emulation Performance?

CPU Performance Tuning

Storage I/O Optimization

Memory Optimization

Network Performance Tuning

What Networking Modes Does QEMU Support?

User Mode Networking (SLIRP)

TAP/Bridge Networking

VDE (Virtual Distributed Ethernet)

Socket Networking

How to Manage QEMU Virtual Machines Effectively?

QEMU Monitor Console

Snapshot Management

Automation Scripts

FAQ

What is the difference between QEMU and KVM?

Can QEMU run virtual machines without KVM?

What is the best disk image format for QEMU?

How do I convert between different VM image formats?

Can I run multiple VMs simultaneously with QEMU?

How do I enable nested virtualization in QEMU?

What's the recommended memory size for QEMU VMs?

How do I backup QEMU virtual machines?

Why is my QEMU VM running slowly?

Troubleshooting Common QEMU Issues

KVM Acceleration Not Available

Network Connectivity Problems

Disk Image Corruption

High CPU Usage on Host

VNC Connection Refused

QEMU Monitor Not Responding

Additional Resources

Official Documentation and References

Community Forums and Support

Related LinuxTips.pro Articles

Books and In-Depth Learning

Tools and Utilities

Conclusion