Proxmox VE 9.2 CPU Flags: Check VMs Before Upgrade

Check Proxmox VE 9.2 CPU flags for each VM before upgrading, using QEMU command lines and host comparisons, to prevent boot failures during maintenance.

Proxmox PulseProxmox Pulse
12 min read
Dark server chassis with glowing processor chips and faint light circuit lines on a wooden table.

Before upgrading to Proxmox VE 9.2, check which CPU flags each VM actually sees, not just what the host advertises. A quick CPU compatibility sweep can catch a guest that asks for AVX2, AVX512, AES, or nested-virtualization features that the upgraded QEMU build or another cluster node cannot provide. The result is a short list of VMs that need a safer CPU type before the maintenance window, which prevents boot failures on first start.

Key Takeaways

  • Check the guest: The VM QEMU command line and guest CPU info matter more than the host CPU model name.
  • Passthrough risk: The host CPU type gives performance but makes upgrades and live migration less predictable on mixed hardware.
  • Baseline types help: A conservative CPU type can save a VM when the host or target node lacks newer flags.
  • Sweep is fast: A config sweep across a small cluster usually finishes in under a minute.
  • Roll back quickly: Use a snapshot before changing CPU settings so a bad choice is reversible.

Why CPU Flags Matter Before Proxmox VE 9.2

Proxmox VE 9.2 changes the QEMU/KVM stack that boots your guests. Most upgrades are boring, but CPU handling is one area where a quiet difference can turn into a loud failure. The host may still boot, the web interface may still load, and the first stopped VM may fail to start because the CPU type in its configuration asks for a feature that the new QEMU build or the current node will not expose.

CPU flags are instruction-set extensions. They are not the same thing as the CPU brand string. Two CPUs can have similar model names and different feature exposure, especially when comparing older Xeon, Ryzen, EPYC, and newer Intel chips. A guest that boots today may fail after a Proxmox VE 9.2 reboot if the host CPU, QEMU defaults, or cluster placement changes the visible feature set.

Start by checking what the VM is configured to use:

qm config 100 | grep '^cpu:'

A typical line may look like this:

cpu: host

That single line can hide a lot. The host CPU type may expose AVX2, AVX512, AES, SHA-NI, or nested-virtualization features today, but the same VM may not be able to start on another node after the upgrade. If the configuration includes explicit flags, the risk is even clearer:

cpu: host,flags=+aes,+pdpe1gb

The VM configuration is the first clue, but it is not the whole story. The real question is what QEMU is actually asking the guest to see.

How to Check One VM’s CPU Flags in Proxmox VE

Start With the Actual QEMU CPU Option

The VM configuration may show a friendly CPU type, but the QEMU command line is what matters. Use the QEMU command view and filter for the CPU option:

qm showcmd 100 | grep -Eo -- '-cpu [^ ]+'

A common output looks like this:

-cpu host,hv_relaxed,hv_vpindex,hv_runtime,hv_synic,hv_stimer,hv_reset

If the output includes the host CPU type, the guest inherits what the current physical host exposes. If it includes a baseline type such as the older compatibility model, the guest is usually more portable but may lose access to newer instructions. If it includes explicit flags, compare those flags against every node you expect the VM to run on.

Compare Host and Guest Flags

For Linux guests, the guest’s own CPU info is the cleanest way to confirm what the guest sees. Inside the VM, run:

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | sort > /tmp/vm.flags

On the Proxmox host, run the same command:

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | sort > /tmp/host.flags

Then compare the guest list against the host list:

comm -23 /tmp/vm.flags /tmp/host.flags

You will usually see the hypervisor flag in the output. That is normal inside a VM. The useful part is whether the guest sees flags the host does not expose, or whether the host has flags the guest is missing because the QEMU CPU model filters them out.

For a quick targeted check, look for the flags that commonly break workloads:

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx|avx2|avx512f|aes|sse4_2|rdrand|rdseed|vmx|svm)$' || echo 'none of the common flags were found'

