The Xen hypervisor offers an efficient and secure feature set for virtualization of x86, x86_64, IA64, PowerPC and other CPU architectures.
A Xen system is structured with the Xen hypervisor as the lowest and most privileged layer.
Above this layer are one or more guest operating systems, which the hypervisor schedules across the physical CPUs. The first guest operating system, called in Xen terminology "domain 0" (dom0), is booted automatically when the hypervisor boots and given special management privileges and direct access to the physical hardware. The system administrator logs into dom0 in order to start any further guest operating systems, called "domain U" (domU) in Xen terminology.
Product Component | OS Type | Versioning | Pattern Depth |
---|---|---|---|
XenSource XenServer Domain | Unix | Active | Instance-Based |
XenSource XenServer Server | Unix | Active | Instance-Based |
The Xen Hypervisor can only be ran on modified version of Unix-like Operating Systems, the pattern identifies and models the XenSource Xenserver Server and Domains on all such Operating Systems.
Product Component | OS Type | Trigger Node | Attribute | Condition | Argument |
---|---|---|---|---|---|
XenSource XenServer Server | Unix | DiscoveredProcess | cmd | matches | regex '\bxenbus$' |
XenSource XenServer Domain | Unix | DiscoveredProcess | cmd | matches | regex '\bxenbus$' |
Note: Both the XenSource XenServer Server and Domain(s) are created from the same trigger.
The consolidation of the Xen domains is handled by a separate pattern module, please click here for more information.
The following processes are identified by the pattern. The identification is performed at two levels - processes listed below are identified through the use of Simple Identifiers and in addition, they are modeled within a full Software Instance for Xen Server (See Xen Source Xen Domain Virtualization Software#Application Model Produced by Software Pattern for more details about the approach taken to model this product).
The processes there are Simple Identifiers for are:
Name | OS Type | Command Regex |
---|---|---|
Xen Bus | Unix | \bxenbus$ |
Xen FB | Unix | \bxenfb$ |
Xen Watch | Unix | \bxenwatch$ |
Xen Console Daemon | Unix | \bxenconsoled$ |
Xen Store Daemon | Unix | \bxenstored$ |
We currently collect version information for the product using the an Active Versioning method.
The pattern checks three different files in order to obtain Version. These files contain respectively the Major, Minor and 'Extra' Version of the underlying Xen Hypervisor. The files reside in the same location, as illustrated in the table below:
Version | System-wide File |
---|---|
Major | /sys/hypervisor/version/major |
Minor | /sys/hypervisor/version/minor |
Extra | /sys/hypervisor/version/extra |
The pattern extracts the version information from all three files to create the Full Version, if we extracted a value from these files then we assign the first two levels of the version to the Product Version.
XenServer Server runs on a modified kernel which is 'Xen-aware'. The host running this kernel is identified by Xen as Domain-0, and will always have the Xen Bus and Xen Watch processes running on it. This host provides the drivers and infrastructures that Xen requires to run its Guest Systems.
There are two Virtualization modes available on XenServer Server: Paravirtualization and Full Virtualization. While Paravirtualization requires solely a modified kernel, Full Virtualization also requires a CPU equipped with the new hardware hypervisor extensions.
The pattern triggers on the Xen Bus process, as illustrated in Section Xen Source Xen Domain Virtualization Software#Software Instance Triggers.
The pattern creates an Instance-Based (Deep) Software Instance for the XenSource XenServer Domain based on the products Domain UUID', _type and _host key.
The pattern creates an Instance-Based (Deep) Software Instance for the XenSource XenServer Server based on the products Domain UUID' (which will always be a set of 0's), _type and _host key, there has to be a XenSource server running in Domain-0 for any further Domains to run.
The pattern attempts to retrieve the following attributes:
The pattern only creates a Software Instances when it is successful in retrieving them all.
The pattern can obtain these attributes through two different methods, each either with no special privileges or with a root login or privileged access.
The pattern retrieves a list of all the domain ID's managed by XenServer Server by using an active command.
Active Command employed to obtain domain ID's: virsh list
It then iterates through the list of domain ID's and attempts to retrieve the attributes by running another Active Command on each of the domain ID's:
Active Command employed to retrieve Attributes: virsh dominfo Domain ID
If the command is successful, The pattern then parses its output through a set of Regular Expressions in order to retrieve the Attributes, as illustrated in the table below:
Domain Attribute | Regular Expression |
---|---|
Domain Name | Name:\s+(.*?)\s |
Domain UUID | UUID:\s+(.*?)\s |
Domain State | State:\s+(.*?)\s |
The pattern subsequently models a Software Instance and adds all these attributes to it.
Should the above commands fail, the pattern attempts to run a System-wide Active Command in order to retrieve the Domain Attributes.
Active Command employed to retrieve Attributes: /usr/sbin/xm list --long
Should any of the above Active Commands fail because of a lack of Privileges, the pattern may try to run it with elevated privileges.
Note
Starting from TKU February 2015, privilege command execution configuration using the pattern configuration block is not supported for Xen Source Xen Domain Virtualization Software. Please, use BMC Atrium Discovery platform configuration instead.
When the Active Command is successful, the pattern splits its output into sections separated by a New Line followed by an open bracket, then parses each section by applying a set of Regular Expressions to it in order to obtain the Domain Attributes, as illustrated in the Table below:
Domain Attribute | Regular Expression |
---|---|
Domain ID | \(domid (\d+)\) |
Domain Name | \(name (\S+)\) |
Domain UUID | \(uuid (\S+)\) |
Domain State | \(state (\S+)\ |
The pattern subsequently models a Software Instance and adds all these attributes to it.
We conducted tests against live installations of XenSource XenServer Server on Linux platforms. This allowed us to ensure that the pattern correctly triggers, retrieves Domain Attributes and Versions the product using the Active method.
The Xen Official Page provided useful information on the Product, including Xen Source Xen Domain Virtualization Software#Product Description and Xen Source Xen Domain Virtualization Software#Known Versions Information.
There are no known open issues with this pattern.
Created by: Edoardo 19:11, 11 February 2008 (GMT)
Updated by: Rebecca Shalfield 17 Mar 2014