How to check if the host is running as Virtual Machine (VM) or Physical Machine? and more importantly which Virtualization technology?

So here it is how to acheive that. Run the following command as superuser (root) :

dmidecode -s system-manufacturer

the output should be something

"Redhat"

or

"VMWare"

or

"XEN"

or

"Citrix"

then run

dmidecode | grep -i "vm" 

it should show result like

Product Name: KVM 

(which means running KVM Virtualization)

or

Product Name: HVM domU 

(which means running XEN Virtualization)

then run

dmesg | grep -i virtual

Different virtual host will throw different output, similar to :

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

 CPU: AMD QEMU Virtual CPU version 0.9.1 stepping 03
  skipping (on a virtual guest)

or sometime

[    0.000000] Booting paravirtualized kernel on KVM

Microsoft VirtualPC:

 # dmesg | grep -i virtual
 hda: Virtual HD, ATA DISK drive
 hdc: Virtual CD, ATAPI CD/DVD-ROM drive

Xen :

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

Virtuozzo :

# dmesg
(returns no output)

# cat /var/log/dmesg
(returns no output)

# ls -al /proc/vz
veinfo  veinfo_redir  veredir  vestat  vzaquota  vzdata

On longer-running systems, you may need to grep /var/log/dmesg instead.

If that doesn't produce anything useful, try using dmidecode to look at the BIOS information. Frequently, there will be at least one component identifying itself as virtualized:

VMWare:

     # dmidecode | egrep -i 'manufacturer|product'
     Manufacturer: VMware, Inc.
     Product Name: VMware Virtual Platform

Microsoft VirtualPC:

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

QEMU or KVM:

     # dmidecode | egrep -i 'vendor'
     Vendor: QEMU

Virtuozzo:

     # dmidecode
     /dev/mem: Permission denied

Xen:

     # dmidecode | grep -i domU
           Product Name: HVM domU

You should just examine the output of dmidecode directly rather than trying to grep as above, in case the output changes. QEMU, for example, doesn't report the vendor in all versions.

Next, check disk devices for identification as virtualized:

VMWare:

    # cat /proc/ide/hd*/model
    VMware Virtual IDE CDROM Drive
    # cat /proc/scsi/scsi
    Attached devices:
    Host: scsi0 Channel: 00 Id: 00 Lun: 00
      Vendor: VMware   Model: Virtual disk     Rev: 1.0
      Type:   Direct-Access                    ANSI SCSI revision: 02

Microsoft VirtualPC:

    # cat /proc/ide/hd*/model
    Virtual HD
    Virtual CD

QEMU, KVM, or Xen:

    # cat /proc/ide/hd*/model
    QEMU HARDDISK
    QEMU DVD-ROM

Virtuozzo:

    # ls -al /dev/vzfs
    b-----x--- 1 root root 0, 19 2009-04-06 15:04 /dev/vzfs

The following bash script can also be used.

#!/bin/bash -
# @configure_input@
# Copyright (C) 2008-2011 Red Hat Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

# 'virt-what' tries 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.
#
# Please see also the manual page virt-what(1).
# This script should be run as root.
#
# The following resources were useful in writing this script:
# . http://www.dmo.ca/blog/20080530151107

VERSION="@VERSION@"

