How to determine Linux guest VM virtualization technology

Posted on in Categories , , , , , , , last updated January 31, 2018

I have a cloud-based virtual machine running Ubuntu and CentOS Linux server. It may or may not be virtualized. How do I determine what kind of virtualization technology (VMWARE/ KVM/ XEN/ VirtualBox/ Container/ lxc/Hyper-V etc.) a Linux guest system running on? How do I find out the virtualization type of a CentOS 7 Linux VPS?

You need to use the virt-what program (shell script) to detect the type of virtualization being used (or none at all if we’re running on bare-metal). It prints out one of more lines each being a ‘fact’ about the virtualization.

Install virt-what on Debian or Ubuntu Linux VM

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

Fig.01: Debian/Ubuntu Linux install virt-what command
Fig.01: Debian/Ubuntu Linux install virt-what command

Install virt-what on RHEL/CentOS/Scientific Linux VM

$ sudo yum install virt-what

Fig.02: Fedora/RHEL/CentOS Linux install virt-what command
Fig.02: Fedora/RHEL/CentOS Linux install virt-what command

Install virt-what on Fedora Linux VM

$ sudo dnf install virt-what

Check if your remote server runs in virtual environment

Simply type the following command:
$ sudo virt-what
xen
xen-domU

Another output:
$ sudo virt-what
kvm

Another output:
$ sudo virt-what
lxc

Other possible values

  1. hyperv : This is Microsoft Hyper-V hypervisor.
  2. parallels : The guest is running inside Parallels Virtual Platform (Parallels Desktop, Parallels Server).
  3. powervm_lx86 : The guest is running inside IBM PowerVM Lx86 Linux/x86 emulator.
  4. qemu : This is QEMU hypervisor using software emulation.
  5. virtualpc : The guest appears to be running on Microsoft VirtualPC.
  6. xen-hvm : This is a Xen guest fully virtualized (HVM).
  7. uml : This is a User-Mode Linux (UML) guest.
  8. openvz : The guest appears to be running inside an OpenVZ or Virtuozzo container.
  9. linux_vserver : This process is running in a Linux VServer container.
  10. ibm_systemz : This is an IBM SystemZ (or other S/390) hardware partitioning system.

If nothing is printed, then it can mean *either* that the program is running on bare-metal *or* the program is running inside a type of virtual machine which we don’t know about or cannot detect. For more info see virt-what – detect if we are running in a virtual machine and here is the source code of the script:

#!/bin/bash -
# virt-what.  Generated from virt-what.in by configure.
# Copyright (C) 2008-2011 Red Hat Inc.
# Do not allow unset variables, and set defaults.
set -u
root=''
skip_qemu_kvm=false
 
VERSION="1.13"
 
function fail {
    echo "virt-what: $1" >&2
    exit 1
}
 
function usage {
    echo "virt-what [options]"
    echo "Options:"
    echo "  --help          Display this help"
    echo "  --version       Display version and exit"
    exit 0
}
 
# Handle the command line arguments, if any.
 
TEMP=$(getopt -o v --long help --long version --long test-root: -n 'virt-what' -- "$@")
if [ $? != 0 ]; then exit 1; fi
eval set -- "$TEMP"
 
while true; do
    case "$1" in
	--help) usage ;;
        --test-root)
            # Deliberately undocumented: used for 'make check'.
            root="$2"
            shift 2
            ;;
	-v|--version) echo "$VERSION"; exit 0 ;;
	--) shift; break ;;
	*) fail "internal error ($1)" ;;
    esac
done
 
# Add /sbin and /usr/sbin to the path so we can find system
# binaries like dmicode.
# Add /usr/libexec to the path so we can find the helper binary.
prefix=/usr
exec_prefix=${prefix}
PATH="${root}${prefix}/lib/virt-what:${root}/sbin:${root}/usr/sbin:${PATH}"
 
# Check we're running as root.
 
if [ "x$root" = "x" ] && [ "$EUID" -ne 0 ]; then
    fail "this script must be run as root"
fi
 
# Many fullvirt hypervisors give an indication through CPUID.  Use the
# helper program to get this information.
 
cpuid=$(virt-what-cpuid-helper)
 
# Check for various products in the BIOS information.
# Note that dmidecode doesn't exist on non-PC architectures.  On these,
# this will return an error which is ignored (error message redirected
# into $dmi variable).
 
dmi=$(LANG=C dmidecode 2>&1)
 
# Architecture.
# Note for the purpose of testing, we only call uname with -p option.
 
arch=$(uname -p)
 
# Check for VMware.
# cpuid check added by Chetan Loke.
 
if [ "$cpuid" = "VMwareVMware" ]; then
    echo vmware
elif echo "$dmi" | grep -q 'Manufacturer: VMware'; then
    echo vmware
fi
 
# Check for Hyper-V.
# http://blogs.msdn.com/b/sqlosteam/archive/2010/10/30/is-this-real-the-metaphysics-of-hardware-virtualization.aspx
if [ "$cpuid" = "Microsoft Hv" ]; then
    echo hyperv
fi
 
# Check for VirtualPC.
# The negative check for cpuid is to distinguish this from Hyper-V
# which also has the same manufacturer string in the SM-BIOS data.
if [ "$cpuid" != "Microsoft Hv" ] &&
    echo "$dmi" | grep -q 'Manufacturer: Microsoft Corporation'; then
    echo virtualpc
fi
 
# Check for VirtualBox.
# Added by Laurent Léonard.
if echo "$dmi" | grep -q 'Manufacturer: innotek GmbH'; then
    echo virtualbox
fi
 
