简体中文
EnglishWebsite review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is KVM?
KVM (Kernel-based Virtual Machine) is an open-source full virtualization solution for Linux on x86 hardware that includes virtualization extensions (Intel VT or AMD-V). It runs as a loadable kernel module — kvm.ko for the core infrastructure, plus a processor-specific module such as kvm-intel.ko or kvm-amd.ko — and lets you run multiple virtual machines with unmodified Linux or Windows images. Each VM gets its own virtualized hardware, including a network card, disk and graphics adapter. The kernel component has been part of mainline Linux since 2.6.20, and the userspace component has been part of mainline QEMU since 1.3, per KVM.
What that means in practice
- You need both halves. KVM provides the kernel-level virtualization; a userspace program such as QEMU supplies the emulated devices and VM management. The project's own documentation covers management tools, migration and a HOWTO section.
- Hardware is the gate. The CPU must expose VT or AMD-V, so check that before planning a deployment.
- Guest flexibility is the point. Because guests run unmodified, the same host can serve Linux and Windows workloads side by side.
Who it suits
Administrators and developers already on Linux who want a hypervisor built into the kernel rather than bolted on, and who are comfortable assembling kernel modules, QEMU and tooling. If you prefer a single packaged management layer, the KVM documentation's management-tools pages are the right starting point.
Next step: confirm your CPU supports VT/AMD-V, then read the project's HOWTO and Downloads pages at KVM before installing.
Do I need Intel VT or AMD-V to run KVM on my Linux server?
Yes. KVM requires a processor with hardware virtualization extensions—either Intel VT (VT-x) or AMD-V—because it builds on those CPU features rather than emulating them in software. On a server without them, KVM itself won't run; you'd need a different virtualization approach or different hardware.
What to check on your server
- Confirm the CPU supports it. On Linux, look for
vmx(Intel) orsvm(AMD) in/proc/cpuinfo, or checklscpufor a "Virtualization" line. - Confirm it's enabled in firmware. VT-x and AMD-V are often disabled by default in BIOS/UEFI. If the CPU supports it but
/proc/cpuinfoshows nothing, enable it in firmware settings and reboot. - Check nested virtualization if the server is itself a VM. Running KVM inside another VM requires the host to expose these extensions to the guest; otherwise KVM won't start.
Practical implications
A server that passes all three checks can run unmodified Linux or Windows guest images, each with its own virtual network card, disk and graphics adapter, as described on KVM. A server that fails step 1 is the hard stop—no amount of configuration fixes missing CPU features. Failing step 2 is usually a quick firmware change. Failing step 3 means talking to your cloud or hosting provider about whether nested virtualization is offered on that instance type.
If you're evaluating hardware for a new host, treat VT-x/AMD-V support as a baseline requirement and verify it before purchase rather than after.
How do I check if KVM is available and enabled on my system?
Check whether the CPU exposes virtualization extensions and whether the KVM kernel modules are loaded; then confirm you can create a VM with a hypervisor that uses KVM. The KVM project's own page describes KVM as a full-virtualization solution for Linux on x86 hardware with Intel VT or AMD-V, built from a core kvm.ko module plus a processor-specific kvm-intel.ko or kvm-amd.ko module, with the kernel part in mainline Linux and the userspace part in mainline QEMU KVM. That description tells you exactly what to look for.
Quick checks
- CPU support. On Linux, look for
vmx(Intel) orsvm(AMD) in/proc/cpuinfo, or runlscpuand check the virtualization flags. No flag usually means virtualization is disabled in firmware or unsupported. - Firmware setting. If the flag is missing, reboot into BIOS/UEFI and enable Intel VT-x / AMD-V (sometimes labeled "Virtualization Technology" or "SVM Mode").
- Kernel modules. Run
lsmod | grep kvm. You should seekvmpluskvm_intelorkvm_amd. If not, trysudo modprobe kvm_intel(orkvm_amd) and checkdmesgfor errors. - Device node. Confirm
/dev/kvmexists and that your user has access to it (group membership is a common stumbling block). - End-to-end test. Start a VM in QEMU with KVM acceleration (for example,
qemu-system-x86_64 -accel kvm ...) or check that libvirt reports KVM as the domain type. A VM that boots with KVM acceleration is the real proof.
What the results mean
| Symptom | Likely cause | Next step |
|---|---|---|
No vmx/svm flag |
Virtualization disabled in firmware, or CPU lacks it | Enable in BIOS/UEFI; if still absent, hardware doesn't support KVM |
Flag present, no kvm module |
Module not loaded or kernel built without it | modprobe, then inspect dmesg |
Module loads but /dev/kvm missing |
Permissions or device setup issue | Check group membership and udev rules |
| Everything present, VM still slow | Hypervisor not actually using KVM | Verify the accelerator flag in your VM command or libvirt XML |
A practical scenario: you're setting up a Linux workstation to run Windows test machines. Start with lscpu and lsmod; if both look right, create one throwaway VM with explicit KVM acceleration before investing time in disk images and networking. If you hit module errors, the KVM project's HOWTO and FAQ sections are the natural place to dig into specifics KVM.
What is the difference between KVM and QEMU, and do I need both?
KVM is the Linux kernel's virtualization layer; QEMU is the userspace emulator that typically provides a virtual machine's hardware and devices. In the common setup you use both: KVM supplies hardware-accelerated execution for the guest CPU, while QEMU creates and runs the virtual machine around it. The KVM project describes itself as a full virtualization solution for Linux on x86 hardware with Intel VT or AMD-V, built from a kernel module (kvm.ko plus a processor-specific module) and paired with a userspace component that has shipped in mainline QEMU since version 1.3, per KVM.
What each part does
| Component | Role | What happens without it |
|---|---|---|
| KVM | Kernel module providing virtualization infrastructure and CPU virtualization extensions | Guests run under QEMU's software emulation: functional but much slower for CPU-heavy work |
| QEMU | Userspace program that defines the virtual machine: virtual network card, disk, graphics adapter and other devices | No virtual machine process to configure, start or manage |
KVM's own documentation notes that each virtual machine gets private virtualized hardware such as a network card, disk and graphics adapter — those devices are the QEMU side of the stack, not the kernel module.
Do you need both?
For a practical Linux host running full virtual machines, yes — install KVM support and use QEMU (often through a management tool such as libvirt) as the front end. The KVM site lists management tools and migration among its topics, which reflects that real deployments rarely drive QEMU by hand. A concrete scenario: a small team wants several isolated Linux and Windows guests on one server. KVM gives near-native CPU speed; QEMU gives each guest its disks, network and display; libvirt or a similar tool makes starting, stopping and migrating them manageable.
You can skip one only in narrower cases. If you need to emulate a different CPU architecture, or run on hardware without VT/AMD-V, QEMU alone works but performance drops. If you only need lightweight OS-level containers rather than full virtual machines with their own virtual hardware, neither is the right tool.
Next step
Check your CPU for Intel VT or AMD-V and confirm the kvm modules load; then install QEMU and a management layer, and create one test guest before migrating anything production. As a decision rule: choose the KVM-plus-QEMU stack when you need full, hardware-accelerated virtual machines with flexible virtual devices; choose QEMU-only when architecture emulation matters more than speed.
How do I migrate a running virtual machine from one KVM host to another?
Live migration of a running KVM guest is handled by the userspace management layer, not by the KVM kernel module itself. The KVM project's own documentation describes KVM as the kernel component (kvm.ko plus the Intel or AMD processor module) and notes that the userspace side ships inside mainline QEMU. That split matters for your question: the migration mechanics live in QEMU and in tools such as libvirt, so look there for the actual procedure rather than expecting a kernel-side switch.
What the moving parts do
- QEMU implements the migration stream: it copies guest RAM, device state and CPU state to the destination while the guest keeps running, then briefly pauses it to transfer the remainder and switch over.
- libvirt wraps that into
virsh migrate, which is what most operators actually type. The KVM wiki's own article list includes "Running libvirt with KVM," which is the right starting point if you are managing guests through libvirt. - Shared storage (NFS, iSCSI, Ceph, or similar) means the disk does not move; only memory and device state do. Without shared storage you need block migration, which copies the disk too and is much slower and more fragile.
A practical sequence
- Confirm both hosts run compatible KVM/QEMU versions and the same CPU feature baseline, otherwise the destination may refuse the incoming guest.
- Make sure the guest's disk is visible at the same path on both hosts, or plan for block migration.
- Check that the destination has enough free RAM and that the network between hosts has bandwidth well above the guest's dirty-page rate; a busy guest on a slow link will never converge.
- Run the migration, watch it complete, then verify the guest is responsive on the new host before doing anything to the old one.
Deciding between live and offline
| Situation | Sensible approach |
|---|---|
| Maintenance on one host, guest must stay up | Live migration with shared storage |
| No shared storage available | Live migration with block migration, or shut down and copy the disk if downtime is acceptable |
| Guest is I/O-heavy and the link is thin | Schedule a maintenance window; live migration may stall |
| Moving to different hardware generations | Check CPU model compatibility first; you may need to pin a baseline CPU model |
For host-level planning and feature status, the project's own pages at KVM cover migration among their listed topics, and the QEMU documentation covers the migration protocol and its options in detail.
Which management tools like libvirt can I use to create and control KVM virtual machines?
KVM itself provides the kernel-level virtualization layer; creating and controlling virtual machines is done through userspace tools that talk to KVM, so the practical answer is to pick a management layer that matches how much automation and multi-host control you need. The KVM project's own site points to libvirt as a common management route and lists a "Management Tools" section alongside its HOWTO and download pages on KVM.
Common management layers
- libvirt — the standard abstraction layer, with
virshas its command-line client. Good for scripted VM creation, XML-defined hardware, snapshots and lifecycle control; it also underpins many graphical front ends. - virt-manager — a desktop GUI built on libvirt, suited to a workstation or single host where you want to click through VM creation and console access.
- oVirt / Proxmox VE — cluster-level platforms for managing many hosts, storage and migration; heavier to run but useful when one machine is no longer enough.
- QEMU command line directly — the most transparent option for learning exactly what hardware a guest receives, but you manage configuration yourself.
| Tool | Best for | Trade-off |
|---|---|---|
libvirt + virsh |
Repeatable, scripted VM management | XML configuration has a learning curve |
| virt-manager | Single-host desktop use | Less suited to large fleets |
| Cluster platforms | Many hosts, shared storage, migration | Significant setup and maintenance overhead |
A practical next step: start with libvirt and virsh on one host, define a test VM in XML, and only move to a cluster platform once you actually need multiple hosts. The KVM site's HOWTO and documents pages are the sensible starting reference for that first setup.
NS1
User reviews (0)