function fail {
    echo "virt-what: $1"
    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=@prefix@
exec_prefix=@exec_prefix@
PATH=$root@libexecdir@:$root/sbin:$root/usr/sbin:$PATH

# Check we're running as root.

uid=`id -u`
if [ "$uid" != 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 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.*HVM 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=1
fi

# Check for Xen.

if [ "$cpuid" = "XenVMMXenVMM" ]; then
    echo xen; echo xen-hvm
    skip_qemu_kvm=1
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=1
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



Without much humdrum, let me jump into the how-to part. But just before that a small note. When i mentioned disk image, I meant device image and not partition image.

There is a difference between disk image and partition image. Even if the file is something.img, you need to ensure that it is a disk and not a partition image. Disk image is where the partition reside. It is a container for partitions. In simple term device holds the partion within it just like chocholate box holds chocolate cubes in it. Thus depending upon the size/capacity of the box or device inner volume, you can hold partition or chocoloate of upto its maximum permitted size/volume and not beyond that.  So please ensure you are actually resizing the disk, using the methods below, and then the partition. In the tutorial below resizing the partition is just a part of the entire process. If you just want to expand the device image, you can skip partition expanding process or if you to expand the partition only without or with a already large device, skip the device expanding part. My tutorial below uses basic Linux tools and syntaxes that will work in any version and flavour of Linux that support KVM or Xen based virtualization. I have not tried this with any other virtualization technology, but with little changes it should work for others too.

 

For the purpose of this tutorial, following are the specs and assumptions used as example.

Host OS : Installed, configured and running CentOS or RHEL 5.6 as OS with KVM or Xen as virtualization technology.
Guest VM OS : Installed, configured and running CentOS or RHEL 5.6 as OS.
VM Disk(Device) Image Name :  60GB.img
VM Disk(Device) Size :  60GB (maximum allowed size) 
Root ( / ) partition : The / partition of this machine was assigned to the virtual disk of size 60GB. So it is utilizing the maximum allowed size of the device.
Resize requirement : around 100GB

RESIZE THE DISK(DEVICE)

1. Create new image of size 40GB for the disk(device). 40GB because we are going to expand the 60 GB to 100GB, so we need additional 40GB 

qemu-img create -f raw 40GB.img 40G 

 

2. Now create a new disk(device) image by concatenating 60GB.img + 40GB.img to a new file 100GB.img. Remember to concatenate 60GB.img first, with 40GB and not vise-versa.

cat 60GB.img 40GB.img > 100GB.img

The disk(device) is now resized to 100GB. Now attach 100GB.img as your new primary device(removing the old 60GB.img) in your VM configuration and boot your guest.

 

RESIZE(ONLINE) THE PARTITION

1. After the VM finishes booting, login to it and issue the following command.

df -h       // See all mounted partition related information.

 

fdisk -l    // See all available disk(device) related information.

 

Note down the partition name and number, and device name from the above command. e.g. /dev/sda3 is the partion I want to expand, thus /dev/sda is the device.

 

2. Now we will do the actual resizing using fdisk. First we will ask fdisk to load and modify the device information into its cache. And then apply it into the disk by flushing its cache.

fdisk /dev/sda  // Choose the device, to load information of, in its cache.

 

3. Then, ask fdisk to delete the partition information in its cache.

Command (m for help): p       // Print partition information

 Command (m for help): d   // Delete partition

Partition number (1-4): 3   // Partition number to delete. It should be the partition that you want to expand.

 

above, 3 is the partion number of /dev/sda3 I want to expand. In case of a single partition it will be selected automatically by fdisk. Dont save the partion at this stage else you will lose data. 

 

 

Then, ask fdisk to recreate the parition in fdisk cache.

Command (m for help): n   // new partition

 Command action
            e   extended
            p   primary partition (1-4)

p  // partition type is primary

Partition number (1-4): 3  // same partition number as given above.

 

keep pressing return, to select all default values for all other, including cylinder start and end to utilize the entire available capacity of the device. Otherwise give end value of cylinder after calculating the size using cylinder value. Google it for that with keyword "howto calculate disk size from cylinder value" 

 

Now, review the changes made in fdisk's cache.

Command (m for help): p   //  print partition information to review the changes made in fdisk's cache.

 

Finally flush the changes from fdisk cache to disk.

Command (m for help): w  // Flush the cache to disk parmanently.

 

See example image below for the entire step 3.

 

 

Ignore any error messages as above

 

4. Now reboot your VM once again. Then once the VM finishes booting, login to it.

 

5. Run the following commands

resize2fs /dev/sda3   // Online resizing of the partition /dev/hda1

 

6. Now reboot your VM for the last time. One the VM finishes booting, you have resized partion inside your resized disk(device). Resized disk(device) only in case you have resized that too, to make space for your new resized partition.

df -h

 

 

Isn't that simple? 

 

Cheers!
Ani 

There was many requests to publish one of my previous article in a form of a downloadable EBook. Keeping that in mind I am happy to publish an Ebook in pdf format for offline use. Please let me know if this effort has helped you in anyway.

Download it here. | The original article was published here.