# Check for OpenVZ / Virtuozzo.
# Added by Evgeniy Sokolov.
# /proc/vz - always exists if OpenVZ kernel is running (inside and outside
# container)
# /proc/bc - exists on node, but not inside container.
 
if [ -d "${root}/proc/vz" -a ! -d "${root}/proc/bc" ]; then
    echo openvz
fi
 
# Check for LXC containers
# http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface
# Added by Marc Fournier
 
if [ -e "${root}/proc/1/environ" ] &&
    cat "${root}/proc/1/environ" | tr '\000' '\n' | grep -Eiq '^container='; then
    echo lxc
fi
 
# Check for Linux-VServer
if cat "${root}/proc/self/status" | grep -q "VxID: [0-9]*"; then
    echo linux_vserver
fi
 
# Check for UML.
# Added by Laurent Léonard.
if grep -q 'UML' "${root}/proc/cpuinfo"; then
    echo uml
fi
 
# Check for IBM PowerVM Lx86 Linux/x86 emulator.
if grep -q '^vendor_id.*PowerVM Lx86' "${root}/proc/cpuinfo"; then
    echo powervm_lx86
fi
 
# Check for Hitachi Virtualization Manager (HVM) Virtage logical partitioning.
if echo "$dmi" | grep -q 'Manufacturer.*HITACHI' &&
   echo "$dmi" | grep -q 'Product.* LPAR'; then
    echo virtage
fi
 
# Check for IBM SystemZ.
if grep -q '^vendor_id.*IBM/S390' "${root}/proc/cpuinfo"; then
    echo ibm_systemz
    if [ -f "${root}/proc/sysinfo" ]; then
        if grep -q 'VM.*Control Program.*z/VM' "${root}/proc/sysinfo"; then
            echo ibm_systemz-zvm
        elif grep -q '^LPAR' "${root}/proc/sysinfo"; then
            echo ibm_systemz-lpar
        else
            # This is unlikely to be correct.
            echo ibm_systemz-direct
        fi
    fi
fi
 
# Check for Parallels.
if echo "$dmi" | grep -q 'Vendor: Parallels'; then
    echo parallels
    skip_qemu_kvm=true
fi
 
# Check for Xen.
 
if [ "$cpuid" = "XenVMMXenVMM" ]; then
    echo xen; echo xen-hvm
    skip_qemu_kvm=true
elif [ -f "${root}/proc/xen/capabilities" ]; then
    echo xen
    if grep -q "control_d" "${root}/proc/xen/capabilities"; then
        echo xen-dom0
    else
        echo xen-domU
    fi
    skip_qemu_kvm=true
elif [ -f "${root}/sys/hypervisor/type" ] &&
    grep -q "xen" "${root}/sys/hypervisor/type"; then
    # Ordinary kernel with pv_ops.  There does not seem to be
    # enough information at present to tell whether this is dom0
    # or domU.  XXX
    echo xen
elif [ "$arch" = "ia64" ]; then
    if [ -d "${root}/sys/bus/xen" -a ! -d "${root}/sys/bus/xen-backend" ]; then
        # PV-on-HVM drivers installed in a Xen guest.
        echo xen
        echo xen-hvm
    else
        # There is no virt leaf on IA64 HVM.  This is a last-ditch
        # attempt to detect something is virtualized by using a
        # timing attack.
        virt-what-ia64-xen-rdtsc-test > /dev/null 2>&1
        case "$?" in
            0) ;; # not virtual
            1) # Could be some sort of virt, or could just be a bit slow.
                echo virt
        esac
    fi
fi
 
# Check for QEMU/KVM.
#
# Parallels exports KVMKVMKVM leaf, so skip this test if we've already
# seen that it's Parallels.  Xen uses QEMU as the device model, so
# skip this test if we know it is Xen.
 
if ! "$skip_qemu_kvm"; then
    if [ "$cpuid" = "KVMKVMKVM" ]; then
	echo kvm
    else
        # XXX This is known to fail for qemu with the explicit -cpu
        # option, since /proc/cpuinfo will not contain the QEMU
        # string.  The long term fix for this would be to export
        # another CPUID leaf for non-accelerated qemu.
        if grep -q 'QEMU' "${root}/proc/cpuinfo"; then
	    echo qemu
	fi
    fi
fi

How to use dmidecode command to find out same info

Use bash for loop as follows along with the dmidecode command:

for i in system-manufacturer system-product-name
do 
  sudo dmidecode -s $i
done

Sample outputs:

Red Hat
KVM

Posted by: Vivek Gite

The author is the creator of nixCraft and a seasoned sysadmin, DevOps engineer, and a trainer for the Linux operating system/Unix shell scripting. Get the latest tutorials on SysAdmin, Linux/Unix and open source topics via RSS/XML feed or weekly email newsletter.

Share this on (or read 9 comments/add one below):

Notable Replies

  1. Thanks I will add those two commands soon too.

Continue the discussion www.nixcraft.com

1 more reply

Participants

Historical Comment Archive

9 comment

  1. systemd (I’ve read that centos7 has systemd) has the same functionality “#systemd-detect-virt “.

  2. Hi Vivek,

    You have missed to comment one of the main players in the game: “VMware”. I was looking for the detection of VMware but you did not comment on it on the article. I had to read the script to realize it is detected as well.

    By the way, nice post. and absolutely fantastic blog.

  3. Good write up, I typically just do: “parted /dev/sda print” and I can tell by the virtual disk name what it is.

  4. 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. In “recent” linux kernels, the kernel detects the hypervisor for you and prints a message that is easily available with

  5. It might be possible for your code to see what sort of virtualisation it could set up. If that fails entirely, you might be in a VM. But you just as might easily be on a box that doesn’t have any VM capable hardware.

    Have a question? Post it on our forum!