How to determine Linux guest VM virtualization technology


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



$ sudo apt install virt-what


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

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




Another output:

$ sudo virt-what



Another output:

$ sudo virt-what


Other possible values

hyperv : This is Microsoft Hyper-V hypervisor.

parallels : The guest is running inside Parallels Virtual Platform (Parallels Desktop, Parallels Server).

powervm_lx86 : The guest is running inside IBM PowerVM Lx86 Linux/x86 emulator.

qemu : This is QEMU hypervisor using software emulation.

virtualpc : The guest appears to be running on Microsoft VirtualPC.

xen-hvm : This is a Xen guest fully virtualized (HVM).

uml : This is a User-Mode Linux (UML) guest.

openvz : The guest appears to be running inside an OpenVZ or Virtuozzo container.

linux_vserver : This process is running in a Linux VServer container.

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 by configure.

# Copyright (C) 2008-2011 Red Hat Inc.

# Do not allow unset variables, and set defaults.

set -u






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 ;;


# Deliberately undocumented: used for  make check .

root= $2

shift 2


-v|–version) echo  $VERSION ; exit 0 ;;

–) shift; break ;;

*) fail  internal error ($1)  ;;




# 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.



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



# Many fullvirt hypervisors give an indication through CPUID.  Use the

# helper program to get this information.




# 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



# Check for Hyper-V.


if [  $cpuid  =  Microsoft Hv  ]; then

echo hyperv



# 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



# Check for VirtualBox.

# Added by Laurent Léonard.

if echo  $dmi  | grep -q  Manufacturer: innotek GmbH ; then

echo virtualbox



# 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



# Check for LXC containers


# Added by Marc Fournier


if [ -e  ${root}/proc/1/environ  ] &&

cat  ${root}/proc/1/environ  | tr  \000   \n  | grep -Eiq  ^container= ; then

echo lxc



# Check for Linux-VServer

if cat  ${root}/proc/self/status  | grep -q  VxID: [0-9]* ; then

echo linux_vserver



# Check for UML.

# Added by Laurent Léonard.

if grep -q  UML   ${root}/proc/cpuinfo ; then

echo uml



# Check for IBM PowerVM Lx86 Linux/x86 emulator.

if grep -q  ^vendor_id.*PowerVM Lx86   ${root}/proc/cpuinfo ; then

echo powervm_lx86



# 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



# 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


# This is unlikely to be correct.

echo ibm_systemz-direct





# Check for Parallels.

if echo  $dmi  | grep -q  Vendor: Parallels ; then

echo parallels




# Check for Xen.


if [  $cpuid  =  XenVMMXenVMM  ]; then

echo xen; echo xen-hvm


elif [ -f  ${root}/proc/xen/capabilities  ]; then

echo xen

if grep -q  control_d   ${root}/proc/xen/capabilities ; then

echo xen-dom0


echo xen-domU



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


# 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





# 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


# 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






Leave a Reply

Your email address will not be published. Required fields are marked *