Easy way to determine the virtualization technology of a Linux machine?

Question

I have command line access to a Linux machine which may or may not be virtualized. I want to determine what kind of virtualization technology it runs on, if any (VMWare, VirtualBox, KVM, OpenVZ, Xen, ). This isn't a hostile environment: I'm not trying to work against a VM that is trying to disguise itself, I'm diagnosing a flaky server that I know little about.

More precisely, I'm helping someone diagnose the issue, I'm not sitting at the helm. So I have to convey instructions like “copy-paste this command” and not “poke around /proc somewhere”. Ideally, it would be something like lshw: an easily-installable (if not preinstalled) command that does the poking around and prints out relevant information.

What's the easiest way of determining what virtualization technology this system may be a guest of? I'd appreciate if proposals mentioned which technologies (including bare hardware) can be conclusively detected and which can be conclusively eliminated. I'm mostly interested in Linux, but if it also works for other unices that's nice.

Answer 1

dmidecode -s system-product-name

I have tested on Vmware Workstation, VirtualBox, QEMU with KVM, standalone QEMU with Ubuntu as the guest OS. Others have added additional platforms that they're familiar with as well.

Virtualization technologies

• VMware Workstation

  root@router:~# dmidecode -s system-product-name
  VMware Virtual Platform
  

• VirtualBox

  root@router:~# dmidecode -s system-product-name
  VirtualBox
  

• Qemu with KVM

  root@router:~# dmidecode -s system-product-name
  KVM
  

• Qemu (emulated)

  root@router:~# dmidecode -s system-product-name
  Bochs
  

• Microsoft VirtualPC

  root@router:~# dmidecode | egrep -i 'manufacturer|product'
  Manufacturer: Microsoft Corporation
  Product Name: Virtual Machine
  

• Virtuozzo

  root@router:~# dmidecode
  /dev/mem: Permission denied
  

• Xen

  root@router:~# dmidecode | grep -i domU
  Product Name: HVM domU
  

On bare metal, this returns an identification of the computer or motherboard model.

/dev/disk/by-id

If you don't have the rights to run dmidecode then you can use:

Virtualization Technology: QEMU

ls -1 /dev/disk/by-id/

Output

[root@host-7-129 ~]# ls -1 /dev/disk/by-id/
ata-QEMU_DVD-ROM_QM00003
ata-QEMU_HARDDISK_QM00001
ata-QEMU_HARDDISK_QM00001-part1
ata-QEMU_HARDDISK_QM00002
ata-QEMU_HARDDISK_QM00002-part1
scsi-SATA_QEMU_HARDDISK_QM00001
scsi-SATA_QEMU_HARDDISK_QM00001-part1
scsi-SATA_QEMU_HARDDISK_QM00002
scsi-SATA_QEMU_HARDDISK_QM00002-part1

References

• How to detect virtualization at dmo.ca

Answer 2

If the container is running systemd:

$ systemd-detect-virt
lxc

On KVM for example it returns:

kvm

and on a non-virtualized host:

none

See also:

• systemd-detect-virt(1)
• Detecting Virtualization

Answer 3

Desirable method

lshw

This command produces the following output on vairous VM technology guests.

$ sudo lshw -class system

Output

• KVM

  mungr                     
      description: Computer
      product: KVM
      vendor: Red Hat
      width: 64 bits
      capabilities: smbios-2.4 dmi-2.4 vsyscall64 vsyscall32
  

• Virtual Box

  fedora17                  
      description: Computer
      product: VirtualBox ()
      vendor: innotek GmbH
      version: 1.2
      serial: 0
      width: 64 bits
      capabilities: smbios-2.5 dmi-2.5 vsyscall32
  

• VMWare

  partedmagic
      description: Computer
      product: VMware Virtual Platform ()
      vendor: VMware, Inc.
      version: None
      serial: VMware-56 4d 94 a0 53 e3 f3 c6-f9 a6 eb 1a 89 70 04 57
      width: 32 bits
      capabilities: smbios-2.4 dmi-2.4 smp-1.4 smp
  

Scripting

If you're on Ubuntu/Debian there's the package open-vm-tools can be installed. It provides vmware-checkvm. It returns only a a digit. A 0 means it's a VM, a 1 means it's a physical system.

Less desirable methods

If it's KVM the /proc/scsi/scsi and ethtool options show up as follows:

SCSI

$ cat /proc/scsi/scsi 
Attached devices:
Host: scsi1 Channel: 00 Id: 00 Lun: 00
  Vendor: QEMU     Model: QEMU DVD-ROM     Rev: 0.9.
  Type:   CD-ROM                           ANSI  SCSI revision: 05

ethtool

$ ethtool -i eth0
driver: virtio_net
version: 
firmware-version: 
bus-info: virtio0
supports-statistics: no
supports-test: no
supports-eeprom-access: no
supports-register-dump: no
supports-priv-flags: no

The virtio_net is part of KVM. The /proc/scsi/scsi tells you that you're in a VM, and that you're most likely KVM.