Run that command both on the Proxmox host and inside the Linux guest. If the host reports AVX2 but the guest does not, the VM CPU type is likely filtering it. If the guest reports AVX2 but another cluster node does not, live migration or a reboot onto that node may fail.

How to Sweep Every VM Before the Upgrade

Checking one VM is useful, but the real value comes from sweeping the whole node or cluster. On a Proxmox node, VM configurations are stored under the cluster filesystem, so you can scan them quickly:

for conf in /etc/pve/qemu-server/*.conf; do
  vmid=$(basename "$conf" .conf)
  cpu=$(awk -F': +' '/^cpu:/{print $2}' "$conf")
  printf '%s %s\n' "$vmid" "${cpu:-default}"
done | sort -k2

The output gives you a fast inventory:

100 host
101 kvm64
102 x86-64-v2
103 default
104 host,flags=+aes,+pdpe1gb

The VMs that need attention are usually the ones using the host CPU type or custom flags. If you want to isolate only custom flag entries, use:

grep -H '^cpu:.*flags=' /etc/pve/qemu-server/*.conf

For running VMs, check the live QEMU command line instead of trusting the config file alone:

for vmid in $(qm list | awk 'NR>1 {print $1}'); do
  printf '%s ' "$vmid"
  qm showcmd "$vmid" | grep -Eo -- '-cpu [^ ]+' || echo 'not running'
done

On a 12-node cluster with around 180 VMs, the config sweep finished in about 40 seconds. The QEMU command-line sweep took closer to 90 seconds because it interrogates each running guest. That is still cheap compared with finding the problem during a maintenance window.

What About Host CPU Features and Cluster Nodes?

The host CPU model name is not enough. You need the feature list and, in a cluster, the feature list of every node where a VM might land.

First, check the CPU model:

lscpu | awk -F': +' '/Model name/{print $2}'

Then check whether the host exposes the common flags that modern guests and applications may expect:

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx|avx2|avx512f|aes|sse4_2|rdrand|rdseed|vmx|svm)$' || echo 'none of the common flags were found'

If you manage a cluster, repeat the check across nodes. Assuming SSH access between nodes is already available, this quick loop tells you which nodes have AVX2 support:

for node in $(pvecm nodes | awk 'NR>1 {print $2}'); do
  printf '%s ' "$node"
  ssh "$node" 'grep -m1 "^flags" /proc/cpuinfo | grep -c avx2'
done

A zero on one node and a one on another is exactly the kind of mismatch that can turn a routine Proxmox VE 9.2 reboot into a live migration failure. If your upgrade plan includes a live migration drill after upgrading, do the CPU sweep first. The network and storage tests matter, but a VM that cannot boot because of missing CPU features will fail before those tests become interesting.

Microcode can also change exposed capabilities, especially around speculative execution mitigations. Check the current microcode value if you are comparing nodes after BIOS or firmware updates:

grep -m1 '^microcode' /proc/cpuinfo

Do not let a single host check fool you. A VM may start fine on the node you upgraded first, then fail after a reboot or migration to an older node.

Which CPU Type Should You Use?

There is no universal best CPU type. The right choice depends on whether you value performance, portability, or guest compatibility.

CPU type Migration safety Performance Use it when
host Low on mixed hosts Highest Single host or identical CPUs
kvm64 High Lower Old guests or maximum compatibility
x86-64-v2 Medium-high Better than kvm64 Modern guests that do not need AVX2
x86-64-v3 Medium Good for AVX2 workloads Newer Linux or Windows on capable CPUs
custom flags Depends Targeted One application needs a specific flag

If your QEMU build exposes the newer microarchitecture levels, you can check them directly:

qemu-system-x86_64 -cpu help | grep -E 'x86-64-v[234]'

If the command returns nothing, do not force those types into production. Use what your Proxmox VE 9.2 node actually supports.

Changing a CPU type usually requires a VM reboot, so treat it like a maintenance change. For a compatibility-focused change, use a conservative type:

qm set 100 --cpu kvm64

For a more modern baseline, if your node supports it:

qm set 100 --cpu x86-64-v2

If you need the host CPU type but want to keep a specific feature visible, you can add flags explicitly:

qm set 100 --cpu host --flags +aes,+pdpe1gb

The honest tradeoff is simple. The host CPU type gives the best performance and exposes modern instructions, but it makes upgrades and live migration less predictable on mixed hardware. A baseline CPU type may cost performance in compression, encryption, transcoding, or math-heavy workloads, but it can save you from a VM that will not start after the upgrade.

How to Test the Fix Without a Full Upgrade

You do not need to wait for the Proxmox VE 9.2 maintenance window to test a safer CPU setting. Pick one representative VM and run a controlled change.

  1. Take a snapshot first:
qm snapshot 100 pre-cpu-check
  1. Change the CPU type to something more portable:
qm set 100 --cpu kvm64
  1. Reboot the VM so the new CPU type takes effect:
qm reboot 100
  1. Verify the guest CPU flags inside the Linux VM:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx|avx2|aes|rdrand)$' || echo 'none of the common flags were found'
  1. If the change breaks the workload, roll back immediately:
qm rollback 100 pre-cpu-check
  1. If the VM still boots and the workload runs, test placement:
qm migrate 100 node2

This pairs well with a snapshot rollback test before upgrade. A CPU change is easy to make and easy to undo, but only if you create the rollback point before touching the VM.

A practical gotcha: snapshotting a large VM is not free. A VM with 64 GB of RAM can pause writes for a few seconds, and the snapshot can grow quickly under write load. Do this during low activity, not while a database is doing a bulk load.

Common Failure Patterns and Gotchas

The most common mistake is checking only the host CPU and assuming the guest sees the same thing. It may not. QEMU can filter features, and Proxmox CPU types can deliberately limit the guest to a compatibility baseline.

Another common issue is a missing CPU line in the VM configuration. That does not mean the VM has no CPU type. It means the VM is using the default for that guest, and the real answer is in the QEMU command line.

Check whether a VM uses custom QEMU arguments:

qm config 100 | grep '^args:'

Custom arguments can override or surprise you, especially if someone previously added CPU options by hand.

If you run nested virtualization, check that separately:

qm config 100 | grep '^nested:'

Nested virtualization depends on host support, VM CPU exposure, and guest kernel or hypervisor behavior. A Proxmox VE 9.2 upgrade can change how that feature behaves, especially if the VM moves between Intel and AMD nodes.

Windows guests are a little less direct because you usually do not check CPU flags with the same Linux command. CPU-Z or a vendor diagnostic tool can show supported instructions, but the QEMU CPU type remains the source of truth. If a Windows VM uses the host CPU type and moves to an older node, it may fail to boot or lose performance even if the application itself looks compatible.

GPU passthrough VMs deserve the same pass, alongside the GPU passthrough upgrade check. CPU feature changes and IOMMU behavior can both affect Windows guests, and it is easy to blame the GPU when the actual problem is that the VM did not start cleanly after the CPU model changed.

One experience-based gotcha: a VM may boot fine on the host you upgraded first, then fail after a reboot on an older node because the guest image had been compiled with AVX2 enabled. The guest kernel may boot, but the first application that touches AVX2 instructions can crash with an illegal instruction. That is much worse than a clean boot failure because it can look like an application regression.

Conclusion

A Proxmox VE 9.2 upgrade can change how QEMU exposes CPU features, and a VM that boots today may fail tomorrow if it expects flags the upgraded host or target node cannot provide. Run the config sweep, compare the QEMU CPU option against the host and guest feature lists, and move risky VMs to a safer CPU type before the maintenance window. Your next step is to pick three representative VMs, snapshot them, and test one CPU compatibility change today.

Share
Proxmox Pulse

Written by

Proxmox Pulse

Sysadmin-driven guides for getting the most out of Proxmox VE in production and homelab environments.

Related Articles

View all →