dmesg

Using the following commands grep'ing through dmesg log.

$ sudo dmesg | grep -i virtual

• VMWare

  VMware vmxnet virtual NIC driver
   Vendor: VMware    Model: Virtual disk      Rev: 1.0 
  hda: VMware Virtual IDE CDROM Drive, ATAPI CD/DVD-ROM drive
  

• QEmu or KVM

  If the "-cpu host" option has not been used, QEmu and KVM will identify themselves as:

  CPU: AMD QEMU Virtual CPU version 0.9.1 stepping 03
  

  otherwise, the host's CPU information will be used both in dmesg, or in /proc/cpuinfo. However, you should see something like:

  [    0.000000] Booting paravirtualized kernel on KVM
  

  In newer kernels that understand that they're running under paravirtualization.

• Microsoft VirtualPC

  hda: Virtual HD, ATA DISK drive
  hdc: Virtual CD, ATAPI CD/DVD-ROM drive
  

• Xen

  $ sudo dmesg | grep -i xen
  Xen virtual console successfully installed as tty1
  

• Virtuozzo

  # method #1
  $ sudo dmesg
  (returns no output)
  
  # method #2
  $ sudo cat /var/log/dmesg
  (returns no output)
  
  # method #3
  $ sudo ls -al /proc/vz
  veinfo  veinfo_redir  veredir  vestat  vzaquota  vzdata
  

References

• dmo.ca/ blog/ How to detect virtualization

Answer 4

The virt-what script seems to cover most cases well...

I do like the disclaimer from the authors:

Most of the time, using this program is the wrong thing to do. Instead you should detect the specific features you actually want to use.

It's appeared on my EL5 and EL6 systems for the past few years as part of default installations. Ubuntu has it, and the source is available as well.

The facts detected by the script are listed here, but can easily be extended for edge cases.

Answer 5

hostnamectl is your friend (requires systemd).

A few examples:

Laptop without any virtualization

$ hostnamectl status
   Static hostname: earth.gangs.net
         Icon name: computer-laptop
           Chassis: laptop
        Machine ID: 18a0752e1ccbeef09da51ad17fab1f1b
           Boot ID: beefdc99969e4a4a8525ff842b383c62
  Operating System: Ubuntu 16.04.2 LTS
            Kernel: Linux 4.4.0-66-generic
      Architecture: x86-64

Xen

$ hostnamectl status
   Static hostname: pluto.gangs.net
         Icon name: computer-vm
           Chassis: vm
        Machine ID: beef39aebbf8ba220ed0438b54497609
           Boot ID: beefc71e97ed48dbb436a470fe1920e1
    Virtualization: xen
  Operating System: Ubuntu 16.04.2 LTS
            Kernel: Linux 3.13.0-37-generic
      Architecture: x86-64

OpenVZ

$ hostnamectl status
   Static hostname: mars.gangs.net
         Icon name: computer-container
           Chassis: container
        Machine ID: 55296cb0566a4aaca10b8e3a4b28beef
           Boot ID: 1bb259b0eb064d9eb8a22d112211beef
    Virtualization: openvz
  Operating System: CentOS Linux 7 (Core)
       CPE OS Name: cpe:/o:centos:centos:7
            Kernel: Linux 2.6.32-042stab120.16
      Architecture: x86-64

KVM

$ hostnamectl status
   Static hostname: mercury.gangs.net
         Icon name: computer-vm
           Chassis: vm
        Machine ID: beeffefc50ae499881b024c25895ec86
           Boot ID: beef9c7662a240b3b3b04cef3d1518f0
    Virtualization: kvm
  Operating System: CentOS Linux 7 (Core)
       CPE OS Name: cpe:/o:centos:centos:7
            Kernel: Linux 3.10.0-514.10.2.el7.x86_64
      Architecture: x86-64

Answer 6

isVMware() { [[ $(dmidecode -s system-manufacturer) = 'VMware, Inc.' ]]; }
isXen   () { [[ $(dmidecode -s system-manufacturer) = 'Xen'          ]]; }
isKVM   () { [[ $(dmidecode -s system-product-name) = 'KVM'          ]]; }
isVBox  () { [[ $(dmidecode -s system-product-name) = 'VirtualBox'   ]]; }
isVM    () { isVMware || isXen || isKVM || isVBox; }

Those are the tests we use at my company.

Answer 7

If you get the person you're helping to install facter, you can do

facter virtual

No root access needed.

Debian Guest on Debian host:

[user@guest]$ facter virtual
virtualbox

I can't vouch for how well this would work with Xen/KVM/Qemu...

Answer 8

In "recent" linux kernels, the kernel detects the hypervisor for you and prints a message that is easily available with dmesg. This will tell you simply:

dmesg | grep "Hypervisor detected"

For example:

$ dmesg | grep "Hypervisor detected"
Hypervisor detected: VMware

As for what "recent" means, I am unclear which kernel version it was officially released in, but the commit that introduced this feature in the code base was on May 7, 2010. See here.

Answer 9

systemd-detect-virt

This will detect the type of virtualization technology used, and output it.

systemd-detect-virt

Distinguishing between machine virtualization and container virtualization

Use the --container and --vm options to limit the type of virtualization that is detected.

Exit codes

If you just want to know if virtualization is detected or not, without the specifics, then it's easier to check the exit code. It will return exit code 0 if virtualization is detected, and non-zero otherwise.

---

Answer 10

Sometimes it's tricky :)

root@server:~# dmidecode -s system-product-name
Bochs

root@server:~# dmidecode | egrep -i 'manufacturer|product|vendor'
        Vendor: Bochs
        Manufacturer: Bochs
        Product Name: Bochs
        Manufacturer: Bochs
        Manufacturer: Bochs
        Manufacturer: Bochs
        Manufacturer: Bochs
        Manufacturer: Bochs

root@server:~# virt-what
root@server:~# dpkg -l |grep virt-what
ii  virt-what                           1.2-1                        detect if we are running in a virtual machine

root@server:~# egrep -i 'virtual|vbox' /var/log/dmesg
[    0.000000] Booting paravirtualized kernel on KVM
[    0.385701] input: Macintosh mouse button emulation as /devices/virtual/input/input0

Answer 11

For VirtualBox, you could lspci | grep -i virtualbox, that gives:

$ lspci | grep -i virtualbox
00:02.0 VGA compatible controller: InnoTek Systemberatung GmbH VirtualBox Graphics Adapter
00:04.0 System peripheral: InnoTek Systemberatung GmbH VirtualBox Guest Service

Alternatively, dmidecode -s system-product-name (as @Rahul Patil suggests) is even more direct to the point (but needs root):

$ sudo dmidecode -s system-product-name
VirtualBox

For non-KVM QEMU, dmidecode -s system-product-name confusingly returns Bochs, but dmesg | grep -i qemu works (the storage devices that QEMU emulates usually have the name QEMU HARDDISK, QEMU DVD-ROM etc...).

Answer 12

I usually use lscpu from the util-linux package. It reports Hypervisor vendor and Virtualization type.

Answer 13

Debian comes with this small package for detecting virtualisation type:

$ sudo apt-get install virt-what
$ virt-what

and little bigger because of Perl dependencies:

$ sudo apt-get install imvirt
$ imvirt

As usual run:

free
cat /proc/meminfo
cat /proc/cpuinfo
dmesg
htop
lshw
dmidecode
lsmod
hwinfo

Answer 14

Apparently virtualization comes in several parts - in my case QEMU, Bochs and KVM (then Ubuntu 14.04). I found the easiest way to discover the hypervisor in use was:

sudo apt-get install virt-what
sudo virt-what

which in my case returned simply kvm which was the basic information I was looking for (also the OP I think), because it tells me what I am allowed to do (e.g. run ipset to block a DDoS attack) and how resources are shared between VMs.

In addition I tried

sudo dmidecode -s system-product-name

and

sudo lshw -class system

neither of which mention KVM but they did both inform me that my hardware emulation was provided by Bochs which I confess I hadn't even heard of, but a quick search turned up interesting information (http://en.wikipedia.org/wiki/Bochs). The lshw command is slightly more informative than dmidecode (e.g. telling me it's 64-bit).

The other answers didn't really tell me anything useful - facter virtual just returned physical and ls -1 /dev/disk/by-id/ returned ata-QEMU_DVD-ROM_QM00003 which shows QEMU is involved but I don't have access to the emulated DVD-ROM anyway.

Answer 15

Example, how is this solved in linux-test-project. It might be useful for those who needs this in C code, ideally without much much of dependencies.

• first it tries external dependency systemd-detect-virt
• then, XEN is detected via /proc/xen or /sys/hypervisor/type,
• for KVM it checks "QEMU Virtual CPU" in /proc/cpuinfo with note, that it doesn't work with custom -cpu values, since there's no easy, reasonable or reliable way to work around those.

=> most of the work is done with systemd-detect-virt. src/detect-virt/detect-virt.c shows how to detect other virtualization technologies.

Answer 16

You can look at the file /sys/devices/virtual/dmi/id/sys_vendor - it should have a relevant value that is either a real hardware vendor - for example, on my laptop it says "Dell Inc." - or a virtual hardware vendor that you can identify - for example, it might say "Amazon EC2" or "QEMU" (under KVM).

Answer 17

My answer is from the Linux kernel perspective.

If you know how to use crash utility, try the following:

In a 4.4 linux kernel dump

crash> p x86_hyper
x86_hyper = $4 = (const struct hypervisor_x86 *) 0xffffffff81b166e0 <x86_hyper_kvm>  

On my kernel 5.12 laptop

crash> p x86_hyper_type      
x86_hyper_type = $1 = X86_HYPER_NATIVE  

For your system, you need to read codes related to detect_hypervisor_vendor().