Merge lp:~ubuntu-branches/ubuntu/natty/libvirt/natty-201011111816 into lp:ubuntu/natty/libvirt

[James Westby]

The package history in the archive and the history in the bzr branch differ. As the archive is authoritative the history of lp:ubuntu/natty/libvirt now reflects that and the old bzr branch has been pushed to lp:~ubuntu-branches/ubuntu/natty/libvirt/natty-201011111816. A merge should be performed if necessary.

Unmerged revisions

108. By Jamie Strandboge on 2010-11-11

0.8.5 merge from Serge Hallyn

* New upstream release.
* Removed a slew of patches which have been
  applied upstream since 0.8.3.
  - 9012-apparmor-extra-tests.patch
  - 9013-apparmor-chardev.patch
  - 9015-Add-ubd-to-the-list-of-disk-prefixes.patch
  - 9016-Close-fd-s-of-persistent-tap-devices.patch
  - 9017-Make-sure-all-command-line-arguments-get-passed-to-U.patch
  - 9018-Make-umlConnectTapDevice-ask-brAddTap-for-a-persiste.patch
  - 9019-uml-fix-logic-bug-in-checking-reply-length.patch
  - 9021-Allow-chardev-of-type-file-for-UML-domains.patch
  - 9022-Rename-qemudShrinkDisks-to-virDomainDiskRemove-and-m.patch
  - 9023-Support-virDomainAttachDevice-and-virDomainDetachDev.patch
  - 9024-Explicitly-pass-uml_dir-argument-to-user-mode-linux.patch
  - 9025-Add-nwfilter-support-to-UML-driver.patch
  - 9026-Rebuild-network-filter-for-UML-guests-on-updates.patch
  - 9027-Make-newfilter-xml-transformations-endian-safe.patch
  - 9028-lp628055.patch
* Updated 9002-better_default_uri_virsh.patch to use vshStrdup,
  as now required in that file. (use of strdup now causes compilation
  to fail)
* Removed 9008-run-as-root-by-default.patch, which has not been
  applied for awhile now, with no ill effects.
* Simple refresh of:
  - 0001-remove-RHism.diff.patch
  - 0003-allow-libvirt-group-to-access-the-socket.patch
  - 0004-fix-Debian-specific-path-to-hvm-loader.patch
  - 0006-patch-qemuMonitorTextGetMigrationStatus-to-intercept.patch
  - 9000-delayed_iff_up_bridge.patch
  - 9001-dont_clobber_existing_bridges.patch
  - 9003-better-default-arch.patch
  - 9004-libvirtd-group-name.patch
  - 9005-increase-unix-socket-timeout.patch
  - 9006-default-config-test-case.patch
  - 9009-autodetect-nc-params.patch
  - 9010-dont-disable-ipv6.patch
  - 9011-move-ebtables-script.patch
  - 9014-skip-nodeinfotest.patch
  - 9020-lp545795.patch
* Create a patch to include stdint.h so lxc_container.h, which
  #includes linux/fs.h, doesn't trip up on undefined uint64_t.

=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2010-11-11 18:22:47 +0000
@@ -0,0 +1,1 @@
+debian/patches

=== added file '.pc/.quilt_series'
--- .pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_series	2010-11-11 18:22:47 +0000
@@ -0,0 +1,1 @@
+series

=== added directory '.pc/0001-remove-RHism.diff.patch'
=== renamed directory '.pc/0001-remove-RHism.diff.patch' => '.pc/0001-remove-RHism.diff.patch.moved'
=== renamed file '.pc/0001-remove-RHism.diff.patch/tools/virsh.pod' => '.pc/0001-remove-RHism.diff.patch.moved/tools/virsh.pod.THIS'
=== added file '.pc/0001-remove-RHism.diff.patch/.timestamp'
=== added directory '.pc/0001-remove-RHism.diff.patch/tools'
=== added file '.pc/0001-remove-RHism.diff.patch/tools/virsh.pod'
--- .pc/0001-remove-RHism.diff.patch/tools/virsh.pod	1970-01-01 00:00:00 +0000
+++ .pc/0001-remove-RHism.diff.patch/tools/virsh.pod	2010-11-11 18:22:47 +0000
@@ -0,0 +1,1220 @@
+=head1 NAME
+
+virsh - management user interface
+
+=head1 SYNOPSIS
+
+B<virsh> [I<OPTION>]... [I<COMMAND_STRING>]
+
+B<virsh> [I<OPTION>]... I<COMMAND> [I<ARG>]...
+
+=head1 DESCRIPTION
+
+The B<virsh> program is the main interface for managing virsh guest
+domains. The program can be used to create, pause, and shutdown
+domains. It can also be used to list current domains. Libvirt is a C
+toolkit to interact with the virtualization capabilities of recent
+versions of Linux (and other OSes). It is free software available
+under the GNU Lesser General Public License. Virtualization of the
+Linux Operating System means the ability to run multiple instances of
+Operating Systems concurrently on a single hardware system where the
+basic resources are driven by a Linux instance. The library aims at
+providing a long term stable C API.  It currently supports Xen, QEmu,
+KVM, LXC, OpenVZ, VirtualBox, OpenNebula, and VMware ESX.
+
+The basic structure of most virsh usage is:
+
+  virsh [OPTION]... <command> <domain-id> [ARG]...
+
+Where I<command> is one of the commands listed below, I<domain-id>
+is the numeric domain id, or the domain name (which will be internally
+translated to domain id), and I<ARGS> are command specific
+options.  There are a few exceptions to this rule in the cases where
+the command in question acts on all domains, the entire machine,
+or directly on the xen hypervisor.  Those exceptions will be clear for
+each of those commands.
+
+The B<virsh> program can be used either to run one I<COMMAND> by giving the
+command and its arguments on the shell command line, or a I<COMMAND_STRING>
+which is a single shell argument consisting of multiple I<COMMAND> actions
+and their arguments joined with whitespace, and separated by semicolons
+between commands.  Within I<COMMAND_STRING>, virsh understands the
+same single, double, and backslash escapes as the shell, although you must
+add another layer of shell escaping in creating the single shell argument.
+If no command is given in the command line, B<virsh> will then start a minimal
+interpreter waiting for your commands, and the B<quit> command will then exit
+the program.
+
+The B<virsh> program understands the following I<OPTIONS>.
+
+=over 4
+
+=item B<-h>, B<--help>
+
+Ignore all other arguments, and behave as if the B<help> command were
+given instead.
+
+=item B<-v>, B<--version>
+
+Ignore all other arguments, and behave as if the B<version> command were
+given instead.
+
+=item B<-c>, B<--connect> I<URI>
+
+Connect to the specified I<URI>, as if by the B<connect> command,
+instead of the default connection.
+
+=item B<-d>, B<--debug> I<LEVEL>
+
+Enable debug messages at integer I<LEVEL> and above.  I<LEVEL> can
+range from 0 (default) to 5.
+
+=item B<-l>, B<--log> I<FILE>
+
+Output logging details to I<FILE>.
+
+=item B<-q>, B<--quiet>
+
+Avoid extra informational messages.
+
+=item B<-r>, B<--readonly>
+
+Make the initial connection read-only, as if by the I<--readonly>
+option of the B<connect> command.
+
+=item B<-t>, B<--timing>
+
+Output elapsed time information for each command.
+
+=back
+
+=head1 NOTES
+
+Most B<virsh> operations rely upon the libvirt library being able to
+connect to an already running libvirtd service.  This can usually be
+done using the command B<service libvirtd start>.
+
+Most B<virsh> commands require root privileges to run due to the
+communications channels used to talk to the hypervisor.  Running as
+non root will return an error.
+
+Most B<virsh> commands act synchronously, except maybe shutdown,
+setvcpus and setmem. In those cases the fact that the B<virsh>
+program returned, may not mean the action is complete and you
+must poll periodically to detect that the guest completed the
+operation.
+
+=head1 GENERIC COMMANDS
+
+The following commands are generic i.e. not specific to a domain.
+
+=over 4
+
+=item B<help> optional I<command>
+
+This prints a small synopsis about all commands available for B<virsh>
+B<help> I<command> will print out a detailed help message on that command.
+
+=item B<quit>, B<exit>
+
+quit this interactive terminal
+
+=item B<version>
+
+Will print out the major version info about what this built from.
+
+=over 4
+
+B<Example>
+
+B<virsh> version
+
+Compiled against library: libvir 0.0.6
+
+Using library: libvir 0.0.6
+
+Using API: Xen 3.0.0
+
+Running hypervisor: Xen 3.0.0
+
+=back
+
+=item B<cd> optional I<directory>
+
+Will change current directory to I<directory>.  The default directory
+for the B<cd> command is the home directory or, if there is no I<HOME>
+variable in the environment, the root directory.
+
+This command is only available in interactive mode.
+
+=item B<pwd>
+
+Will print the current directory.
+
+=item B<connect> I<URI> optional I<--readonly>
+
+(Re)-Connect to the hypervisor. When the shell is first started, this
+is automatically run with the I<URI> parameter requested by the C<-c>
+option on the command line. The I<URI> parameter specifies how to
+connect to the hypervisor. The documentation page at
+L<http://libvirt.org/uri.html> list the values supported, but the most
+common are:
+
+=over 4
+
+=item xen:///
+
+this is used to connect to the local Xen hypervisor, this is the default
+
+=item qemu:///system
+
+connect locally as root to the daemon supervising QEmu and KVM domains
+
+=item qemu:///session
+
+connect locally as a normal user to his own set of QEmu and KVM domains
+
+=item lxc:///
+
+connect to a local linux container
+
+=back
+
+For remote access see the documentation page on how to make URIs.
+The I<--readonly> option allows for read-only connection
+
+=item B<uri>
+
+Prints the hypervisor canonical URI, can be useful in shell mode.
+
+=item B<hostname>
+
+Print the hypervisor hostname.
+
+=item B<nodeinfo>
+
+Returns basic information about the node, like number and type of CPU,
+and size of the physical memory.
+
+=item B<capabilities>
+
+Print an XML document describing the capabilities of the hypervisor
+we are currently connected to. This includes a section on the host
+capabilities in terms of CPU and features, and a set of description
+for each kind of guest which can be virtualized. For a more complete
+description see:
+  L<http://libvirt.org/formatcaps.html>
+The XML also show the NUMA topology information if available.
+
+=item B<list> optional I<--inactive> I<--all>
+
+Prints information about one or more domains.  If no domains are
+specified it prints out information about running domains.
+
+An example format for the list is as follows:
+
+B<virsh> list
+ Id Name                 State
+
+----------------------------------
+
+  0 Domain-0             running
+  2 fedora               paused
+
+
+Name is the name of the domain.  ID the domain numeric id.
+State is the run state (see below).
+
+B<STATES>
+
+The State field lists 7 states for a domain, and which ones the
+current domain is in.
+
+=over 4
+
+=item B<running>
+
+The domain is currently running on a CPU
+
+=item B<idle>
+
+The domain is idle, and not running or runnable.  This can be caused
+because the domain is waiting on IO (a traditional wait state) or has
+gone to sleep because there was nothing else for it to do.
+
+=item B<paused>
+
+The domain has been paused, usually occurring through the administrator
+running B<virsh suspend>.  When in a paused state the domain will still
+consume allocated resources like memory, but will not be eligible for
+scheduling by the hypervisor.
+
+=item B<shutdown>
+
+The domain is in the process of shutting down, i.e. the guest operating system
+has been notified and should be in the process of stopping its operations
+gracefully.
+
+=item B<shut off>
+
+The domain is not running.  Usually this indicates the domain has been
+shut down completely, or has not been started.
+
+=item B<crashed>
+
+The domain has crashed, which is always a violent ending.  Usually
+this state can only occur if the domain has been configured not to
+restart on crash.
+
+=item B<dying>
+
+The domain is in process of dying, but hasn't completely shutdown or
+crashed.
+
+=back
+
+=item B<freecell> optional I<cellno>
+
+Prints the available amount of memory on the machine or within a
+NUMA cell if I<cellno> is provided.
+
+=item B<cpu-baseline> I<FILE>
+
+Compute baseline CPU which will be supported by all host CPUs given in <file>.
+The list of host CPUs is built by extracting all <cpu> elements from the
+<file>. Thus, the <file> can contain either a set of <cpu> elements separated
+by new lines or even a set of complete <capabilities> elements printed by
+B<capabilities> command.
+
+=item B<cpu-compare> I<FILE>
+
+Compare CPU definition from XML <file> with host CPU. The XML <file> may
+contain either host or guest CPU definition. The host CPU definition is the
+<cpu> element and its contents as printed by B<capabilities> command. The
+guest CPU definition is the <cpu> element and its contents from domain XML
+definition. For more information on guest CPU definition see:
+L<http://libvirt.org/formatdomain.html#elementsCPU>
+
+=back
+
+=head1 DOMAIN COMMANDS
+
+The following commands manipulate domains directly, as stated
+previously most commands take domain-id as the first parameter. The
+I<domain-id> can be specified as an short integer, a name or a full UUID.
+
+=over 4
+
+=item B<autostart> optional I<--disable> I<domain-id>
+
+Configure a domain to be automatically started at boot.
+
+The option I<--disable> disables autostarting.
+
+=item B<console> I<domain-id>
+
+Connect the virtual serial console for the guest.
+
+=item B<create> I<FILE> optional I<--console> I<--paused>
+
+Create a domain from an XML <file>. An easy way to create the XML
+<file> is to use the B<dumpxml> command to obtain the definition of a
+pre-existing guest.  The domain will be paused if the I<--paused> option
+is used and supported by the driver; otherwise it will be running.
+If I<--console> is requested, attach to the console after creation.
+
+B<Example>
+
+ virsh dumpxml <domain-id> > domain.xml
+ edit domain.xml
+ virsh create < domain.xml
+
+=item B<define> I<FILE>
+
+Define a domain from an XML <file>. The domain definition is registered
+but not started.
+
+=item B<destroy> I<domain-id>
+
+Immediately terminate the domain domain-id.  This doesn't give the domain
+OS any chance to react, and it's the equivalent of ripping the power
+cord out on a physical machine.  In most cases you will want to use
+the B<shutdown> command instead.
+
+=item B<domblkstat> I<domain> I<block-device>
+
+Get device block stats for a running domain.
+
+=item B<domifstat> I<domain> I<interface-device>
+
+Get network interface stats for a running domain.
+
+=item B<dommemstat> I<domain>
+
+Get memory stats for a running domain.
+
+=item B<domblkinfo> I<domain> I<block-device>
+
+Get block device size info for a domain.
+
+=item B<dominfo> I<domain-id>
+
+Returns basic information about the domain.
+
+=item B<domuuid> I<domain-name-or-id>
+
+Convert a domain name or id to domain UUID
+
+=item B<domid> I<domain-name-or-uuid>
+
+Convert a domain name (or UUID) to a domain id
+
+=item B<domjobabort> I<domain-id-or-uuid>
+
+Abort the currently running domain job.
+
+=item B<domjobinfo> I<domain-id-or-uuid>
+
+Returns information about jobs running on a domain.
+
+=item B<domname> I<domain-id-or-uuid>
+
+Convert a domain Id (or UUID) to domain name
+
+=item B<domstate> I<domain-id>
+
+Returns state about a running domain.
+
+=item B<domxml-from-native> I<format> I<config>
+
+Convert the file I<config> in the native guest configuration format
+named by I<format> to a domain XML format.
+
+=item B<domxml-to-native> I<format> I<xml>
+
+Convert the file I<xml> in domain XML format to the native guest
+configuration format named by I<format>.
+
+=item B<dump> I<domain-id> I<corefilepath>
+
+Dumps the core of a domain to a file for analysis.
+
+=item B<dumpxml> I<domain-id> optional I<--inactive> I<--security-info> I<--update-cpu>
+
+Output the domain information as an XML dump to stdout, this format can be used
+by the B<create> command. Additional options affecting the XML dump may be
+used. I<--inactive> tells virsh to dump domain configuration that will be used
+on next start of the domain as opposed to the current domain configuration.
+Using I<--security-info> security sensitive information will also be included
+in the XML dump. I<--update-cpu> updates domain CPU requirements according to
+host CPU.
+
+=item B<echo> optional I<--shell> I<--xml> I<arg>...
+
+Echo back each I<arg>, separated by space.  If I<--shell> is
+specified, then the output will be single-quoted where needed, so that
+it is suitable for reuse in a shell context.  If I<--xml> is
+specified, then the output will be escaped for use in XML.
+
+=item B<edit> I<domain-id>
+
+Edit the XML configuration file for a domain.
+
+This is equivalent to:
+
+ virsh dumpxml domain > domain.xml
+ edit domain.xml
+ virsh define domain.xml
+
+except that it does some error checking.
+
+The editor used can be supplied by the C<$VISUAL> or C<$EDITOR> environment
+variables, and defaults to C<vi>.
+
+=item B<managedsave> I<domain-id>
+
+Save and destroy a running domain, so it can be restarted from the same
+state at a later time.  When the virsh B<start> command is next run for
+the domain, it will automatically be started from this saved state.
+
+=item B<managedsave-remove> I<domain-id>
+
+Remove the B<managedsave> state file for a domain, if it exists.  This
+ensures the domain will do a full boot the next time it is started.
+
+=item B<maxvcpus> optional I<type>
+
+Provide the maximum number of virtual CPUs supported for a guest VM on
+this connection.  If provided, the I<type> parameter must be a valid
+type attribute for the <domain> element of XML.
+
+=item B<migrate> optional I<--live> I<--suspend> I<domain-id> I<desturi>
+I<migrateuri>
+
+Migrate domain to another host.  Add --live for live migration; --suspend
+leaves the domain paused on the destination host. The I<desturi> is the
+connection URI of the destination host, and I<migrateuri> is the
+migration URI, which usually can be omitted.
+
+=item B<migrate-setmaxdowntime> I<domain-id> I<downtime>
+
+Set maximum tolerable downtime for a domain which is being live-migrated to
+another host.  The I<downtime> is a number of milliseconds the guest is allowed
+to be down at the end of live migration.
+
+=item B<reboot> I<domain-id>
+
+Reboot a domain.  This acts just as if the domain had the B<reboot>
+command run from the console.  The command returns as soon as it has
+executed the reboot action, which may be significantly before the
+domain actually reboots.
+
+The exact behavior of a domain when it reboots is set by the
+I<on_reboot> parameter in the domain's XML definition.
+
+=item B<restore> I<state-file>
+
+Restores a domain from an B<virsh save> state file.  See I<save> for more info.
+
+=item B<save> I<domain-id> I<state-file>
+
+Saves a running domain to a state file so that it can be restored
+later.  Once saved, the domain will no longer be running on the
+system, thus the memory allocated for the domain will be free for
+other domains to use.  B<virsh restore> restores from this state file.
+
+This is roughly equivalent to doing a hibernate on a running computer,
+with all the same limitations.  Open network connections may be
+severed upon restore, as TCP timeouts may have expired.
+
+=item B<schedinfo> optional I<--set> B<parameter=value> I<domain-id>
+
+=item B<schedinfo> optional I<--weight> B<number> optional I<--cap> B<number> I<domain-id>
+
+Allows you to show (and set) the domain scheduler parameters. The parameters available for each hypervisor are:
+
+LXC, QEMU/KVM (posix scheduler): cpu_shares
+
+Xen (credit scheduler): weight, cap
+
+ESX (allocation scheduler): reservation, limit, shares
+
+B<Note>: The cpu_shares parameter has a valid value range of 0-262144.
+
+B<Note>: The weight and cap parameters are defined only for the
+XEN_CREDIT scheduler and are now I<DEPRECATED>.
+
+=item B<setmem> I<domain-id> B<kilobytes>
+
+Change the current memory allocation in the guest domain. This should take
+effect immediately. The memory limit is specified in
+kilobytes.
+
+For Xen, you can only adjust the memory of a running domain if the
+domain is paravirtualized or running the PV balloon driver.
+
+=item B<setmaxmem> I<domain-id> B<kilobytes>
+
+Change the maximum memory allocation limit in the guest domain. This should
+not change the current memory use. The memory limit is specified in
+kilobytes.
+
+=item B<memtune> I<domain-id> optional I<--hard-limit> B<kilobytes>
+optional I<--soft-limit> B<kilobytes> optional I<--swap-hard-limit>
+B<kilobytes> -I<--min-guarantee> B<kilobytes>
+
+Allows you to display or set the domain memory parameters. Without
+flags, the current settings are displayed; with a flag, the
+appropriate limit is adjusted if supported by the hypervisor.  LXC and
+QEMU/KVM supports I<--hard-limit>, I<--soft-limit>, and I<--swap-hard-limit>.
+
+=item B<setvcpus> I<domain-id> I<count> optional I<--maximum> I<--config>
+I<--live>
+
+Change the number of virtual CPUs active in the guest domain. Note that
+I<count> may be limited by host, hypervisor or limit coming from the
+original description of domain.
+
+For Xen, you can only adjust the virtual CPUs of a running domain if
+the domain is paravirtualized.
+
+If I<--config> is specified, the change will only affect the next
+boot of a domain.  If I<--live> is specified, the domain must be
+running, and the change takes place immediately.  Both flags may be
+specified, if supported by the hypervisor.  If neither flag is given,
+then I<--live> is implied and it is up to the hypervisor whether
+I<--config> is also implied.
+
+If I<--maximum> is specified, then you must use I<--config> and
+avoid I<--live>; this flag controls the maximum limit of vcpus that
+can be hot-plugged the next time the domain is booted.
+
+=item B<shutdown> I<domain-id>
+
+Gracefully shuts down a domain.  This coordinates with the domain OS
+to perform graceful shutdown, so there is no guarantee that it will
+succeed, and may take a variable length of time depending on what
+services must be shutdown in the domain.
+
+The exact behavior of a domain when it shuts down is set by the
+I<on_shutdown> parameter in the domain's XML definition.
+
+=item B<start> I<domain-name> optional I<--console> I<--paused>
+
+Start a (previously defined) inactive domain, either from the last
+B<managedsave> state, or via a fresh boot if no managedsave state is
+present.  The domain will be paused if the I<--paused> option is
+used and supported by the driver; otherwise it will be running.
+If I<--console> is requested, attach to the console after creation.
+
+=item B<suspend> I<domain-id>
+
+Suspend a running domain. It is kept in memory but won't be scheduled
+anymore.
+
+=item B<resume> I<domain-id>
+
+Moves a domain out of the suspended state.  This will allow a previously
+suspended domain to now be eligible for scheduling by the underlying
+hypervisor.
+
+=item B<ttyconsole> I<domain-id>
+
+Output the device used for the TTY console of the domain. If the information
+is not available the processes will provide an exit code of 1.
+
+=item B<undefine> I<domain-id>
+
+Undefine the configuration for an inactive domain. Since it's not running
+the domain name or UUID must be used as the I<domain-id>.
+
+=item B<vcpucount> I<domain-id>  optional I<--maximum> I<--current>
+I<--config> I<--live>
+
+Print information about the virtual cpu counts of the given
+I<domain-id>.  If no flags are specified, all possible counts are
+listed in a table; otherwise, the output is limited to just the
+numeric value requested.
+
+I<--maximum> requests information on the maximum cap of vcpus that a
+domain can add via B<setvcpus>, while I<--current> shows the current
+usage; these two flags cannot both be specified.  I<--config>
+requests information regarding the next time the domain will be
+booted, while I<--live> requires a running domain and lists current
+values; these two flags cannot both be specified.
+
+=item B<vcpuinfo> I<domain-id>
+
+Returns basic information about the domain virtual CPUs, like the number of
+vCPUs, the running time, the affinity to physical processors.
+
+=item B<vcpupin> I<domain-id> I<vcpu> I<cpulist>
+
+Pin domain VCPUs to host physical CPUs. The I<vcpu> number must be provided
+and I<cpulist> is a comma separated list of physical CPU numbers.
+
+=item B<vncdisplay> I<domain-id>
+
+Output the IP address and port number for the VNC display. If the information
+is not available the processes will provide an exit code of 1.
+
+=back
+
+=head1 DEVICE COMMANDS
+
+The following commands manipulate devices associated to domains.
+The domain-id can be specified as an short integer, a name or a full UUID.
+To better understand the values allowed as options for the command
+reading the documentation at L<http://libvirt.org/formatdomain.html> on the
+format of the device sections to get the most accurate set of accepted values.
+
+=over 4
+
+=item B<attach-device> I<domain-id> I<FILE>
+
+Attach a device to the domain, using a device definition in an XML file.
+See the documentation to learn about libvirt XML format for a device.
+For cdrom and floppy devices, this command only replaces the media within
+the single existing device; consider using B<update-device> for this usage.
+
+=item B<attach-disk> I<domain-id> I<source> I<target> optional I<--driver driver> I<--subdriver subdriver> I<--type type> I<--mode mode>
+
+Attach a new disk device to the domain.
+I<source> and I<target> are paths for the files and devices.
+I<driver> can be I<file>, I<tap> or I<phy> depending on the kind of access.
+I<type> can indicate I<cdrom> or I<floppy> as alternative to the disk default,
+although this use only replaces the media within the existing virtual cdrom or
+floppy device; consider using B<update-device> for this usage instead.
+I<mode> can specify the two specific mode I<readonly> or I<shareable>.
+
+=item B<attach-interface> I<domain-id> I<type> I<source> optional I<--target target> I<--mac mac> I<--script script> I<--model model> I<--persistent>
+
+Attach a new network interface to the domain.
+I<type> can be either I<network> to indicate a physical network device or I<bridge> to indicate a bridge to a device.
+I<source> indicates the source device.
+I<target> allows to indicate the target device in the guest.
+I<mac> allows to specify the MAC address of the network interface.
+I<script> allows to specify a path to a script handling a bridge instead of
+the default one.
+I<model> allows to specify the model type.
+I<persistent> indicates the changes will affect the next boot of the domain.
+
+=item B<detach-device> I<domain-id> I<FILE>
+
+Detach a device from the domain, takes the same kind of XML descriptions
+as command B<attach-device>.
+
+=item B<detach-disk> I<domain-id> I<target>
+
+Detach a disk device from a domain. The I<target> is the device as seen
+from the domain.
+
+=item B<detach-interface> I<domain-id> I<type> optional I<--mac mac>
+
+Detach a network interface from a domain.
+I<type> can be either I<network> to indicate a physical network device or I<bridge> to indicate a bridge to a device.
+It is recommended to use the I<mac> option to distinguish between the interfaces
+if more than one are present on the domain.
+
+=item B<update-device> I<domain-id> I<file> optional I<--persistent>
+
+Update the characteristics of a device associated with I<domain-id>,
+based on the device definition in an XML I<file>.  If the I<--persistent>
+option is used, the changes will affect the next boot of the domain.
+See the documentation to learn about libvirt XML format for a device.
+
+=back
+
+=head1 VIRTUAL NETWORK COMMANDS
+
+The following commands manipulate networks. Libvirt has the capability to
+define virtual networks which can then be used by domains and linked to
+actual network devices. For more detailed information about this feature
+see the documentation at L<http://libvirt.org/formatnetwork.html> . A lot
+of the command for virtual networks are similar to the one used for domains,
+but the way to name a virtual network is either by its name or UUID.
+
+=over 4
+
+=item B<net-autostart> I<network> optional I<--disable>
+
+Configure a virtual network to be automatically started at boot.
+The I<--disable> option disable autostarting.
+
+=item B<net-create> I<file>
+
+Create a virtual network from an XML I<file>, see the documentation to get
+a description of the XML network format used by libvirt.
+
+=item B<net-define> I<file>
+
+Define a virtual network from an XML I<file>, the network is just defined but
+not instantiated.
+
+=item B<net-destroy> I<network>
+
+Destroy a given virtual network specified by its name or UUID. This takes
+effect immediately.
+
+=item B<net-dumpxml> I<network>
+
+Output the virtual network information as an XML dump to stdout.
+
+=item B<net-edit> I<network>
+
+Edit the XML configuration file for a network.
+
+This is equivalent to:
+
+ virsh net-dumpxml network > network.xml
+ edit network.xml
+ virsh net-define network.xml
+
+except that it does some error checking.
+
+The editor used can be supplied by the C<$VISUAL> or C<$EDITOR> environment
+variables, and defaults to C<vi>.
+
+=item B<net-list> optional I<--inactive> or I<--all>
+
+Returns the list of active networks, if I<--all> is specified this will also
+include defined but inactive networks, if I<--inactive> is specified only the
+inactive ones will be listed.
+
+=item B<net-name> I<network-UUID>
+
+Convert a network UUID to network name.
+
+=item B<net-start> I<network>
+
+Start a (previously defined) inactive network.
+
+=item B<net-undefine> I<network>
+
+Undefine the configuration for an inactive network.
+
+=item B<net-uuid> I<network-name>
+
+Convert a network name to network UUID.
+
+=back
+
+=head1 STORAGE POOL COMMANDS
+
+The following commands manipulate storage pools. Libvirt has the
+capability to manage various storage solutions, including files, raw
+partitions, and domain-specific formats, used to provide the storage
+volumes visible as devices within virtual machines. For more detailed
+information about this feature, see the documentation at
+L<http://libvirt.org/formatstorage.html> . A lot of the commands for
+pools are similar to the ones used for domains.
+
+=over 4
+
+=item B<find-storage-pool-sources> I<type> optional I<srcSpec>
+
+Returns XML describing all storage pools of a given I<type> that could
+be found.  If I<srcSpec> is provided, it is a file that contains XML
+to further restrict the query for pools.
+
+=item B<find-storage-pool-sources> I<type> optional I<host> I<port>
+
+Returns XML describing all storage pools of a given I<type> that could
+be found.  If I<host> and I<port> are provided, they control where the
+query is performed.
+
+=item B<pool-autostart> I<pool-or-uuid> optional I<--disable>
+
+Configure whether I<pool> should automatically start at boot.
+
+=item B<pool-build> I<pool-or-uuid>
+
+Build a given pool.
+
+=item B<pool-create> I<file>
+
+Create and start a pool object from the XML I<file>.
+
+=item B<pool-create-as> I<name> I<--print-xml> I<type> optional I<source-host>
+I<source-path> I<source-dev> I<source-name> <target> I<--source-format format>
+
+Create and start a pool object I<name> from the raw parameters.  If
+I<--print-xml> is specified, then print the XML of the pool object
+without creating the pool.  Otherwise, the pool has the specified
+I<type>.
+
+=item B<pool-define> I<file>
+
+Create, but do not start, a pool object from the XML I<file>.
+
+=item B<pool-define-as> I<name> I<--print-xml> I<type> optional I<source-host>
+I<source-path> I<source-dev> I<source-name> <target> I<--source-format format>
+
+Create, but do not start, a pool object I<name> from the raw parameters.  If
+I<--print-xml> is specified, then print the XML of the pool object
+without defining the pool.  Otherwise, the pool has the specified
+I<type>.
+
+=item B<pool-destroy> I<pool-or-uuid>
+
+Destroy a given I<pool> object. Libvirt will no longer manage the
+storage described by the pool object, but the raw data contained in
+the pool is not changed, and can be later recovered with
+B<pool-create>.
+
+=item B<pool-delete> I<pool-or-uuid>
+
+Destroy the resources used by a given I<pool> object. This operation
+is non-recoverable.  The I<pool> object will still exist after this
+command.
+
+=item B<pool-dumpxml> I<pool-or-uuid>
+
+Returns the XML information about the I<pool> object.
+
+=item B<pool-edit> I<pool-or-uuid>
+
+Edit the XML configuration file for a storage pool.
+
+This is equivalent to:
+
+ virsh pool-dumpxml pool > pool.xml
+ edit pool.xml
+ virsh pool-define pool.xml
+
+except that it does some error checking.
+
+The editor used can be supplied by the C<$VISUAL> or C<$EDITOR> environment
+variables, and defaults to C<vi>.
+
+=item B<pool-info> I<pool-or-uuid>
+
+Returns basic information about the I<pool> object.
+
+=item B<pool-list> optional I<--inactive> I<--all> I<--details>
+
+List pool objects known to libvirt.  By default, only pools in use by
+active domains are listed; I<--inactive> lists just the inactive
+pools, and I<--all> lists all pools. The I<--details> option instructs
+virsh to additionally display pool persistence and capacity related
+information where available.
+
+=item B<pool-name> I<uuid>
+
+Convert the I<uuid> to a pool name.
+
+=item B<pool-refresh> I<pool-or-uuid>
+
+Refresh the list of volumes contained in I<pool>.
+
+=item B<pool-start> I<pool-or-uuid>
+
+Start the storage I<pool>, which is previously defined but inactive.
+
+=item B<pool-undefine> I<pool-or-uuid>
+
+Undefine the configuration for an inactive I<pool>.
+
+=item B<pool-uuid> I<pool>
+
+Returns the UUID of the named I<pool>.
+
+=back
+
+=head1 VOLUME COMMANDS
+
+=over 4
+
+=item B<vol-create> I<pool-or-uuid> I<FILE>
+
+Create a volume from an XML <file>.
+I<pool-or-uuid> is the name or UUID of the storage pool to create the volume in.
+I<FILE> is the XML <file> with the volume definition. An easy way to create the
+XML <file> is to use the B<vol-dumpxml> command to obtain the definition of a
+pre-existing volume.
+
+B<Example>
+
+ virsh vol-dumpxml --pool storagepool1 appvolume1 > newvolume.xml
+ edit newvolume.xml
+ virsh vol-create differentstoragepool newvolume.xml
+
+=item B<vol-create-from> I<pool-or-uuid> I<FILE> [optional I<--inputpool>
+I<pool-or-uuid>] I<vol-name-or-key-or-path>
+
+Create a volume, using another volume as input.
+I<pool-or-uuid> is the name or UUID of the storage pool to create the volume in.
+I<FILE> is the XML <file> with the volume definition.
+I<--inputpool> I<pool-or-uuid> is the name or uuid of the storage pool the
+source volume is in.
+I<vol-name-or-key-or-path> is the name or key or path of the source volume.
+
+=item B<vol-create-as> I<pool-or-uuid> I<name> I<capacity> optional
+I<--allocation> I<size> I<--format> I<string> I<--backing-vol>
+I<vol-name-or-key-or-path> I<--backing-vol-format> I<string>
+
+Create a volume from a set of arguments.
+I<pool-or-uuid> is the name or UUID of the storage pool to create the volume
+in.
+I<name> is the name of the new volume.
+I<capacity> is the size of the volume to be created, with optional k, M, G, or
+T suffix.
+I<--allocation> I<size> is the initial size to be allocated in the volume, with
+optional k, M, G, or T suffix.
+I<--format> I<string> is used in file based storage pools to specify the volume
+file format to use; raw, bochs, qcow, qcow2, vmdk.
+I<--backing-vol> I<vol-name-or-key-or-path> is the source backing
+volume to be used if taking a snapshot of an existing volume.
+I<--backing-vol-format> I<string> is the format of the snapshot backing volume;
+raw, bochs, qcow, qcow2, vmdk, host_device.
+
+=item B<vol-clone> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key-or-path> I<name>
+
+Clone an existing volume.  Less powerful, but easier to type, version of
+B<vol-create-from>.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool to create the volume in.
+I<vol-name-or-key-or-path> is the name or key or path of the source volume.
+I<name> is the name of the new volume.
+
+=item B<vol-delete> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key-or-path>
+
+Delete a given volume.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
+I<vol-name-or-key-or-path> is the name or key or path of the volume to delete.
+
+=item B<vol-wipe> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key-or-path>
+
+Wipe a volume, ensure data previously on the volume is not accessible to future reads.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
+I<vol-name-or-key-or-path> is the name or key or path of the volume to wipe.
+
+=item B<vol-dumpxml> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key-or-path>
+
+Output the volume information as an XML dump to stdout.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
+I<vol-name-or-key-or-path> is the name or key or path of the volume to output the XML of.
+
+=item B<vol-info> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key-or-path>
+
+Returns basic information about the given storage volume.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
+I<vol-name-or-key-or-path> is the name or key or path of the volume to return information for.
+
+=item B<vol-list> [optional I<--pool>] I<pool-or-uuid> optional I<--details>
+
+Return the list of volumes in the given storage pool.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool.
+The I<--details> option instructs virsh to additionally display volume
+type and capacity related information where available.
+
+=item B<vol-pool> [optional I<--uuid>] I<vol-key-or-path>
+
+Return the pool name or UUID for a given volume. By default, the pool name is
+returned. If the I<--uuid> option is given, the pool UUID is returned instead.
+I<vol-key-or-path> is the key or path of the volume to return the pool
+information for.
+
+=item B<vol-path> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key>
+
+Return the path for a given volume.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
+I<vol-name-or-key> is the name or key of the volume to return the path for.
+
+=item B<vol-name> I<vol-key-or-path>
+
+Return the name for a given volume.
+I<vol-key-or-path> is the key or path of the volume to return the name for.
+
+=item B<vol-key> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-path>
+
+Return the volume key for a given volume.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
+I<vol-name-or-path> is the name or path of the volume to return the volume key for.
+
+=back
+
+=head1 SECRET COMMMANDS
+
+The following commands manipulate "secrets" (e.g. passwords, passphrases and
+encryption keys).  Libvirt can store secrets independently from their use, and
+other objects (e.g. volumes or domains) can refer to the secrets for encryption
+or possibly other uses.  Secrets are identified using an UUID.  See
+L<http://libvirt.org/formatsecret.html> for documentation of the XML format
+used to represent properties of secrets.
+
+=over 4
+
+=item B<secret-define> I<file>
+
+Create a secret with the properties specified in I<file>, with no associated
+secret value.  If I<file> does not specify a UUID, choose one automatically.
+If I<file> specifies an UUID of an existing secret, replace its properties by
+properties defined in I<file>, without affecting the secret value.
+
+=item B<secret-dumpxml> I<secret>
+
+Output properties of I<secret> (specified by its UUID) as an XML dump to stdout.
+
+=item B<secret-set-value> I<secret> I<base64>
+
+Set the value associated with I<secret> (specified by its UUID) to the value
+Base64-encoded value I<base64>.
+
+=item B<secret-get-value> I<secret>
+
+Output the value associated with I<secret> (specified by its UUID) to stdout,
+encoded using Base64.
+
+=item B<secret-undefine> I<secret>
+
+Delete a I<secret> (specified by its UUID), including the associated value, if
+any.
+
+=item B<secret-list>
+
+Output a list of UUIDs of known secrets to stdout.
+
+=back
+
+=head1 SNAPSHOT COMMMANDS
+
+The following commands manipulate domain snapshots.  Snapshots take the
+disk, memory, and device state of a domain at a point-of-time, and save it
+for future use.  They have many uses, from saving a "clean" copy of an OS
+image to saving a domain's state before a potentially destructive operation.
+Snapshots are identified with a unique name.  See
+L<http://libvirt.org/formatsnapshot.html> for documentation of the XML format
+used to represent properties of snapshots.
+
+=over 4
+
+=item B<snapshot-create> I<domain> I<xmlfile>
+
+Create a snapshot for domain I<domain> with the properties specified in
+I<xmlfile>.  The only properties settable for a domain snapshot are the
+<name> and <description>; the rest of the fields are ignored, and
+automatically filled in by libvirt.  If I<xmlfile> is completely omitted,
+then libvirt will choose a value for all fields.
+
+=item B<snapshot-current> I<domain>
+
+Output the snapshot XML for the domain's current snapshot (if any).
+
+=item B<snapshot-list> I<domain>
+
+List all of the available snapshots for the given domain.
+
+=item B<snapshot-dumpxml> I<domain> I<snapshot>
+
+Output the snapshot XML for the domain's snapshot named I<snapshot>.
+
+=item B<snapshot-revert> I<domain> I<snapshot>
+
+Revert the given domain to the snapshot specified by I<snapshot>.  Be aware
+that this is a destructive action; any changes in the domain since the
+snapshot was taken will be lost.  Also note that the state of the domain after
+snapshot-revert is complete will be the state of the domain at the time
+the original snapshot was taken.
+
+=item B<snapshot-delete> I<domain> I<snapshot> I<--children>
+
+Delete the snapshot for the domain named I<snapshot>.  If this snapshot
+has child snapshots, changes from this snapshot will be merged into the
+children.  If I<--children> is passed, then delete this snapshot and any
+children of this snapshot.
+
+=back
+
+=head1 NWFILTER COMMMANDS
+
+The following commands manipulate network filters. Network filters allow
+filtering of the network traffic coming from and going to virtual machines.
+Individual network traffic filters are written in XML and may contain
+references to other network filters, describe traffic filtering rules,
+or contain both. Network filters are referenced by virtual machines
+from within their interface description. A network filter may be referenced
+by multiple virtual machines' interfaces.
+
+=over 4
+
+=item B<nwfilter-define> I<xmlfile>
+
+Make a new network filter known to libvirt. If a network filter with
+the same name already exists, it will be replaced with the new XML.
+Any running virtual machine referencing this network filter will have
+its network traffic rules adapted. If for any reason the network traffic
+filtering rules cannot be instantiated by any of the running virtual
+machines, then the new XML will be rejected.
+
+=item B<nwfilter-undefine> I<nwfilter-name>
+
+Delete a network filter. The deletion will fail if any running virtual
+machine is currently using this network filter.
+
+=item B<nwfilter-list>
+
+List all of the available network filters.
+
+=item B<nwfilter-dumpxml> I<nwfilter-name>
+
+Output the network filter XML.
+
+=item B<nwfilter-edit> I<nwfilter-name>
+
+Edit the XML of a network filter.
+
+This is equivalent to:
+
+ virsh nwfilter-dumpxml myfilter > myfilter.xml
+ edit myfilter.xml
+ virsh nwfilter-define myfilter.xml
+
+except that it does some error checking.
+The new network filter may be rejected due to the same reason as
+mentioned in I<nwfilter-define>.
+
+The editor used can be supplied by the C<$VISUAL> or C<$EDITOR> environment
+variables, and defaults to C<vi>.
+
+=back
+
+=head1 ENVIRONMENT
+
+The following environment variables can be set to alter the behaviour
+of C<virsh>
+
+=over 4
+
+=item VIRSH_DEFAULT_CONNECT_URI
+
+The hypervisor to connect to by default. Set this to a URI, in the same
+format as accepted by the B<connect> option.
+
+=item VISUAL
+
+The editor to use by the B<edit> and related options.
+
+=item EDITOR
+
+The editor to use by the B<edit> and related options, if C<VISUAL>
+is not set.
+
+=item LIBVIRT_DEBUG=LEVEL
+
+Turn on verbose debugging of all libvirt API calls. Valid levels are
+
+=over 4
+
+=item * LIBVIRT_DEBUG=1
+
+Messages at level DEBUG or above
+
+=item * LIBVIRT_DEBUG=2
+
+Messages at level INFO or above
+
+=item * LIBVIRT_DEBUG=3
+
+Messages at level WARNING or above
+
+=item * LIBVIRT_DEBUG=4
+
+Messages at level ERROR or above
+
+=back
+
+For further information about debugging options consult C<http://libvirt.org/logging.html>
+
+=back
+
+=head1 BUGS
+
+Report any bugs discovered to the libvirt community via the mailing
+list C<http://libvirt.org/contact.html> or bug tracker C<http://libvirt.org/bugs.html>.
+Alternatively report bugs to your software distributor / vendor.
+
+=head1 AUTHORS
+
+  Please refer to the AUTHORS file distributed with libvirt.
+
+  Based on the xm man page by:
+  Sean Dague <sean at dague dot net>
+  Daniel Stekloff <dsteklof at us dot ibm dot com>
+
+=head1 COPYRIGHT
+
+Copyright (C) 2005, 2007-2010 Red Hat, Inc., and the authors listed in the
+libvirt AUTHORS file.
+
+=head1 LICENSE
+
+virsh is distributed under the terms of the GNU LGPL v2+.
+This is free software; see the source for copying conditions. There
+is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE
+
+=head1 SEE ALSO
+
+L<virt-install(1)>, L<virt-xml-validate(1)>, L<virt-top(1)>, L<virt-mem(1)>, L<virt-df(1)>, L<http://www.libvirt.org/>
+
+=cut

=== added directory '.pc/0003-allow-libvirt-group-to-access-the-socket.patch'
=== renamed directory '.pc/0003-allow-libvirt-group-to-access-the-socket.patch' => '.pc/0003-allow-libvirt-group-to-access-the-socket.patch.moved'
=== renamed file '.pc/0003-allow-libvirt-group-to-access-the-socket.patch/daemon/libvirtd.conf' => '.pc/0003-allow-libvirt-group-to-access-the-socket.patch.moved/daemon/libvirtd.conf.THIS'
=== added file '.pc/0003-allow-libvirt-group-to-access-the-socket.patch/.timestamp'
=== added directory '.pc/0003-allow-libvirt-group-to-access-the-socket.patch/daemon'
=== added file '.pc/0003-allow-libvirt-group-to-access-the-socket.patch/daemon/libvirtd.conf'
--- .pc/0003-allow-libvirt-group-to-access-the-socket.patch/daemon/libvirtd.conf	1970-01-01 00:00:00 +0000
+++ .pc/0003-allow-libvirt-group-to-access-the-socket.patch/daemon/libvirtd.conf	2010-11-11 18:22:47 +0000
@@ -0,0 +1,346 @@
+# Master libvirt daemon configuration file
+#
+# For further information consult http://libvirt.org/format.html
+#
+# NOTE: the tests/daemon-conf regression test script requires
+# that each "PARAMETER = VALUE" line in this file have the parameter
+# name just after a leading "#".
+
+#################################################################
+#
+# Network connectivity controls
+#
+
+# Flag listening for secure TLS connections on the public TCP/IP port.
+# NB, must pass the --listen flag to the libvirtd process for this to
+# have any effect.
+#
+# It is necessary to setup a CA and issue server certificates before
+# using this capability.
+#
+# This is enabled by default, uncomment this to disable it
+#listen_tls = 0
+
+# Listen for unencrypted TCP connections on the public TCP/IP port.
+# NB, must pass the --listen flag to the libvirtd process for this to
+# have any effect.
+#
+# Using the TCP socket requires SASL authentication by default. Only
+# SASL mechanisms which support data encryption are allowed. This is
+# DIGEST_MD5 and GSSAPI (Kerberos5)
+#
+# This is disabled by default, uncomment this to enable it.
+#listen_tcp = 1
+
+
+
+# Override the port for accepting secure TLS connections
+# This can be a port number, or service name
+#
+#tls_port = "16514"
+
+# Override the port for accepting insecure TCP connections
+# This can be a port number, or service name
+#
+#tcp_port = "16509"
+
+
+# Override the default configuration which binds to all network
+# interfaces. This can be a numeric IPv4/6 address, or hostname
+#
+#listen_addr = "192.168.0.1"
+
+
+# Flag toggling mDNS advertizement of the libvirt service.
+#
+# Alternatively can disable for all services on a host by
+# stopping the Avahi daemon
+#
+# This is enabled by default, uncomment this to disable it
+#mdns_adv = 0
+
+# Override the default mDNS advertizement name. This must be
+# unique on the immediate broadcast network.
+#
+# The default is "Virtualization Host HOSTNAME", where HOSTNAME
+# is subsituted for the short hostname of the machine (without domain)
+#
+#mdns_name = "Virtualization Host Joe Demo"
+
+
+#################################################################
+#
+# UNIX socket access controls
+#
+
+# Set the UNIX domain socket group ownership. This can be used to
+# allow a 'trusted' set of users access to management capabilities
+# without becoming root.
+#
+# This is restricted to 'root' by default.
+#unix_sock_group = "libvirt"
+
+# Set the UNIX socket permissions for the R/O socket. This is used
+# for monitoring VM status only
+#
+# Default allows any user. If setting group ownership may want to
+# restrict this to:
+#unix_sock_ro_perms = "0777"
+
+# Set the UNIX socket permissions for the R/W socket. This is used
+# for full management of VMs
+#
+# Default allows only root. If PolicyKit is enabled on the socket,
+# the default will change to allow everyone (eg, 0777)
+#
+# If not using PolicyKit and setting group ownership for access
+# control then you may want to relax this to:
+#unix_sock_rw_perms = "0770"
+
+# Set the name of the directory in which sockets will be found/created.
+#unix_sock_dir = "/var/run/libvirt"
+
+#################################################################
+#
+# Authentication.
+#
+#  - none: do not perform auth checks. If you can connect to the
+#          socket you are allowed. This is suitable if there are
+#          restrictions on connecting to the socket (eg, UNIX
+#          socket permissions), or if there is a lower layer in
+#          the network providing auth (eg, TLS/x509 certificates)
+#
+#  - sasl: use SASL infrastructure. The actual auth scheme is then
+#          controlled from /etc/sasl2/libvirt.conf. For the TCP
+#          socket only GSSAPI & DIGEST-MD5 mechanisms will be used.
+#          For non-TCP or TLS sockets,  any scheme is allowed.
+#
+#  - polkit: use PolicyKit to authenticate. This is only suitable
+#            for use on the UNIX sockets. The default policy will
+#            require a user to supply their own password to gain
+#            full read/write access (aka sudo like), while anyone
+#            is allowed read/only access.
+#
+# Set an authentication scheme for UNIX read-only sockets
+# By default socket permissions allow anyone to connect
+#
+# To restrict monitoring of domains you may wish to enable
+# an authentication mechanism here
+#auth_unix_ro = "none"
+
+# Set an authentication scheme for UNIX read-write sockets
+# By default socket permissions only allow root. If PolicyKit
+# support was compiled into libvirt, the default will be to
+# use 'polkit' auth.
+#
+# If the unix_sock_rw_perms are changed you may wish to enable
+# an authentication mechanism here
+#auth_unix_rw = "none"
+
+# Change the authentication scheme for TCP sockets.
+#
+# If you don't enable SASL, then all TCP traffic is cleartext.
+# Don't do this outside of a dev/test scenario. For real world
+# use, always enable SASL and use the GSSAPI or DIGEST-MD5
+# mechanism in /etc/sasl2/libvirt.conf
+#auth_tcp = "sasl"
+
+# Change the authentication scheme for TLS sockets.
+#
+# TLS sockets already have encryption provided by the TLS
+# layer, and limited authentication is done by certificates
+#
+# It is possible to make use of any SASL authentication
+# mechanism as well, by using 'sasl' for this option
+#auth_tls = "none"
+
+
+
+#################################################################
+#
+# TLS x509 certificate configuration
+#
+
+
+# Override the default server key file path
+#
+#key_file = "/etc/pki/libvirt/private/serverkey.pem"
+
+# Override the default server certificate file path
+#
+#cert_file = "/etc/pki/libvirt/servercert.pem"
+
+# Override the default CA certificate path
+#
+#ca_file = "/etc/pki/CA/cacert.pem"
+
+# Specify a certificate revocation list.
+#
+# Defaults to not using a CRL, uncomment to enable it
+#crl_file = "/etc/pki/CA/crl.pem"
+
+
+
+#################################################################
+#
+# Authorization controls
+#
+
+
+# Flag to disable verification of client certificates
+#
+# Client certificate verification is the primary authentication mechanism.
+# Any client which does not present a certificate signed by the CA
+# will be rejected.
+#
+# Default is to always verify. Uncommenting this will disable
+# verification - make sure an IP whitelist is set
+#tls_no_verify_certificate = 1
+
+
+# A whitelist of allowed x509  Distinguished Names
+# This list may contain wildcards such as
+#
+#    "C=GB,ST=London,L=London,O=Red Hat,CN=*"
+#
+# See the POSIX fnmatch function for the format of the wildcards.
+#
+# NB If this is an empty list, no client can connect, so comment out
+# entirely rather than using empty list to disable these checks
+#
+# By default, no DN's are checked
+#tls_allowed_dn_list = ["DN1", "DN2"]
+
+
+# A whitelist of allowed SASL usernames. The format for usernames
+# depends on the SASL authentication mechanism. Kerberos usernames
+# look like username@REALM
+#
+# This list may contain wildcards such as
+#
+#    "*@EXAMPLE.COM"
+#
+# See the POSIX fnmatch function for the format of the wildcards.
+#
+# NB If this is an empty list, no client can connect, so comment out
+# entirely rather than using empty list to disable these checks
+#
+# By default, no Username's are checked
+#sasl_allowed_username_list = ["[e-mail]", "[e-mail]" ]
+
+
+
+#################################################################
+#
+# Processing controls
+#
+
+# The maximum number of concurrent client connections to allow
+# over all sockets combined.
+#max_clients = 20
+
+
+# The minimum limit sets the number of workers to start up
+# initially. If the number of active clients exceeds this,
+# then more threads are spawned, upto max_workers limit.
+# Typically you'd want max_workers to equal maximum number
+# of clients allowed
+#min_workers = 5
+#max_workers = 20
+
+# Total global limit on concurrent RPC calls. Should be
+# at least as large as max_workers. Beyond this, RPC requests
+# will be read into memory and queued. This directly impact
+# memory usage, currently each request requires 256 KB of
+# memory. So by default upto 5 MB of memory is used
+#
+# XXX this isn't actually enforced yet, only the per-client
+# limit is used so far
+#max_requests = 20
+
+# Limit on concurrent requests from a single client
+# connection. To avoid one client monopolizing the server
+# this should be a small fraction of the global max_requests
+# and max_workers parameter
+#max_client_requests = 5
+
+#################################################################
+#
+# Logging controls
+#
+
+# Logging level: 4 errors, 3 warnings, 2 informations, 1 debug
+# basically 1 will log everything possible
+#log_level = 3
+
+# Logging filters:
+# A filter allows to select a different logging level for a given category
+# of logs
+# The format for a filter is:
+#    x:name
+#      where name is a match string e.g. remote or qemu
+# the x prefix is the minimal level where matching messages should be logged
+#    1: DEBUG
+#    2: INFO
+#    3: WARNING
+#    4: ERROR
+#
+# Multiple filter can be defined in a single @filters, they just need to be
+# separated by spaces.
+#
+# e.g:
+# log_filters="3:remote 4:event"
+# to only get warning or errors from the remote layer and only errors from
+# the event layer.
+
+# Logging outputs:
+# An output is one of the places to save logging informations
+# The format for an output can be:
+#    x:stderr
+#      output goes to stderr
+#    x:syslog:name
+#      use syslog for the output and use the given name as the ident
+#    x:file:file_path
+#      output to a file, with the given filepath
+# In all case the x prefix is the minimal level, acting as a filter
+#    1: DEBUG
+#    2: INFO
+#    3: WARNING
+#    4: ERROR
+#
+# Multiple output can be defined, they just need to be separated by spaces.
+# e.g.:
+# log_outputs="3:syslog:libvirtd"
+# to log all warnings and errors to syslog under the libvirtd ident
+
+
+##################################################################
+#
+# Auditing
+#
+# This setting allows usage of the auditing subsystem to be altered:
+#
+#   audit_level == 0  -> disable all auditing
+#   audit_level == 1  -> enable auditing, only if enabled on host (default)
+#   audit_level == 2  -> enable auditing, and exit if disabled on host
+#
+#audit_level = 2
+#
+# If set to 1, then audit messages will also be sent
+# via libvirt logging infrastructure. Defaults to 0
+#
+#audit_logging = 1
+
+###################################################################
+# UUID of the host:
+# Provide the UUID of the host here in case the command
+# 'dmidecode -s system-uuid' does not provide a valid uuid. In case
+# 'dmidecode' does not provide a valid UUID and none is provided here, a
+# temporary UUID will be generated.
+# Keep the format of the example UUID below. UUID must not have all digits
+# be the same.
+
+# NB This default all-zeros UUID will not work. Replace
+# it with the output of the 'uuidgen' command and then
+# uncomment this entry
+#host_uuid = "00000000-0000-0000-0000-000000000000"

=== added directory '.pc/0004-fix-Debian-specific-path-to-hvm-loader.patch'
=== renamed directory '.pc/0004-fix-Debian-specific-path-to-hvm-loader.patch' => '.pc/0004-fix-Debian-specific-path-to-hvm-loader.patch.moved'
=== renamed file '.pc/0004-fix-Debian-specific-path-to-hvm-loader.patch/src/xen/xen_hypervisor.c' => '.pc/0004-fix-Debian-specific-path-to-hvm-loader.patch.moved/src/xen/xen_hypervisor.c.THIS'
=== added file '.pc/0004-fix-Debian-specific-path-to-hvm-loader.patch/.timestamp'
=== added directory '.pc/0004-fix-Debian-specific-path-to-hvm-loader.patch/src'
=== added directory '.pc/0004-fix-Debian-specific-path-to-hvm-loader.patch/src/xen'
=== added file '.pc/0004-fix-Debian-specific-path-to-hvm-loader.patch/src/xen/xen_hypervisor.c'
--- .pc/0004-fix-Debian-specific-path-to-hvm-loader.patch/src/xen/xen_hypervisor.c	1970-01-01 00:00:00 +0000
+++ .pc/0004-fix-Debian-specific-path-to-hvm-loader.patch/src/xen/xen_hypervisor.c	2010-11-11 18:22:47 +0000
@@ -0,0 +1,3588 @@
+/*
+ * xen_internal.c: direct access to Xen hypervisor level
+ *
+ * Copyright (C) 2005-2010 Red Hat, Inc.
+ *
+ * See COPYING.LIB for the License of this software
+ *
+ * Daniel Veillard <[e-mail]>
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <string.h>
+/* required for uint8_t, uint32_t, etc ... */
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <limits.h>
+#include <stdint.h>
+#include <regex.h>
+#include <errno.h>
+#include <sys/utsname.h>
+
+#ifdef __sun
+# include <sys/systeminfo.h>
+
+# include <priv.h>
+
+# ifndef PRIV_XVM_CONTROL
+#  define PRIV_XVM_CONTROL ((const char *)"xvm_control")
+# endif
+
+#endif /* __sun */
+
+/* required for dom0_getdomaininfo_t */
+#include <xen/dom0_ops.h>
+#include <xen/version.h>
+#ifdef HAVE_XEN_LINUX_PRIVCMD_H
+# include <xen/linux/privcmd.h>
+#else
+# ifdef HAVE_XEN_SYS_PRIVCMD_H
+#  include <xen/sys/privcmd.h>
+# endif
+#endif
+
+/* required for shutdown flags */
+#include <xen/sched.h>
+
+#include "virterror_internal.h"
+#include "logging.h"
+#include "datatypes.h"
+#include "driver.h"
+#include "util.h"
+#include "xen_driver.h"
+#include "xen_hypervisor.h"
+#include "xs_internal.h"
+#include "stats_linux.h"
+#include "block_stats.h"
+#include "xend_internal.h"
+#include "buf.h"
+#include "capabilities.h"
+#include "memory.h"
+
+#define VIR_FROM_THIS VIR_FROM_XEN
+
+/*
+ * so far there is 2 versions of the structures usable for doing
+ * hypervisor calls.
+ */
+/* the old one */
+typedef struct v0_hypercall_struct {
+    unsigned long op;
+    unsigned long arg[5];
+} v0_hypercall_t;
+
+#ifdef __linux__
+# define XEN_V0_IOCTL_HYPERCALL_CMD \
+        _IOC(_IOC_NONE, 'P', 0, sizeof(v0_hypercall_t))
+/* the new one */
+typedef struct v1_hypercall_struct
+{
+    uint64_t op;
+    uint64_t arg[5];
+} v1_hypercall_t;
+# define XEN_V1_IOCTL_HYPERCALL_CMD                  \
+    _IOC(_IOC_NONE, 'P', 0, sizeof(v1_hypercall_t))
+typedef v1_hypercall_t hypercall_t;
+#elif defined(__sun)
+typedef privcmd_hypercall_t hypercall_t;
+#else
+# error "unsupported platform"
+#endif
+
+#ifndef __HYPERVISOR_sysctl
+# define __HYPERVISOR_sysctl 35
+#endif
+#ifndef __HYPERVISOR_domctl
+# define __HYPERVISOR_domctl 36
+#endif
+
+#ifdef WITH_RHEL5_API
+# define SYS_IFACE_MIN_VERS_NUMA 3
+#else
+# define SYS_IFACE_MIN_VERS_NUMA 4
+#endif
+
+/* xen-unstable changeset 19788 removed MAX_VIRT_CPUS from public
+ * headers.  Its semanitc was retained with XEN_LEGACY_MAX_VCPUS.
+ * Ensure MAX_VIRT_CPUS is defined accordingly.
+ */
+#if !defined(MAX_VIRT_CPUS) && defined(XEN_LEGACY_MAX_VCPUS)
+# define MAX_VIRT_CPUS XEN_LEGACY_MAX_VCPUS
+#endif
+
+static int xen_ioctl_hypercall_cmd = 0;
+static int initialized = 0;
+static int in_init = 0;
+static int hv_version = 0;
+static int hypervisor_version = 2;
+static int sys_interface_version = -1;
+static int dom_interface_version = -1;
+static int kb_per_pages = 0;
+
+/* Regular expressions used by xenHypervisorGetCapabilities, and
+ * compiled once by xenHypervisorInit.  Note that these are POSIX.2
+ * extended regular expressions (regex(7)).
+ */
+static const char *flags_hvm_re = "^flags[[:blank:]]+:.* (vmx|svm)[[:space:]]";
+static regex_t flags_hvm_rec;
+static const char *flags_pae_re = "^flags[[:blank:]]+:.* pae[[:space:]]";
+static regex_t flags_pae_rec;
+static const char *xen_cap_re = "(xen|hvm)-[[:digit:]]+\\.[[:digit:]]+-(x86_32|x86_64|ia64|powerpc64)(p|be)?";
+static regex_t xen_cap_rec;
+
+/*
+ * The content of the structures for a getdomaininfolist system hypercall
+ */
+#ifndef DOMFLAGS_DYING
+# define DOMFLAGS_DYING     (1<<0) /* Domain is scheduled to die.             */
+# define DOMFLAGS_HVM       (1<<1) /* Domain is HVM                           */
+# define DOMFLAGS_SHUTDOWN  (1<<2) /* The guest OS has shut down.             */
+# define DOMFLAGS_PAUSED    (1<<3) /* Currently paused by control software.   */
+# define DOMFLAGS_BLOCKED   (1<<4) /* Currently blocked pending an event.     */
+# define DOMFLAGS_RUNNING   (1<<5) /* Domain is currently running.            */
+# define DOMFLAGS_CPUMASK      255 /* CPU to which this domain is bound.      */
+# define DOMFLAGS_CPUSHIFT       8
+# define DOMFLAGS_SHUTDOWNMASK 255 /* DOMFLAGS_SHUTDOWN guest-supplied code.  */
+# define DOMFLAGS_SHUTDOWNSHIFT 16
+#endif
+
+/*
+ * These flags explain why a system is in the state of "shutdown".  Normally,
+ * They are defined in xen/sched.h
+ */
+#ifndef SHUTDOWN_poweroff
+# define SHUTDOWN_poweroff   0  /* Domain exited normally. Clean up and kill. */
+# define SHUTDOWN_reboot     1  /* Clean up, kill, and then restart.          */
+# define SHUTDOWN_suspend    2  /* Clean up, save suspend info, kill.         */
+# define SHUTDOWN_crash      3  /* Tell controller we've crashed.             */
+#endif
+
+#define XEN_V0_OP_GETDOMAININFOLIST	38
+#define XEN_V1_OP_GETDOMAININFOLIST	38
+#define XEN_V2_OP_GETDOMAININFOLIST	6
+
+struct xen_v0_getdomaininfo {
+    domid_t  domain;	/* the domain number */
+    uint32_t flags;	/* flags, see before */
+    uint64_t tot_pages;	/* total number of pages used */
+    uint64_t max_pages;	/* maximum number of pages allowed */
+    unsigned long shared_info_frame; /* MFN of shared_info struct */
+    uint64_t cpu_time;  /* CPU time used */
+    uint32_t nr_online_vcpus;  /* Number of VCPUs currently online. */
+    uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */
+    uint32_t ssidref;
+    xen_domain_handle_t handle;
+};
+typedef struct xen_v0_getdomaininfo xen_v0_getdomaininfo;
+
+struct xen_v2_getdomaininfo {
+    domid_t  domain;	/* the domain number */
+    uint32_t flags;	/* flags, see before */
+    uint64_t tot_pages;	/* total number of pages used */
+    uint64_t max_pages;	/* maximum number of pages allowed */
+    uint64_t shared_info_frame; /* MFN of shared_info struct */
+    uint64_t cpu_time;  /* CPU time used */
+    uint32_t nr_online_vcpus;  /* Number of VCPUs currently online. */
+    uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */
+    uint32_t ssidref;
+    xen_domain_handle_t handle;
+};
+typedef struct xen_v2_getdomaininfo xen_v2_getdomaininfo;
+
+
+/* As of Hypervisor Call v2,  DomCtl v5 we are now 8-byte aligned
+   even on 32-bit archs when dealing with uint64_t */
+#define ALIGN_64 __attribute__((aligned(8)))
+
+struct xen_v2d5_getdomaininfo {
+    domid_t  domain;	/* the domain number */
+    uint32_t flags;	/* flags, see before */
+    uint64_t tot_pages ALIGN_64;	/* total number of pages used */
+    uint64_t max_pages ALIGN_64;	/* maximum number of pages allowed */
+    uint64_t shared_info_frame ALIGN_64; /* MFN of shared_info struct */
+    uint64_t cpu_time ALIGN_64;  /* CPU time used */
+    uint32_t nr_online_vcpus;  /* Number of VCPUs currently online. */
+    uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */
+    uint32_t ssidref;
+    xen_domain_handle_t handle;
+};
+typedef struct xen_v2d5_getdomaininfo xen_v2d5_getdomaininfo;
+
+struct xen_v2d6_getdomaininfo {
+    domid_t  domain;	/* the domain number */
+    uint32_t flags;	/* flags, see before */
+    uint64_t tot_pages ALIGN_64;	/* total number of pages used */
+    uint64_t max_pages ALIGN_64;	/* maximum number of pages allowed */
+    uint64_t shr_pages ALIGN_64;    /* number of shared pages */
+    uint64_t shared_info_frame ALIGN_64; /* MFN of shared_info struct */
+    uint64_t cpu_time ALIGN_64;  /* CPU time used */
+    uint32_t nr_online_vcpus;  /* Number of VCPUs currently online. */
+    uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */
+    uint32_t ssidref;
+    xen_domain_handle_t handle;
+};
+typedef struct xen_v2d6_getdomaininfo xen_v2d6_getdomaininfo;
+
+union xen_getdomaininfo {
+    struct xen_v0_getdomaininfo v0;
+    struct xen_v2_getdomaininfo v2;
+    struct xen_v2d5_getdomaininfo v2d5;
+    struct xen_v2d6_getdomaininfo v2d6;
+};
+typedef union xen_getdomaininfo xen_getdomaininfo;
+
+union xen_getdomaininfolist {
+    struct xen_v0_getdomaininfo *v0;
+    struct xen_v2_getdomaininfo *v2;
+    struct xen_v2d5_getdomaininfo *v2d5;
+    struct xen_v2d6_getdomaininfo *v2d6;
+};
+typedef union xen_getdomaininfolist xen_getdomaininfolist;
+
+
+struct xen_v2_getschedulerid {
+    uint32_t sched_id; /* Get Scheduler ID from Xen */
+};
+typedef struct xen_v2_getschedulerid xen_v2_getschedulerid;
+
+
+union xen_getschedulerid {
+    struct xen_v2_getschedulerid *v2;
+};
+typedef union xen_getschedulerid xen_getschedulerid;
+
+struct xen_v2s4_availheap {
+    uint32_t min_bitwidth;  /* Smallest address width (zero if don't care). */
+    uint32_t max_bitwidth;  /* Largest address width (zero if don't care). */
+    int32_t  node;          /* NUMA node (-1 for sum across all nodes). */
+    uint64_t avail_bytes;   /* Bytes available in the specified region. */
+};
+
+typedef struct xen_v2s4_availheap  xen_v2s4_availheap;
+
+struct xen_v2s5_availheap {
+    uint32_t min_bitwidth;  /* Smallest address width (zero if don't care). */
+    uint32_t max_bitwidth;  /* Largest address width (zero if don't care). */
+    int32_t  node;          /* NUMA node (-1 for sum across all nodes). */
+    uint64_t avail_bytes ALIGN_64;   /* Bytes available in the specified region. */
+};
+
+typedef struct xen_v2s5_availheap  xen_v2s5_availheap;
+
+
+#define XEN_GETDOMAININFOLIST_ALLOC(domlist, size)                      \
+    (hypervisor_version < 2 ?                                           \
+     (VIR_ALLOC_N(domlist.v0, (size)) == 0) :                           \
+     (dom_interface_version >= 6 ?                                      \
+      (VIR_ALLOC_N(domlist.v2d6, (size)) == 0) :                        \
+     (dom_interface_version == 5 ?                                      \
+      (VIR_ALLOC_N(domlist.v2d5, (size)) == 0) :                        \
+      (VIR_ALLOC_N(domlist.v2, (size)) == 0))))
+
+#define XEN_GETDOMAININFOLIST_FREE(domlist)            \
+    (hypervisor_version < 2 ?                          \
+     VIR_FREE(domlist.v0) :                            \
+     (dom_interface_version >= 6 ?                     \
+      VIR_FREE(domlist.v2d6) :                         \
+     (dom_interface_version == 5 ?                     \
+      VIR_FREE(domlist.v2d5) :                         \
+      VIR_FREE(domlist.v2))))
+
+#define XEN_GETDOMAININFOLIST_CLEAR(domlist, size)            \
+    (hypervisor_version < 2 ?                                 \
+     memset(domlist.v0, 0, sizeof(*domlist.v0) * size) :      \
+     (dom_interface_version >= 6 ?                            \
+      memset(domlist.v2d6, 0, sizeof(*domlist.v2d6) * size) : \
+     (dom_interface_version == 5 ?                            \
+      memset(domlist.v2d5, 0, sizeof(*domlist.v2d5) * size) : \
+      memset(domlist.v2, 0, sizeof(*domlist.v2) * size))))
+
+#define XEN_GETDOMAININFOLIST_DOMAIN(domlist, n)    \
+    (hypervisor_version < 2 ?                       \
+     domlist.v0[n].domain :                         \
+     (dom_interface_version >= 6 ?                  \
+      domlist.v2d6[n].domain :                      \
+     (dom_interface_version == 5 ?                  \
+      domlist.v2d5[n].domain :                      \
+      domlist.v2[n].domain)))
+
+#define XEN_GETDOMAININFOLIST_UUID(domlist, n)      \
+    (hypervisor_version < 2 ?                       \
+     domlist.v0[n].handle :                         \
+     (dom_interface_version >= 6 ?                  \
+      domlist.v2d6[n].handle :                      \
+     (dom_interface_version == 5 ?                  \
+      domlist.v2d5[n].handle :                      \
+      domlist.v2[n].handle)))
+
+#define XEN_GETDOMAININFOLIST_DATA(domlist)        \
+    (hypervisor_version < 2 ?                      \
+     (void*)(domlist->v0) :                        \
+     (dom_interface_version >= 6 ?                 \
+      (void*)(domlist->v2d6) :                     \
+     (dom_interface_version == 5 ?                 \
+      (void*)(domlist->v2d5) :                     \
+      (void*)(domlist->v2))))
+
+#define XEN_GETDOMAININFO_SIZE                     \
+    (hypervisor_version < 2 ?                      \
+     sizeof(xen_v0_getdomaininfo) :                \
+     (dom_interface_version >= 6 ?                 \
+      sizeof(xen_v2d6_getdomaininfo) :             \
+     (dom_interface_version == 5 ?                 \
+      sizeof(xen_v2d5_getdomaininfo) :             \
+      sizeof(xen_v2_getdomaininfo))))
+
+#define XEN_GETDOMAININFO_CLEAR(dominfo)                           \
+    (hypervisor_version < 2 ?                                      \
+     memset(&(dominfo.v0), 0, sizeof(xen_v0_getdomaininfo)) :      \
+     (dom_interface_version >= 6 ?                                 \
+      memset(&(dominfo.v2d6), 0, sizeof(xen_v2d6_getdomaininfo)) : \
+     (dom_interface_version == 5 ?                                 \
+      memset(&(dominfo.v2d5), 0, sizeof(xen_v2d5_getdomaininfo)) : \
+      memset(&(dominfo.v2), 0, sizeof(xen_v2_getdomaininfo)))))
+
+#define XEN_GETDOMAININFO_DOMAIN(dominfo)       \
+    (hypervisor_version < 2 ?                   \
+     dominfo.v0.domain :                        \
+     (dom_interface_version >= 6 ?              \
+      dominfo.v2d6.domain :                     \
+     (dom_interface_version == 5 ?              \
+      dominfo.v2d5.domain :                     \
+      dominfo.v2.domain)))
+
+#define XEN_GETDOMAININFO_CPUTIME(dominfo)      \
+    (hypervisor_version < 2 ?                   \
+     dominfo.v0.cpu_time :                      \
+     (dom_interface_version >= 6 ?              \
+      dominfo.v2d6.cpu_time :                   \
+     (dom_interface_version == 5 ?              \
+      dominfo.v2d5.cpu_time :                   \
+      dominfo.v2.cpu_time)))
+
+
+#define XEN_GETDOMAININFO_CPUCOUNT(dominfo)     \
+    (hypervisor_version < 2 ?                   \
+     dominfo.v0.nr_online_vcpus :               \
+     (dom_interface_version >= 6 ?              \
+      dominfo.v2d6.nr_online_vcpus :            \
+     (dom_interface_version == 5 ?              \
+      dominfo.v2d5.nr_online_vcpus :            \
+      dominfo.v2.nr_online_vcpus)))
+
+#define XEN_GETDOMAININFO_MAXCPUID(dominfo)  \
+    (hypervisor_version < 2 ?                   \
+     dominfo.v0.max_vcpu_id :                   \
+     (dom_interface_version >= 6 ?              \
+      dominfo.v2d6.max_vcpu_id :                \
+     (dom_interface_version == 5 ?              \
+      dominfo.v2d5.max_vcpu_id :                \
+      dominfo.v2.max_vcpu_id)))
+
+#define XEN_GETDOMAININFO_FLAGS(dominfo)        \
+    (hypervisor_version < 2 ?                   \
+     dominfo.v0.flags :                         \
+     (dom_interface_version >= 6 ?              \
+      dominfo.v2d6.flags :                      \
+     (dom_interface_version == 5 ?              \
+      dominfo.v2d5.flags :                      \
+      dominfo.v2.flags)))
+
+#define XEN_GETDOMAININFO_TOT_PAGES(dominfo)    \
+    (hypervisor_version < 2 ?                   \
+     dominfo.v0.tot_pages :                     \
+     (dom_interface_version >= 6 ?              \
+      dominfo.v2d6.tot_pages :                  \
+     (dom_interface_version == 5 ?              \
+      dominfo.v2d5.tot_pages :                  \
+      dominfo.v2.tot_pages)))
+
+#define XEN_GETDOMAININFO_MAX_PAGES(dominfo)    \
+    (hypervisor_version < 2 ?                   \
+     dominfo.v0.max_pages :                     \
+     (dom_interface_version >= 6 ?              \
+      dominfo.v2d6.max_pages :                  \
+     (dom_interface_version == 5 ?              \
+      dominfo.v2d5.max_pages :                  \
+      dominfo.v2.max_pages)))
+
+#define XEN_GETDOMAININFO_UUID(dominfo)         \
+    (hypervisor_version < 2 ?                   \
+     dominfo.v0.handle :                        \
+     (dom_interface_version >= 6 ?              \
+      dominfo.v2d6.handle :                     \
+     (dom_interface_version == 5 ?              \
+      dominfo.v2d5.handle :                     \
+      dominfo.v2.handle)))
+
+
+static int
+lock_pages(void *addr, size_t len)
+{
+#ifdef __linux__
+        return (mlock(addr, len));
+#elif defined(__sun)
+        return (0);
+#endif
+}
+
+static int
+unlock_pages(void *addr, size_t len)
+{
+#ifdef __linux__
+        return (munlock(addr, len));
+#elif defined(__sun)
+        return (0);
+#endif
+}
+
+
+struct xen_v0_getdomaininfolistop {
+    domid_t   first_domain;
+    uint32_t  max_domains;
+    struct xen_v0_getdomaininfo *buffer;
+    uint32_t  num_domains;
+};
+typedef struct xen_v0_getdomaininfolistop xen_v0_getdomaininfolistop;
+
+
+struct xen_v2_getdomaininfolistop {
+    domid_t   first_domain;
+    uint32_t  max_domains;
+    struct xen_v2_getdomaininfo *buffer;
+    uint32_t  num_domains;
+};
+typedef struct xen_v2_getdomaininfolistop xen_v2_getdomaininfolistop;
+
+/* As of HV version 2, sysctl version 3 the *buffer pointer is 64-bit aligned */
+struct xen_v2s3_getdomaininfolistop {
+    domid_t   first_domain;
+    uint32_t  max_domains;
+#ifdef __BIG_ENDIAN__
+    struct {
+        int __pad[(sizeof (long long) - sizeof (struct xen_v2d5_getdomaininfo *)) / sizeof (int)];
+        struct xen_v2d5_getdomaininfo *v;
+    } buffer;
+#else
+    union {
+        struct xen_v2d5_getdomaininfo *v;
+        uint64_t pad ALIGN_64;
+    } buffer;
+#endif
+    uint32_t  num_domains;
+};
+typedef struct xen_v2s3_getdomaininfolistop xen_v2s3_getdomaininfolistop;
+
+
+
+struct xen_v0_domainop {
+    domid_t   domain;
+};
+typedef struct xen_v0_domainop xen_v0_domainop;
+
+/*
+ * The information for a destroydomain system hypercall
+ */
+#define XEN_V0_OP_DESTROYDOMAIN	9
+#define XEN_V1_OP_DESTROYDOMAIN	9
+#define XEN_V2_OP_DESTROYDOMAIN	2
+
+/*
+ * The information for a pausedomain system hypercall
+ */
+#define XEN_V0_OP_PAUSEDOMAIN	10
+#define XEN_V1_OP_PAUSEDOMAIN	10
+#define XEN_V2_OP_PAUSEDOMAIN	3
+
+/*
+ * The information for an unpausedomain system hypercall
+ */
+#define XEN_V0_OP_UNPAUSEDOMAIN	11
+#define XEN_V1_OP_UNPAUSEDOMAIN	11
+#define XEN_V2_OP_UNPAUSEDOMAIN	4
+
+/*
+ * The information for an setmaxmem system hypercall
+ */
+#define XEN_V0_OP_SETMAXMEM	28
+#define XEN_V1_OP_SETMAXMEM	28
+#define XEN_V2_OP_SETMAXMEM	11
+
+struct xen_v0_setmaxmem {
+    domid_t	domain;
+    uint64_t	maxmem;
+};
+typedef struct xen_v0_setmaxmem xen_v0_setmaxmem;
+typedef struct xen_v0_setmaxmem xen_v1_setmaxmem;
+
+struct xen_v2_setmaxmem {
+    uint64_t	maxmem;
+};
+typedef struct xen_v2_setmaxmem xen_v2_setmaxmem;
+
+struct xen_v2d5_setmaxmem {
+    uint64_t	maxmem ALIGN_64;
+};
+typedef struct xen_v2d5_setmaxmem xen_v2d5_setmaxmem;
+
+/*
+ * The information for an setmaxvcpu system hypercall
+ */
+#define XEN_V0_OP_SETMAXVCPU	41
+#define XEN_V1_OP_SETMAXVCPU	41
+#define XEN_V2_OP_SETMAXVCPU	15
+
+struct xen_v0_setmaxvcpu {
+    domid_t	domain;
+    uint32_t	maxvcpu;
+};
+typedef struct xen_v0_setmaxvcpu xen_v0_setmaxvcpu;
+typedef struct xen_v0_setmaxvcpu xen_v1_setmaxvcpu;
+
+struct xen_v2_setmaxvcpu {
+    uint32_t	maxvcpu;
+};
+typedef struct xen_v2_setmaxvcpu xen_v2_setmaxvcpu;
+
+/*
+ * The information for an setvcpumap system hypercall
+ * Note that between 1 and 2 the limitation to 64 physical CPU was lifted
+ * hence the difference in structures
+ */
+#define XEN_V0_OP_SETVCPUMAP	20
+#define XEN_V1_OP_SETVCPUMAP	20
+#define XEN_V2_OP_SETVCPUMAP	9
+
+struct xen_v0_setvcpumap {
+    domid_t	domain;
+    uint32_t	vcpu;
+    cpumap_t    cpumap;
+};
+typedef struct xen_v0_setvcpumap xen_v0_setvcpumap;
+typedef struct xen_v0_setvcpumap xen_v1_setvcpumap;
+
+struct xen_v2_cpumap {
+    uint8_t    *bitmap;
+    uint32_t    nr_cpus;
+};
+struct xen_v2_setvcpumap {
+    uint32_t	vcpu;
+    struct xen_v2_cpumap cpumap;
+};
+typedef struct xen_v2_setvcpumap xen_v2_setvcpumap;
+
+/* HV version 2, Dom version 5 requires 64-bit alignment */
+struct xen_v2d5_cpumap {
+#ifdef __BIG_ENDIAN__
+    struct {
+        int __pad[(sizeof (long long) - sizeof (uint8_t *)) / sizeof (int)];
+        uint8_t *v;
+    } bitmap;
+#else
+    union {
+        uint8_t    *v;
+        uint64_t   pad ALIGN_64;
+    } bitmap;
+#endif
+    uint32_t    nr_cpus;
+};
+struct xen_v2d5_setvcpumap {
+    uint32_t	vcpu;
+    struct xen_v2d5_cpumap cpumap;
+};
+typedef struct xen_v2d5_setvcpumap xen_v2d5_setvcpumap;
+
+/*
+ * The information for an vcpuinfo system hypercall
+ */
+#define XEN_V0_OP_GETVCPUINFO   43
+#define XEN_V1_OP_GETVCPUINFO	43
+#define XEN_V2_OP_GETVCPUINFO   14
+
+struct xen_v0_vcpuinfo {
+    domid_t	domain;		/* owner's domain */
+    uint32_t	vcpu;		/* the vcpu number */
+    uint8_t	online;		/* seen as on line */
+    uint8_t	blocked;	/* blocked on event */
+    uint8_t	running;	/* scheduled on CPU */
+    uint64_t    cpu_time;	/* nanosecond of CPU used */
+    uint32_t	cpu;		/* current mapping */
+    cpumap_t	cpumap;		/* deprecated in V2 */
+};
+typedef struct xen_v0_vcpuinfo xen_v0_vcpuinfo;
+typedef struct xen_v0_vcpuinfo xen_v1_vcpuinfo;
+
+struct xen_v2_vcpuinfo {
+    uint32_t	vcpu;		/* the vcpu number */
+    uint8_t	online;		/* seen as on line */
+    uint8_t	blocked;	/* blocked on event */
+    uint8_t	running;	/* scheduled on CPU */
+    uint64_t    cpu_time;	/* nanosecond of CPU used */
+    uint32_t	cpu;		/* current mapping */
+};
+typedef struct xen_v2_vcpuinfo xen_v2_vcpuinfo;
+
+struct xen_v2d5_vcpuinfo {
+    uint32_t	vcpu;		/* the vcpu number */
+    uint8_t	online;		/* seen as on line */
+    uint8_t	blocked;	/* blocked on event */
+    uint8_t	running;	/* scheduled on CPU */
+    uint64_t    cpu_time ALIGN_64; /* nanosecond of CPU used */
+    uint32_t	cpu;		/* current mapping */
+};
+typedef struct xen_v2d5_vcpuinfo xen_v2d5_vcpuinfo;
+
+/*
+ * from V2 the pinning of a vcpu is read with a separate call
+ */
+#define XEN_V2_OP_GETVCPUMAP	25
+typedef struct xen_v2_setvcpumap xen_v2_getvcpumap;
+typedef struct xen_v2d5_setvcpumap xen_v2d5_getvcpumap;
+
+/*
+ * from V2 we get the scheduler information
+ */
+#define XEN_V2_OP_GETSCHEDULERID	4
+
+/*
+ * from V2 we get the available heap information
+ */
+#define XEN_V2_OP_GETAVAILHEAP  	9
+
+/*
+ * from V2 we get the scheduler parameter
+ */
+#define XEN_V2_OP_SCHEDULER		16
+/* Scheduler types. */
+#define XEN_SCHEDULER_SEDF       4
+#define XEN_SCHEDULER_CREDIT     5
+/* get/set scheduler parameters */
+#define XEN_DOMCTL_SCHEDOP_putinfo 0
+#define XEN_DOMCTL_SCHEDOP_getinfo 1
+
+struct xen_v2_setschedinfo {
+    uint32_t sched_id;
+    uint32_t cmd;
+    union {
+        struct xen_domctl_sched_sedf {
+            uint64_t period ALIGN_64;
+            uint64_t slice  ALIGN_64;
+            uint64_t latency ALIGN_64;
+            uint32_t extratime;
+            uint32_t weight;
+        } sedf;
+        struct xen_domctl_sched_credit {
+            uint16_t weight;
+            uint16_t cap;
+        } credit;
+    } u;
+};
+typedef struct xen_v2_setschedinfo xen_v2_setschedinfo;
+typedef struct xen_v2_setschedinfo xen_v2_getschedinfo;
+
+
+/*
+ * The hypercall operation structures also have changed on
+ * changeset 86d26e6ec89b
+ */
+/* the old structure */
+struct xen_op_v0 {
+    uint32_t cmd;
+    uint32_t interface_version;
+    union {
+        xen_v0_getdomaininfolistop getdomaininfolist;
+        xen_v0_domainop          domain;
+        xen_v0_setmaxmem         setmaxmem;
+        xen_v0_setmaxvcpu        setmaxvcpu;
+        xen_v0_setvcpumap        setvcpumap;
+        xen_v0_vcpuinfo          getvcpuinfo;
+        uint8_t padding[128];
+    } u;
+};
+typedef struct xen_op_v0 xen_op_v0;
+typedef struct xen_op_v0 xen_op_v1;
+
+/* the new structure for systems operations */
+struct xen_op_v2_sys {
+    uint32_t cmd;
+    uint32_t interface_version;
+    union {
+        xen_v2_getdomaininfolistop   getdomaininfolist;
+        xen_v2s3_getdomaininfolistop getdomaininfolists3;
+        xen_v2_getschedulerid        getschedulerid;
+        xen_v2s4_availheap           availheap;
+        xen_v2s5_availheap           availheap5;
+        uint8_t padding[128];
+    } u;
+};
+typedef struct xen_op_v2_sys xen_op_v2_sys;
+
+/* the new structure for domains operation */
+struct xen_op_v2_dom {
+    uint32_t cmd;
+    uint32_t interface_version;
+    domid_t  domain;
+    union {
+        xen_v2_setmaxmem         setmaxmem;
+        xen_v2d5_setmaxmem       setmaxmemd5;
+        xen_v2_setmaxvcpu        setmaxvcpu;
+        xen_v2_setvcpumap        setvcpumap;
+        xen_v2d5_setvcpumap      setvcpumapd5;
+        xen_v2_vcpuinfo          getvcpuinfo;
+        xen_v2d5_vcpuinfo        getvcpuinfod5;
+        xen_v2_getvcpumap        getvcpumap;
+        xen_v2d5_getvcpumap      getvcpumapd5;
+        xen_v2_setschedinfo      setschedinfo;
+        xen_v2_getschedinfo      getschedinfo;
+        uint8_t padding[128];
+    } u;
+};
+typedef struct xen_op_v2_dom xen_op_v2_dom;
+
+
+#ifdef __linux__
+# define XEN_HYPERVISOR_SOCKET	"/proc/xen/privcmd"
+# define HYPERVISOR_CAPABILITIES	"/sys/hypervisor/properties/capabilities"
+#elif defined(__sun)
+# define XEN_HYPERVISOR_SOCKET	"/dev/xen/privcmd"
+#else
+# error "unsupported platform"
+#endif
+
+#ifndef PROXY
+static unsigned long xenHypervisorGetMaxMemory(virDomainPtr domain);
+#endif
+
+#ifndef PROXY
+struct xenUnifiedDriver xenHypervisorDriver = {
+    xenHypervisorOpen, /* open */
+    xenHypervisorClose, /* close */
+    xenHypervisorGetVersion, /* version */
+    NULL, /* hostname */
+    NULL, /* nodeGetInfo */
+    xenHypervisorGetCapabilities, /* getCapabilities */
+    xenHypervisorListDomains, /* listDomains */
+    xenHypervisorNumOfDomains, /* numOfDomains */
+    NULL, /* domainCreateXML */
+    xenHypervisorPauseDomain, /* domainSuspend */
+    xenHypervisorResumeDomain, /* domainResume */
+    NULL, /* domainShutdown */
+    NULL, /* domainReboot */
+    xenHypervisorDestroyDomain, /* domainDestroy */
+    xenHypervisorDomainGetOSType, /* domainGetOSType */
+    xenHypervisorGetMaxMemory, /* domainGetMaxMemory */
+    xenHypervisorSetMaxMemory, /* domainSetMaxMemory */
+    NULL, /* domainSetMemory */
+    xenHypervisorGetDomainInfo, /* domainGetInfo */
+    NULL, /* domainSave */
+    NULL, /* domainRestore */
+    NULL, /* domainCoreDump */
+    xenHypervisorPinVcpu, /* domainPinVcpu */
+    xenHypervisorGetVcpus, /* domainGetVcpus */
+    NULL, /* listDefinedDomains */
+    NULL, /* numOfDefinedDomains */
+    NULL, /* domainCreate */
+    NULL, /* domainDefineXML */
+    NULL, /* domainUndefine */
+    NULL, /* domainAttachDeviceFlags */
+    NULL, /* domainDetachDeviceFlags */
+    NULL, /* domainUpdateDeviceFlags */
+    NULL, /* domainGetAutostart */
+    NULL, /* domainSetAutostart */
+    xenHypervisorGetSchedulerType, /* domainGetSchedulerType */
+    xenHypervisorGetSchedulerParameters, /* domainGetSchedulerParameters */
+    xenHypervisorSetSchedulerParameters, /* domainSetSchedulerParameters */
+};
+#endif /* !PROXY */
+
+#define virXenError(code, ...)                                             \
+        if (in_init == 0)                                                  \
+            virReportErrorHelper(NULL, VIR_FROM_XEN, code, __FILE__,       \
+                                 __FUNCTION__, __LINE__, __VA_ARGS__)
+
+#ifndef PROXY
+
+/**
+ * virXenErrorFunc:
+ * @error: the error number
+ * @func: the function failing
+ * @info: extra information string
+ * @value: extra information number
+ *
+ * Handle an error at the xend daemon interface
+ */
+static void
+virXenErrorFunc(virErrorNumber error, const char *func, const char *info,
+                int value)
+{
+    char fullinfo[1000];
+    const char *errmsg;
+
+    if ((error == VIR_ERR_OK) || (in_init != 0))
+        return;
+
+
+    errmsg =virErrorMsg(error, info);
+    if (func != NULL) {
+        snprintf(fullinfo, 999, "%s: %s", func, info);
+        fullinfo[999] = 0;
+        virRaiseError(NULL, NULL, NULL, VIR_FROM_XEN, error, VIR_ERR_ERROR,
+                        errmsg, fullinfo, NULL, value, 0, errmsg, fullinfo,
+                        value);
+    } else {
+        virRaiseError(NULL, NULL, NULL, VIR_FROM_XEN, error, VIR_ERR_ERROR,
+                        errmsg, info, NULL, value, 0, errmsg, info,
+                        value);
+    }
+}
+
+#endif /* PROXY */
+
+/**
+ * xenHypervisorDoV0Op:
+ * @handle: the handle to the Xen hypervisor
+ * @op: pointer to the hypervisor operation structure
+ *
+ * Do an hypervisor operation though the old interface,
+ * this leads to an hypervisor call through ioctl.
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+static int
+xenHypervisorDoV0Op(int handle, xen_op_v0 * op)
+{
+    int ret;
+    v0_hypercall_t hc;
+
+    memset(&hc, 0, sizeof(hc));
+    op->interface_version = hv_version << 8;
+    hc.op = __HYPERVISOR_dom0_op;
+    hc.arg[0] = (unsigned long) op;
+
+    if (lock_pages(op, sizeof(dom0_op_t)) < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " locking");
+        return (-1);
+    }
+
+    ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
+    if (ret < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " ioctl %d",
+                    xen_ioctl_hypercall_cmd);
+    }
+
+    if (unlock_pages(op, sizeof(dom0_op_t)) < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " releasing");
+        ret = -1;
+    }
+
+    if (ret < 0)
+        return (-1);
+
+    return (0);
+}
+/**
+ * xenHypervisorDoV1Op:
+ * @handle: the handle to the Xen hypervisor
+ * @op: pointer to the hypervisor operation structure
+ *
+ * Do an hypervisor v1 operation, this leads to an hypervisor call through
+ * ioctl.
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+static int
+xenHypervisorDoV1Op(int handle, xen_op_v1* op)
+{
+    int ret;
+    hypercall_t hc;
+
+    memset(&hc, 0, sizeof(hc));
+    op->interface_version = DOM0_INTERFACE_VERSION;
+    hc.op = __HYPERVISOR_dom0_op;
+    hc.arg[0] = (unsigned long) op;
+
+    if (lock_pages(op, sizeof(dom0_op_t)) < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " locking");
+        return (-1);
+    }
+
+    ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
+    if (ret < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " ioctl %d",
+                    xen_ioctl_hypercall_cmd);
+    }
+
+    if (unlock_pages(op, sizeof(dom0_op_t)) < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " releasing");
+        ret = -1;
+    }
+
+    if (ret < 0)
+        return (-1);
+
+    return (0);
+}
+
+/**
+ * xenHypervisorDoV2Sys:
+ * @handle: the handle to the Xen hypervisor
+ * @op: pointer to the hypervisor operation structure
+ *
+ * Do an hypervisor v2 system operation, this leads to an hypervisor
+ * call through ioctl.
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+static int
+xenHypervisorDoV2Sys(int handle, xen_op_v2_sys* op)
+{
+    int ret;
+    hypercall_t hc;
+
+    memset(&hc, 0, sizeof(hc));
+    op->interface_version = sys_interface_version;
+    hc.op = __HYPERVISOR_sysctl;
+    hc.arg[0] = (unsigned long) op;
+
+    if (lock_pages(op, sizeof(dom0_op_t)) < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " locking");
+        return (-1);
+    }
+
+    ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
+    if (ret < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " sys ioctl %d",
+                                            xen_ioctl_hypercall_cmd);
+    }
+
+    if (unlock_pages(op, sizeof(dom0_op_t)) < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " releasing");
+        ret = -1;
+    }
+
+    if (ret < 0)
+        return (-1);
+
+    return (0);
+}
+
+/**
+ * xenHypervisorDoV2Dom:
+ * @handle: the handle to the Xen hypervisor
+ * @op: pointer to the hypervisor domain operation structure
+ *
+ * Do an hypervisor v2 domain operation, this leads to an hypervisor
+ * call through ioctl.
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+static int
+xenHypervisorDoV2Dom(int handle, xen_op_v2_dom* op)
+{
+    int ret;
+    hypercall_t hc;
+
+    memset(&hc, 0, sizeof(hc));
+    op->interface_version = dom_interface_version;
+    hc.op = __HYPERVISOR_domctl;
+    hc.arg[0] = (unsigned long) op;
+
+    if (lock_pages(op, sizeof(dom0_op_t)) < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " locking");
+        return (-1);
+    }
+
+    ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
+    if (ret < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " ioctl %d",
+                    xen_ioctl_hypercall_cmd);
+    }
+
+    if (unlock_pages(op, sizeof(dom0_op_t)) < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " releasing");
+        ret = -1;
+    }
+
+    if (ret < 0)
+        return (-1);
+
+    return (0);
+}
+
+/**
+ * virXen_getdomaininfolist:
+ * @handle: the hypervisor handle
+ * @first_domain: first domain in the range
+ * @maxids: maximum number of domains to list
+ * @dominfos: output structures
+ *
+ * Do a low level hypercall to list existing domains information
+ *
+ * Returns the number of domains or -1 in case of failure
+ */
+static int
+virXen_getdomaininfolist(int handle, int first_domain, int maxids,
+                         xen_getdomaininfolist *dominfos)
+{
+    int ret = -1;
+
+    if (lock_pages(XEN_GETDOMAININFOLIST_DATA(dominfos),
+              XEN_GETDOMAININFO_SIZE * maxids) < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " locking");
+        return (-1);
+    }
+    if (hypervisor_version > 1) {
+        xen_op_v2_sys op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V2_OP_GETDOMAININFOLIST;
+
+        if (sys_interface_version < 3) {
+            op.u.getdomaininfolist.first_domain = (domid_t) first_domain;
+            op.u.getdomaininfolist.max_domains = maxids;
+            op.u.getdomaininfolist.buffer = dominfos->v2;
+            op.u.getdomaininfolist.num_domains = maxids;
+        } else {
+            op.u.getdomaininfolists3.first_domain = (domid_t) first_domain;
+            op.u.getdomaininfolists3.max_domains = maxids;
+            op.u.getdomaininfolists3.buffer.v = dominfos->v2d5;
+            op.u.getdomaininfolists3.num_domains = maxids;
+        }
+        ret = xenHypervisorDoV2Sys(handle, &op);
+
+        if (ret == 0) {
+            if (sys_interface_version < 3)
+                ret = op.u.getdomaininfolist.num_domains;
+            else
+                ret = op.u.getdomaininfolists3.num_domains;
+        }
+    } else if (hypervisor_version == 1) {
+        xen_op_v1 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V1_OP_GETDOMAININFOLIST;
+        op.u.getdomaininfolist.first_domain = (domid_t) first_domain;
+        op.u.getdomaininfolist.max_domains = maxids;
+        op.u.getdomaininfolist.buffer = dominfos->v0;
+        op.u.getdomaininfolist.num_domains = maxids;
+        ret = xenHypervisorDoV1Op(handle, &op);
+        if (ret == 0)
+            ret = op.u.getdomaininfolist.num_domains;
+    } else if (hypervisor_version == 0) {
+        xen_op_v0 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V0_OP_GETDOMAININFOLIST;
+        op.u.getdomaininfolist.first_domain = (domid_t) first_domain;
+        op.u.getdomaininfolist.max_domains = maxids;
+        op.u.getdomaininfolist.buffer = dominfos->v0;
+        op.u.getdomaininfolist.num_domains = maxids;
+        ret = xenHypervisorDoV0Op(handle, &op);
+        if (ret == 0)
+            ret = op.u.getdomaininfolist.num_domains;
+    }
+    if (unlock_pages(XEN_GETDOMAININFOLIST_DATA(dominfos),
+                XEN_GETDOMAININFO_SIZE * maxids) < 0) {
+        virXenError(VIR_ERR_XEN_CALL, " release");
+        ret = -1;
+    }
+    return(ret);
+}
+
+static int
+virXen_getdomaininfo(int handle, int first_domain,
+                     xen_getdomaininfo *dominfo) {
+    xen_getdomaininfolist dominfos;
+
+    if (hypervisor_version < 2) {
+        dominfos.v0 = &(dominfo->v0);
+    } else {
+        dominfos.v2 = &(dominfo->v2);
+    }
+
+    return virXen_getdomaininfolist(handle, first_domain, 1, &dominfos);
+}
+
+
+#ifndef PROXY
+/**
+ * xenHypervisorGetSchedulerType:
+ * @domain: pointer to the Xen Hypervisor block
+ * @nparams:give a number of scheduler parameters.
+ *
+ * Do a low level hypercall to get scheduler type
+ *
+ * Returns scheduler name or NULL in case of failure
+ */
+char *
+xenHypervisorGetSchedulerType(virDomainPtr domain, int *nparams)
+{
+    char *schedulertype = NULL;
+    xenUnifiedPrivatePtr priv;
+
+    if (domain->conn == NULL) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        "domain or conn is NULL", 0);
+        return NULL;
+    }
+
+    priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
+    if (priv->handle < 0) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        "priv->handle invalid", 0);
+        return NULL;
+    }
+    if (domain->id < 0) {
+        virXenError(VIR_ERR_OPERATION_INVALID,
+                    "%s", _("domain is not running"));
+        return NULL;
+    }
+
+    /*
+     * Support only dom_interface_version >=5
+     * (Xen3.1.0 or later)
+     * TODO: check on Xen 3.0.3
+     */
+    if (dom_interface_version < 5) {
+        virXenErrorFunc(VIR_ERR_NO_XEN, __FUNCTION__,
+                        "unsupported in dom interface < 5", 0);
+        return NULL;
+    }
+
+    if (hypervisor_version > 1) {
+        xen_op_v2_sys op;
+        int ret;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V2_OP_GETSCHEDULERID;
+        ret = xenHypervisorDoV2Sys(priv->handle, &op);
+        if (ret < 0)
+            return(NULL);
+
+        switch (op.u.getschedulerid.sched_id){
+            case XEN_SCHEDULER_SEDF:
+                schedulertype = strdup("sedf");
+                if (schedulertype == NULL)
+                    virReportOOMError();
+                if (nparams)
+                    *nparams = 6;
+                break;
+            case XEN_SCHEDULER_CREDIT:
+                schedulertype = strdup("credit");
+                if (schedulertype == NULL)
+                    virReportOOMError();
+                if (nparams)
+                    *nparams = 2;
+                break;
+            default:
+                break;
+        }
+    }
+
+    return schedulertype;
+}
+
+static const char *str_weight = "weight";
+static const char *str_cap = "cap";
+
+/**
+ * xenHypervisorGetSchedulerParameters:
+ * @domain: pointer to the Xen Hypervisor block
+ * @params: pointer to scheduler parameters.
+ *     This memory area should be allocated before calling.
+ * @nparams:this parameter should be same as
+ *     a given number of scheduler parameters.
+ *     from xenHypervisorGetSchedulerType().
+ *
+ * Do a low level hypercall to get scheduler parameters
+ *
+ * Returns 0 or -1 in case of failure
+ */
+int
+xenHypervisorGetSchedulerParameters(virDomainPtr domain,
+                                    virSchedParameterPtr params, int *nparams)
+{
+    xenUnifiedPrivatePtr priv;
+
+    if (domain->conn == NULL) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        "domain or conn is NULL", 0);
+        return -1;
+    }
+
+    priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
+    if (priv->handle < 0) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        "priv->handle invalid", 0);
+        return -1;
+    }
+    if (domain->id < 0) {
+        virXenError(VIR_ERR_OPERATION_INVALID,
+                    "%s", _("domain is not running"));
+        return -1;
+    }
+
+    /*
+     * Support only dom_interface_version >=5
+     * (Xen3.1.0 or later)
+     * TODO: check on Xen 3.0.3
+     */
+    if (dom_interface_version < 5) {
+        virXenErrorFunc(VIR_ERR_NO_XEN, __FUNCTION__,
+                        "unsupported in dom interface < 5", 0);
+        return -1;
+    }
+
+    if (hypervisor_version > 1) {
+        xen_op_v2_sys op_sys;
+        xen_op_v2_dom op_dom;
+        int ret;
+
+        memset(&op_sys, 0, sizeof(op_sys));
+        op_sys.cmd = XEN_V2_OP_GETSCHEDULERID;
+        ret = xenHypervisorDoV2Sys(priv->handle, &op_sys);
+        if (ret < 0)
+            return -1;
+
+        switch (op_sys.u.getschedulerid.sched_id){
+            case XEN_SCHEDULER_SEDF:
+                /* TODO: Implement for Xen/SEDF */
+                TODO
+                return(-1);
+            case XEN_SCHEDULER_CREDIT:
+                if (*nparams < 2)
+                    return(-1);
+                memset(&op_dom, 0, sizeof(op_dom));
+                op_dom.cmd = XEN_V2_OP_SCHEDULER;
+                op_dom.domain = (domid_t) domain->id;
+                op_dom.u.getschedinfo.sched_id = XEN_SCHEDULER_CREDIT;
+                op_dom.u.getschedinfo.cmd = XEN_DOMCTL_SCHEDOP_getinfo;
+                ret = xenHypervisorDoV2Dom(priv->handle, &op_dom);
+                if (ret < 0)
+                    return(-1);
+
+                if (virStrcpyStatic(params[0].field, str_weight) == NULL) {
+                    virXenError(VIR_ERR_INTERNAL_ERROR,
+                                "Weight %s too big for destination", str_weight);
+                    return -1;
+                }
+                params[0].type = VIR_DOMAIN_SCHED_FIELD_UINT;
+                params[0].value.ui = op_dom.u.getschedinfo.u.credit.weight;
+
+                if (virStrcpyStatic(params[1].field, str_cap) == NULL) {
+                    virXenError(VIR_ERR_INTERNAL_ERROR,
+                                "Cap %s too big for destination", str_cap);
+                    return -1;
+                }
+                params[1].type = VIR_DOMAIN_SCHED_FIELD_UINT;
+                params[1].value.ui = op_dom.u.getschedinfo.u.credit.cap;
+
+                *nparams = 2;
+                break;
+            default:
+                virXenErrorFunc(VIR_ERR_INVALID_ARG, __FUNCTION__,
+                        "Unknown scheduler", op_sys.u.getschedulerid.sched_id);
+                return -1;
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * xenHypervisorSetSchedulerParameters:
+ * @domain: pointer to the Xen Hypervisor block
+ * @nparams:give a number of scheduler setting parameters .
+ *
+ * Do a low level hypercall to set scheduler parameters
+ *
+ * Returns 0 or -1 in case of failure
+ */
+int
+xenHypervisorSetSchedulerParameters(virDomainPtr domain,
+                                 virSchedParameterPtr params, int nparams)
+{
+    int i;
+    unsigned int val;
+    xenUnifiedPrivatePtr priv;
+    char buf[256];
+
+    if (domain->conn == NULL) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        "domain or conn is NULL", 0);
+        return -1;
+    }
+
+    if ((nparams == 0) || (params == NULL)) {
+        virXenErrorFunc(VIR_ERR_INVALID_ARG, __FUNCTION__,
+                        "Noparameters given", 0);
+        return(-1);
+    }
+
+    priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
+    if (priv->handle < 0) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        "priv->handle invalid", 0);
+        return -1;
+    }
+    if (domain->id < 0) {
+        virXenError(VIR_ERR_OPERATION_INVALID,
+                    "%s", _("domain is not running"));
+        return -1;
+    }
+
+    /*
+     * Support only dom_interface_version >=5
+     * (Xen3.1.0 or later)
+     * TODO: check on Xen 3.0.3
+     */
+    if (dom_interface_version < 5) {
+        virXenErrorFunc(VIR_ERR_NO_XEN, __FUNCTION__,
+                        "unsupported in dom interface < 5", 0);
+        return -1;
+    }
+
+    if (hypervisor_version > 1) {
+        xen_op_v2_sys op_sys;
+        xen_op_v2_dom op_dom;
+        int ret;
+
+        memset(&op_sys, 0, sizeof(op_sys));
+        op_sys.cmd = XEN_V2_OP_GETSCHEDULERID;
+        ret = xenHypervisorDoV2Sys(priv->handle, &op_sys);
+        if (ret == -1) return -1;
+
+        switch (op_sys.u.getschedulerid.sched_id){
+        case XEN_SCHEDULER_SEDF:
+            /* TODO: Implement for Xen/SEDF */
+            TODO
+            return(-1);
+        case XEN_SCHEDULER_CREDIT: {
+            memset(&op_dom, 0, sizeof(op_dom));
+            op_dom.cmd = XEN_V2_OP_SCHEDULER;
+            op_dom.domain = (domid_t) domain->id;
+            op_dom.u.getschedinfo.sched_id = XEN_SCHEDULER_CREDIT;
+            op_dom.u.getschedinfo.cmd = XEN_DOMCTL_SCHEDOP_putinfo;
+
+            /*
+             * credit scheduler parameters
+             * following values do not change the parameters
+             */
+            op_dom.u.getschedinfo.u.credit.weight = 0;
+            op_dom.u.getschedinfo.u.credit.cap    = (uint16_t)~0U;
+
+            for (i = 0; i < nparams; i++) {
+                memset(&buf, 0, sizeof(buf));
+                if (STREQ (params[i].field, str_weight) &&
+                    params[i].type == VIR_DOMAIN_SCHED_FIELD_UINT) {
+                    val = params[i].value.ui;
+                    if ((val < 1) || (val > USHRT_MAX)) {
+                        snprintf(buf, sizeof(buf), _("Credit scheduler weight parameter (%d) is out of range (1-65535)"), val);
+                        virXenErrorFunc(VIR_ERR_INVALID_ARG, __FUNCTION__, buf, val);
+                        return(-1);
+                    }
+                    op_dom.u.getschedinfo.u.credit.weight = val;
+                } else if (STREQ (params[i].field, str_cap) &&
+                    params[i].type == VIR_DOMAIN_SCHED_FIELD_UINT) {
+                    val = params[i].value.ui;
+                    if (val >= USHRT_MAX) {
+                        snprintf(buf, sizeof(buf), _("Credit scheduler cap parameter (%d) is out of range (0-65534)"), val);
+                        virXenErrorFunc(VIR_ERR_INVALID_ARG, __FUNCTION__, buf, val);
+                        return(-1);
+                    }
+                    op_dom.u.getschedinfo.u.credit.cap = val;
+                } else {
+                    virXenErrorFunc(VIR_ERR_INVALID_ARG, __FUNCTION__,
+                                    "Credit scheduler accepts 'cap' and 'weight' integer parameters",
+                                    0);
+                    return(-1);
+                }
+            }
+
+            ret = xenHypervisorDoV2Dom(priv->handle, &op_dom);
+            if (ret < 0)
+                return -1;
+            break;
+        }
+        default:
+            virXenErrorFunc(VIR_ERR_INVALID_ARG, __FUNCTION__,
+                        "Unknown scheduler", op_sys.u.getschedulerid.sched_id);
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+
+int
+xenHypervisorDomainBlockStats (virDomainPtr dom,
+                               const char *path,
+                               struct _virDomainBlockStats *stats)
+{
+# ifdef __linux__
+    xenUnifiedPrivatePtr priv;
+    int ret;
+
+    priv = (xenUnifiedPrivatePtr) dom->conn->privateData;
+    xenUnifiedLock(priv);
+    /* Need to lock because it hits the xenstore handle :-( */
+    ret = xenLinuxDomainBlockStats (priv, dom, path, stats);
+    xenUnifiedUnlock(priv);
+    return ret;
+# else
+    virXenErrorFunc(VIR_ERR_NO_SUPPORT, __FUNCTION__,
+                    "block statistics not supported on this platform",
+                    dom->id);
+    return -1;
+# endif
+}
+
+/* Paths have the form vif<domid>.<n> (this interface checks that
+ * <domid> is the real domain ID and returns an error if not).
+ *
+ * In future we may allow you to query bridge stats (virbrX or
+ * xenbrX), but that will probably be through a separate
+ * virNetwork interface, as yet not decided.
+ */
+int
+xenHypervisorDomainInterfaceStats (virDomainPtr dom,
+                                   const char *path,
+                                   struct _virDomainInterfaceStats *stats)
+{
+# ifdef __linux__
+    int rqdomid, device;
+
+    /* Verify that the vif requested is one belonging to the current
+     * domain.
+     */
+    if (sscanf (path, "vif%d.%d", &rqdomid, &device) != 2) {
+        virXenErrorFunc(VIR_ERR_INVALID_ARG, __FUNCTION__,
+                        "invalid path, should be vif<domid>.<n>.", 0);
+        return -1;
+    }
+    if (rqdomid != dom->id) {
+        virXenErrorFunc(VIR_ERR_INVALID_ARG, __FUNCTION__,
+                        "invalid path, vif<domid> should match this domain ID", 0);
+        return -1;
+    }
+
+    return linuxDomainInterfaceStats(path, stats);
+# else
+    virXenErrorFunc(VIR_ERR_NO_SUPPORT, __FUNCTION__,
+                    "/proc/net/dev: Interface not found", 0);
+    return -1;
+# endif
+}
+
+/**
+ * virXen_pausedomain:
+ * @handle: the hypervisor handle
+ * @id: the domain id
+ *
+ * Do a low level hypercall to pause the domain
+ *
+ * Returns 0 or -1 in case of failure
+ */
+static int
+virXen_pausedomain(int handle, int id)
+{
+    int ret = -1;
+
+    if (hypervisor_version > 1) {
+        xen_op_v2_dom op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V2_OP_PAUSEDOMAIN;
+        op.domain = (domid_t) id;
+        ret = xenHypervisorDoV2Dom(handle, &op);
+    } else if (hypervisor_version == 1) {
+        xen_op_v1 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V1_OP_PAUSEDOMAIN;
+        op.u.domain.domain = (domid_t) id;
+        ret = xenHypervisorDoV1Op(handle, &op);
+    } else if (hypervisor_version == 0) {
+        xen_op_v0 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V0_OP_PAUSEDOMAIN;
+        op.u.domain.domain = (domid_t) id;
+        ret = xenHypervisorDoV0Op(handle, &op);
+    }
+    return(ret);
+}
+
+/**
+ * virXen_unpausedomain:
+ * @handle: the hypervisor handle
+ * @id: the domain id
+ *
+ * Do a low level hypercall to unpause the domain
+ *
+ * Returns 0 or -1 in case of failure
+ */
+static int
+virXen_unpausedomain(int handle, int id)
+{
+    int ret = -1;
+
+    if (hypervisor_version > 1) {
+        xen_op_v2_dom op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V2_OP_UNPAUSEDOMAIN;
+        op.domain = (domid_t) id;
+        ret = xenHypervisorDoV2Dom(handle, &op);
+    } else if (hypervisor_version == 1) {
+        xen_op_v1 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V1_OP_UNPAUSEDOMAIN;
+        op.u.domain.domain = (domid_t) id;
+        ret = xenHypervisorDoV1Op(handle, &op);
+    } else if (hypervisor_version == 0) {
+        xen_op_v0 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V0_OP_UNPAUSEDOMAIN;
+        op.u.domain.domain = (domid_t) id;
+        ret = xenHypervisorDoV0Op(handle, &op);
+    }
+    return(ret);
+}
+
+/**
+ * virXen_destroydomain:
+ * @handle: the hypervisor handle
+ * @id: the domain id
+ *
+ * Do a low level hypercall to destroy the domain
+ *
+ * Returns 0 or -1 in case of failure
+ */
+static int
+virXen_destroydomain(int handle, int id)
+{
+    int ret = -1;
+
+    if (hypervisor_version > 1) {
+        xen_op_v2_dom op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V2_OP_DESTROYDOMAIN;
+        op.domain = (domid_t) id;
+        ret = xenHypervisorDoV2Dom(handle, &op);
+    } else if (hypervisor_version == 1) {
+        xen_op_v1 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V1_OP_DESTROYDOMAIN;
+        op.u.domain.domain = (domid_t) id;
+        ret = xenHypervisorDoV1Op(handle, &op);
+    } else if (hypervisor_version == 0) {
+        xen_op_v0 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V0_OP_DESTROYDOMAIN;
+        op.u.domain.domain = (domid_t) id;
+        ret = xenHypervisorDoV0Op(handle, &op);
+    }
+    return(ret);
+}
+
+/**
+ * virXen_setmaxmem:
+ * @handle: the hypervisor handle
+ * @id: the domain id
+ * @memory: the amount of memory in kilobytes
+ *
+ * Do a low level hypercall to change the max memory amount
+ *
+ * Returns 0 or -1 in case of failure
+ */
+static int
+virXen_setmaxmem(int handle, int id, unsigned long memory)
+{
+    int ret = -1;
+
+    if (hypervisor_version > 1) {
+        xen_op_v2_dom op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V2_OP_SETMAXMEM;
+        op.domain = (domid_t) id;
+        if (dom_interface_version < 5)
+            op.u.setmaxmem.maxmem = memory;
+        else
+            op.u.setmaxmemd5.maxmem = memory;
+        ret = xenHypervisorDoV2Dom(handle, &op);
+    } else if (hypervisor_version == 1) {
+        xen_op_v1 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V1_OP_SETMAXMEM;
+        op.u.setmaxmem.domain = (domid_t) id;
+        op.u.setmaxmem.maxmem = memory;
+        ret = xenHypervisorDoV1Op(handle, &op);
+    } else if (hypervisor_version == 0) {
+        xen_op_v0 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V0_OP_SETMAXMEM;
+        op.u.setmaxmem.domain = (domid_t) id;
+        op.u.setmaxmem.maxmem = memory;
+        ret = xenHypervisorDoV0Op(handle, &op);
+    }
+    return(ret);
+}
+
+/**
+ * virXen_setmaxvcpus:
+ * @handle: the hypervisor handle
+ * @id: the domain id
+ * @vcpus: the numbers of vcpus
+ *
+ * Do a low level hypercall to change the max vcpus amount
+ *
+ * Returns 0 or -1 in case of failure
+ */
+static int
+virXen_setmaxvcpus(int handle, int id, unsigned int vcpus)
+{
+    int ret = -1;
+
+    if (hypervisor_version > 1) {
+        xen_op_v2_dom op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V2_OP_SETMAXVCPU;
+        op.domain = (domid_t) id;
+        op.u.setmaxvcpu.maxvcpu = vcpus;
+        ret = xenHypervisorDoV2Dom(handle, &op);
+    } else if (hypervisor_version == 1) {
+        xen_op_v1 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V1_OP_SETMAXVCPU;
+        op.u.setmaxvcpu.domain = (domid_t) id;
+        op.u.setmaxvcpu.maxvcpu = vcpus;
+        ret = xenHypervisorDoV1Op(handle, &op);
+    } else if (hypervisor_version == 0) {
+        xen_op_v0 op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V0_OP_SETMAXVCPU;
+        op.u.setmaxvcpu.domain = (domid_t) id;
+        op.u.setmaxvcpu.maxvcpu = vcpus;
+        ret = xenHypervisorDoV0Op(handle, &op);
+    }
+    return(ret);
+}
+
+/**
+ * virXen_setvcpumap:
+ * @handle: the hypervisor handle
+ * @id: the domain id
+ * @vcpu: the vcpu to map
+ * @cpumap: the bitmap for this vcpu
+ * @maplen: the size of the bitmap in bytes
+ *
+ * Do a low level hypercall to change the pinning for vcpu
+ *
+ * Returns 0 or -1 in case of failure
+ */
+static int
+virXen_setvcpumap(int handle, int id, unsigned int vcpu,
+                  unsigned char * cpumap, int maplen)
+{
+    int ret = -1;
+    unsigned char *new = NULL;
+    unsigned char *bitmap = NULL;
+    uint32_t nr_cpus;
+
+    if (hypervisor_version > 1) {
+        xen_op_v2_dom op;
+
+        if (lock_pages(cpumap, maplen) < 0) {
+            virXenError(VIR_ERR_XEN_CALL, " locking");
+            return (-1);
+        }
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V2_OP_SETVCPUMAP;
+        op.domain = (domid_t) id;
+
+        /* The allocated memory to cpumap must be 'sizeof(uint64_t)' byte *
+         * for Xen, and also nr_cpus must be 'sizeof(uint64_t) * 8'       */
+        if (maplen < 8) {
+            if (VIR_ALLOC_N(new, sizeof(uint64_t)) < 0) {
+                virReportOOMError();
+                return (-1);
+            }
+            memcpy(new, cpumap, maplen);
+            bitmap = new;
+            nr_cpus = sizeof(uint64_t) * 8;
+        } else {
+            bitmap = cpumap;
+            nr_cpus = maplen * 8;
+        }
+
+        if (dom_interface_version < 5) {
+            op.u.setvcpumap.vcpu = vcpu;
+            op.u.setvcpumap.cpumap.bitmap = bitmap;
+            op.u.setvcpumap.cpumap.nr_cpus = nr_cpus;
+        } else {
+            op.u.setvcpumapd5.vcpu = vcpu;
+            op.u.setvcpumapd5.cpumap.bitmap.v = bitmap;
+            op.u.setvcpumapd5.cpumap.nr_cpus = nr_cpus;
+        }
+        ret = xenHypervisorDoV2Dom(handle, &op);
+        VIR_FREE(new);
+
+        if (unlock_pages(cpumap, maplen) < 0) {
+            virXenError(VIR_ERR_XEN_CALL, " release");
+            ret = -1;
+        }
+    } else {
+        cpumap_t xen_cpumap; /* limited to 64 CPUs in old hypervisors */
+        uint64_t *pm = &xen_cpumap;
+        int j;
+
+        if ((maplen > (int)sizeof(cpumap_t)) || (sizeof(cpumap_t) & 7))
+            return (-1);
+
+        memset(pm, 0, sizeof(cpumap_t));
+        for (j = 0; j < maplen; j++)
+            *(pm + (j / 8)) |= cpumap[j] << (8 * (j & 7));
+
+        if (hypervisor_version == 1) {
+            xen_op_v1 op;
+
+            memset(&op, 0, sizeof(op));
+            op.cmd = XEN_V1_OP_SETVCPUMAP;
+            op.u.setvcpumap.domain = (domid_t) id;
+            op.u.setvcpumap.vcpu = vcpu;
+            op.u.setvcpumap.cpumap = xen_cpumap;
+            ret = xenHypervisorDoV1Op(handle, &op);
+        } else if (hypervisor_version == 0) {
+            xen_op_v0 op;
+
+            memset(&op, 0, sizeof(op));
+            op.cmd = XEN_V0_OP_SETVCPUMAP;
+            op.u.setvcpumap.domain = (domid_t) id;
+            op.u.setvcpumap.vcpu = vcpu;
+            op.u.setvcpumap.cpumap = xen_cpumap;
+            ret = xenHypervisorDoV0Op(handle, &op);
+        }
+    }
+    return(ret);
+}
+#endif /* !PROXY*/
+
+/**
+ * virXen_getvcpusinfo:
+ * @handle: the hypervisor handle
+ * @id: the domain id
+ * @vcpu: the vcpu to map
+ * @cpumap: the bitmap for this vcpu
+ * @maplen: the size of the bitmap in bytes
+ *
+ * Do a low level hypercall to change the pinning for vcpu
+ *
+ * Returns 0 or -1 in case of failure
+ */
+static int
+virXen_getvcpusinfo(int handle, int id, unsigned int vcpu, virVcpuInfoPtr ipt,
+                    unsigned char *cpumap, int maplen)
+{
+    int ret = -1;
+
+    if (hypervisor_version > 1) {
+        xen_op_v2_dom op;
+
+        memset(&op, 0, sizeof(op));
+        op.cmd = XEN_V2_OP_GETVCPUINFO;
+        op.domain = (domid_t) id;
+        if (dom_interface_version < 5)
+            op.u.getvcpuinfo.vcpu = (uint16_t) vcpu;
+        else
+            op.u.getvcpuinfod5.vcpu = (uint16_t) vcpu;
+        ret = xenHypervisorDoV2Dom(handle, &op);
+
+        if (ret < 0)
+            return(-1);
+        ipt->number = vcpu;
+        if (dom_interface_version < 5) {
+            if (op.u.getvcpuinfo.online) {
+                if (op.u.getvcpuinfo.running)
+                    ipt->state = VIR_VCPU_RUNNING;
+                if (op.u.getvcpuinfo.blocked)
+                    ipt->state = VIR_VCPU_BLOCKED;
+            } else
+                ipt->state = VIR_VCPU_OFFLINE;
+
+            ipt->cpuTime = op.u.getvcpuinfo.cpu_time;
+            ipt->cpu = op.u.getvcpuinfo.online ? (int)op.u.getvcpuinfo.cpu : -1;
+        } else {
+            if (op.u.getvcpuinfod5.online) {
+                if (op.u.getvcpuinfod5.running)
+                    ipt->state = VIR_VCPU_RUNNING;
+                if (op.u.getvcpuinfod5.blocked)
+                    ipt->state = VIR_VCPU_BLOCKED;
+            } else
+                ipt->state = VIR_VCPU_OFFLINE;
+
+            ipt->cpuTime = op.u.getvcpuinfod5.cpu_time;
+            ipt->cpu = op.u.getvcpuinfod5.online ? (int)op.u.getvcpuinfod5.cpu : -1;
+        }
+        if ((cpumap != NULL) && (maplen > 0)) {
+            if (lock_pages(cpumap, maplen) < 0) {
+                virXenError(VIR_ERR_XEN_CALL, " locking");
+                return (-1);
+            }
+            memset(cpumap, 0, maplen);
+            memset(&op, 0, sizeof(op));
+            op.cmd = XEN_V2_OP_GETVCPUMAP;
+            op.domain = (domid_t) id;
+            if (dom_interface_version < 5) {
+                op.u.getvcpumap.vcpu = vcpu;
+                op.u.getvcpumap.cpumap.bitmap = cpumap;
+                op.u.getvcpumap.cpumap.nr_cpus = maplen * 8;
+            } else {
+                op.u.getvcpumapd5.vcpu = vcpu;
+                op.u.getvcpumapd5.cpumap.bitmap.v = cpumap;
+                op.u.getvcpumapd5.cpumap.nr_cpus = maplen * 8;
+            }
+            ret = xenHypervisorDoV2Dom(handle, &op);
+            if (unlock_pages(cpumap, maplen) < 0) {
+                virXenError(VIR_ERR_XEN_CALL, " release");
+                ret = -1;
+            }
+        }
+    } else {
+        int mapl = maplen;
+        int cpu;
+
+        if (maplen > (int)sizeof(cpumap_t))
+            mapl = (int)sizeof(cpumap_t);
+
+        if (hypervisor_version == 1) {
+            xen_op_v1 op;
+
+            memset(&op, 0, sizeof(op));
+            op.cmd = XEN_V1_OP_GETVCPUINFO;
+            op.u.getvcpuinfo.domain = (domid_t) id;
+            op.u.getvcpuinfo.vcpu = vcpu;
+            ret = xenHypervisorDoV1Op(handle, &op);
+            if (ret < 0)
+                return(-1);
+            ipt->number = vcpu;
+            if (op.u.getvcpuinfo.online) {
+                if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
+                if (op.u.getvcpuinfo.blocked) ipt->state = VIR_VCPU_BLOCKED;
+            }
+            else ipt->state = VIR_VCPU_OFFLINE;
+            ipt->cpuTime = op.u.getvcpuinfo.cpu_time;
+            ipt->cpu = op.u.getvcpuinfo.online ? (int)op.u.getvcpuinfo.cpu : -1;
+            if ((cpumap != NULL) && (maplen > 0)) {
+                for (cpu = 0; cpu < (mapl * 8); cpu++) {
+                    if (op.u.getvcpuinfo.cpumap & ((uint64_t)1<<cpu))
+                        VIR_USE_CPU(cpumap, cpu);
+                }
+            }
+        } else if (hypervisor_version == 0) {
+            xen_op_v1 op;
+
+            memset(&op, 0, sizeof(op));
+            op.cmd = XEN_V0_OP_GETVCPUINFO;
+            op.u.getvcpuinfo.domain = (domid_t) id;
+            op.u.getvcpuinfo.vcpu = vcpu;
+            ret = xenHypervisorDoV0Op(handle, &op);
+            if (ret < 0)
+                return(-1);
+            ipt->number = vcpu;
+            if (op.u.getvcpuinfo.online) {
+                if (op.u.getvcpuinfo.running) ipt->state = VIR_VCPU_RUNNING;
+                if (op.u.getvcpuinfo.blocked) ipt->state = VIR_VCPU_BLOCKED;
+            }
+            else ipt->state = VIR_VCPU_OFFLINE;
+            ipt->cpuTime = op.u.getvcpuinfo.cpu_time;
+            ipt->cpu = op.u.getvcpuinfo.online ? (int)op.u.getvcpuinfo.cpu : -1;
+            if ((cpumap != NULL) && (maplen > 0)) {
+                for (cpu = 0; cpu < (mapl * 8); cpu++) {
+                    if (op.u.getvcpuinfo.cpumap & ((uint64_t)1<<cpu))
+                        VIR_USE_CPU(cpumap, cpu);
+                }
+            }
+        }
+    }
+    return(ret);
+}
+
+/**
+ * xenHypervisorInit:
+ *
+ * Initialize the hypervisor layer. Try to detect the kind of interface
+ * used i.e. pre or post changeset 10277
+ */
+int
+xenHypervisorInit(void)
+{
+    int fd, ret, cmd, errcode;
+    hypercall_t hc;
+    v0_hypercall_t v0_hc;
+    xen_getdomaininfo info;
+    virVcpuInfoPtr ipt = NULL;
+
+    if (initialized) {
+        if (hypervisor_version == -1)
+            return (-1);
+        return(0);
+    }
+    initialized = 1;
+    in_init = 1;
+
+    /* Compile regular expressions used by xenHypervisorGetCapabilities.
+     * Note that errors here are really internal errors since these
+     * regexps should never fail to compile.
+     */
+    errcode = regcomp (&flags_hvm_rec, flags_hvm_re, REG_EXTENDED);
+    if (errcode != 0) {
+        char error[100];
+        regerror (errcode, &flags_hvm_rec, error, sizeof error);
+        regfree (&flags_hvm_rec);
+        virXenError(VIR_ERR_INTERNAL_ERROR, "%s", error);
+        in_init = 0;
+        return -1;
+    }
+    errcode = regcomp (&flags_pae_rec, flags_pae_re, REG_EXTENDED);
+    if (errcode != 0) {
+        char error[100];
+        regerror (errcode, &flags_pae_rec, error, sizeof error);
+        regfree (&flags_pae_rec);
+        regfree (&flags_hvm_rec);
+        virXenError(VIR_ERR_INTERNAL_ERROR, "%s", error);
+        in_init = 0;
+        return -1;
+    }
+    errcode = regcomp (&xen_cap_rec, xen_cap_re, REG_EXTENDED);
+    if (errcode != 0) {
+        char error[100];
+        regerror (errcode, &xen_cap_rec, error, sizeof error);
+        regfree (&xen_cap_rec);
+        regfree (&flags_pae_rec);
+        regfree (&flags_hvm_rec);
+        virXenError(VIR_ERR_INTERNAL_ERROR, "%s", error);
+        in_init = 0;
+        return -1;
+    }
+
+    /* Xen hypervisor version detection begins. */
+    ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
+    if (ret < 0) {
+        hypervisor_version = -1;
+        return(-1);
+    }
+    fd = ret;
+
+    /*
+     * The size of the hypervisor call block changed July 2006
+     * this detect if we are using the new or old hypercall_t structure
+     */
+    hc.op = __HYPERVISOR_xen_version;
+    hc.arg[0] = (unsigned long) XENVER_version;
+    hc.arg[1] = 0;
+
+    cmd = IOCTL_PRIVCMD_HYPERCALL;
+    ret = ioctl(fd, cmd, (unsigned long) &hc);
+
+    if ((ret != -1) && (ret != 0)) {
+        DEBUG("Using new hypervisor call: %X", ret);
+        hv_version = ret;
+        xen_ioctl_hypercall_cmd = cmd;
+        goto detect_v2;
+    }
+
+#ifndef __sun
+    /*
+     * check if the old hypercall are actually working
+     */
+    v0_hc.op = __HYPERVISOR_xen_version;
+    v0_hc.arg[0] = (unsigned long) XENVER_version;
+    v0_hc.arg[1] = 0;
+    cmd = _IOC(_IOC_NONE, 'P', 0, sizeof(v0_hypercall_t));
+    ret = ioctl(fd, cmd, (unsigned long) &v0_hc);
+    if ((ret != -1) && (ret != 0)) {
+        DEBUG("Using old hypervisor call: %X", ret);
+        hv_version = ret;
+        xen_ioctl_hypercall_cmd = cmd;
+        hypervisor_version = 0;
+        goto done;
+    }
+#endif
+
+    /*
+     * we failed to make any hypercall
+     */
+
+    hypervisor_version = -1;
+    virXenError(VIR_ERR_XEN_CALL, " ioctl %lu",
+                (unsigned long) IOCTL_PRIVCMD_HYPERCALL);
+    close(fd);
+    in_init = 0;
+    return(-1);
+
+ detect_v2:
+    /*
+     * The hypercalls were refactored into 3 different section in August 2006
+     * Try to detect if we are running a version post 3.0.2 with the new ones
+     * or the old ones
+     */
+    hypervisor_version = 2;
+
+    if (VIR_ALLOC(ipt) < 0) {
+        virReportOOMError();
+        return(-1);
+    }
+    /* Currently consider RHEL5.0 Fedora7, xen-3.1, and xen-unstable */
+    sys_interface_version = 2; /* XEN_SYSCTL_INTERFACE_VERSION */
+    if (virXen_getdomaininfo(fd, 0, &info) == 1) {
+        /* RHEL 5.0 */
+        dom_interface_version = 3; /* XEN_DOMCTL_INTERFACE_VERSION */
+        if (virXen_getvcpusinfo(fd, 0, 0, ipt, NULL, 0) == 0){
+            DEBUG0("Using hypervisor call v2, sys ver2 dom ver3");
+            goto done;
+        }
+        /* Fedora 7 */
+        dom_interface_version = 4; /* XEN_DOMCTL_INTERFACE_VERSION */
+        if (virXen_getvcpusinfo(fd, 0, 0, ipt, NULL, 0) == 0){
+            DEBUG0("Using hypervisor call v2, sys ver2 dom ver4");
+            goto done;
+        }
+    }
+
+    sys_interface_version = 3; /* XEN_SYSCTL_INTERFACE_VERSION */
+    if (virXen_getdomaininfo(fd, 0, &info) == 1) {
+        /* xen-3.1 */
+        dom_interface_version = 5; /* XEN_DOMCTL_INTERFACE_VERSION */
+        if (virXen_getvcpusinfo(fd, 0, 0, ipt, NULL, 0) == 0){
+            DEBUG0("Using hypervisor call v2, sys ver3 dom ver5");
+            goto done;
+        }
+    }
+
+    sys_interface_version = 4; /* XEN_SYSCTL_INTERFACE_VERSION */
+    if (virXen_getdomaininfo(fd, 0, &info) == 1) {
+        /* Fedora 8 */
+        dom_interface_version = 5; /* XEN_DOMCTL_INTERFACE_VERSION */
+        if (virXen_getvcpusinfo(fd, 0, 0, ipt, NULL, 0) == 0){
+            DEBUG0("Using hypervisor call v2, sys ver4 dom ver5");
+            goto done;
+        }
+    }
+
+    sys_interface_version = 6; /* XEN_SYSCTL_INTERFACE_VERSION */
+    if (virXen_getdomaininfo(fd, 0, &info) == 1) {
+        /* Xen 3.2, Fedora 9 */
+        dom_interface_version = 5; /* XEN_DOMCTL_INTERFACE_VERSION */
+        if (virXen_getvcpusinfo(fd, 0, 0, ipt, NULL, 0) == 0){
+            DEBUG0("Using hypervisor call v2, sys ver6 dom ver5");
+            goto done;
+        }
+    }
+
+    /* Xen 4.0 */
+    sys_interface_version = 7; /* XEN_SYSCTL_INTERFACE_VERSION */
+    if (virXen_getdomaininfo(fd, 0, &info) == 1) {
+        dom_interface_version = 6; /* XEN_DOMCTL_INTERFACE_VERSION */
+        DEBUG0("Using hypervisor call v2, sys ver7 dom ver6");
+        goto done;
+    }
+
+    hypervisor_version = 1;
+    sys_interface_version = -1;
+    if (virXen_getdomaininfo(fd, 0, &info) == 1) {
+        DEBUG0("Using hypervisor call v1");
+        goto done;
+    }
+
+    /*
+     * we failed to make the getdomaininfolist hypercall
+     */
+
+    DEBUG0("Failed to find any Xen hypervisor method");
+    hypervisor_version = -1;
+    virXenError(VIR_ERR_XEN_CALL, " ioctl %lu",
+                (unsigned long)IOCTL_PRIVCMD_HYPERCALL);
+    close(fd);
+    in_init = 0;
+    VIR_FREE(ipt);
+    return(-1);
+
+ done:
+    close(fd);
+    in_init = 0;
+    VIR_FREE(ipt);
+    return(0);
+}
+
+/**
+ * xenHypervisorOpen:
+ * @conn: pointer to the connection block
+ * @name: URL for the target, NULL for local
+ * @flags: combination of virDrvOpenFlag(s)
+ *
+ * Connects to the Xen hypervisor.
+ *
+ * Returns 0 or -1 in case of error.
+ */
+virDrvOpenStatus
+xenHypervisorOpen(virConnectPtr conn,
+                  virConnectAuthPtr auth ATTRIBUTE_UNUSED,
+                  int flags ATTRIBUTE_UNUSED)
+{
+    int ret;
+    xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData;
+
+    if (initialized == 0)
+        if (xenHypervisorInit() == -1)
+            return -1;
+
+    priv->handle = -1;
+
+    ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
+    if (ret < 0) {
+        virXenError(VIR_ERR_NO_XEN, "%s", XEN_HYPERVISOR_SOCKET);
+        return (-1);
+    }
+
+    priv->handle = ret;
+
+    return(0);
+}
+
+/**
+ * xenHypervisorClose:
+ * @conn: pointer to the connection block
+ *
+ * Close the connection to the Xen hypervisor.
+ *
+ * Returns 0 in case of success or -1 in case of error.
+ */
+int
+xenHypervisorClose(virConnectPtr conn)
+{
+    int ret;
+    xenUnifiedPrivatePtr priv;
+
+    if (conn == NULL)
+        return (-1);
+
+    priv = (xenUnifiedPrivatePtr) conn->privateData;
+
+    if (priv->handle < 0)
+        return -1;
+
+    ret = close(priv->handle);
+    if (ret < 0)
+        return (-1);
+
+    return (0);
+}
+
+
+/**
+ * xenHypervisorGetVersion:
+ * @conn: pointer to the connection block
+ * @hvVer: where to store the version
+ *
+ * Call the hypervisor to extracts his own internal API version
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+int
+xenHypervisorGetVersion(virConnectPtr conn, unsigned long *hvVer)
+{
+    xenUnifiedPrivatePtr priv;
+
+    if (conn == NULL)
+        return -1;
+    priv = (xenUnifiedPrivatePtr) conn->privateData;
+    if (priv->handle < 0 || hvVer == NULL)
+        return (-1);
+    *hvVer = (hv_version >> 16) * 1000000 + (hv_version & 0xFFFF) * 1000;
+    return(0);
+}
+
+struct guest_arch {
+    const char *model;
+    int bits;
+    int hvm;
+    int pae;
+    int nonpae;
+    int ia64_be;
+};
+
+
+static virCapsPtr
+xenHypervisorBuildCapabilities(virConnectPtr conn,
+                               const char *hostmachine,
+                               int host_pae,
+                               const char *hvm_type,
+                               struct guest_arch *guest_archs,
+                               int nr_guest_archs) {
+    virCapsPtr caps;
+    int i;
+    int hv_major = hv_version >> 16;
+    int hv_minor = hv_version & 0xFFFF;
+
+    if ((caps = virCapabilitiesNew(hostmachine, 1, 1)) == NULL)
+        goto no_memory;
+
+    virCapabilitiesSetMacPrefix(caps, (unsigned char[]){ 0x00, 0x16, 0x3e });
+
+    if (hvm_type && STRNEQ(hvm_type, "") &&
+        virCapabilitiesAddHostFeature(caps, hvm_type) < 0)
+        goto no_memory;
+    if (host_pae &&
+        virCapabilitiesAddHostFeature(caps, "pae") < 0)
+        goto no_memory;
+
+
+    if (virCapabilitiesAddHostMigrateTransport(caps,
+                                               "xenmigr") < 0)
+        goto no_memory;
+
+
+    if (sys_interface_version >= SYS_IFACE_MIN_VERS_NUMA) {
+        if (xenDaemonNodeGetTopology(conn, caps) != 0) {
+            virCapabilitiesFree(caps);
+            return NULL;
+        }
+    }
+
+    for (i = 0; i < nr_guest_archs; ++i) {
+        virCapsGuestPtr guest;
+        char const *const xen_machines[] = {guest_archs[i].hvm ? "xenfv" : "xenpv"};
+        virCapsGuestMachinePtr *machines;
+
+        if ((machines = virCapabilitiesAllocMachines(xen_machines, 1)) == NULL)
+            goto no_memory;
+
+        if ((guest = virCapabilitiesAddGuest(caps,
+                                             guest_archs[i].hvm ? "hvm" : "xen",
+                                             guest_archs[i].model,
+                                             guest_archs[i].bits,
+                                             (STREQ(hostmachine, "x86_64") ?
+                                              "/usr/lib64/xen/bin/qemu-dm" :
+                                              "/usr/lib/xen/bin/qemu-dm"),
+                                             (guest_archs[i].hvm ?
+                                              "/usr/lib/xen/boot/hvmloader" :
+                                              NULL),
+                                             1,
+                                             machines)) == NULL) {
+            virCapabilitiesFreeMachines(machines, 1);
+            goto no_memory;
+        }
+        machines = NULL;
+
+        if (virCapabilitiesAddGuestDomain(guest,
+                                          "xen",
+                                          NULL,
+                                          NULL,
+                                          0,
+                                          NULL) == NULL)
+            goto no_memory;
+
+        if (guest_archs[i].pae &&
+            virCapabilitiesAddGuestFeature(guest,
+                                           "pae",
+                                           1,
+                                           0) == NULL)
+            goto no_memory;
+
+        if (guest_archs[i].nonpae &&
+            virCapabilitiesAddGuestFeature(guest,
+                                           "nonpae",
+                                           1,
+                                           0) == NULL)
+            goto no_memory;
+
+        if (guest_archs[i].ia64_be &&
+            virCapabilitiesAddGuestFeature(guest,
+                                           "ia64_be",
+                                           1,
+                                           0) == NULL)
+            goto no_memory;
+
+        if (guest_archs[i].hvm) {
+            if (virCapabilitiesAddGuestFeature(guest,
+                                               "acpi",
+                                               1, 1) == NULL)
+                goto no_memory;
+
+            // In Xen 3.1.0, APIC is always on and can't be toggled
+            if (virCapabilitiesAddGuestFeature(guest,
+                                               "apic",
+                                               1,
+                                               (hv_major > 3 &&
+                                                hv_minor > 0 ?
+                                                0 : 1)) == NULL)
+                goto no_memory;
+        }
+    }
+
+    caps->defaultConsoleTargetType = VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_XEN;
+
+    return caps;
+
+ no_memory:
+    virCapabilitiesFree(caps);
+    return NULL;
+}
+
+#ifdef __sun
+
+static int
+get_cpu_flags(virConnectPtr conn, const char **hvm, int *pae, int *longmode)
+{
+    struct {
+        uint32_t r_eax, r_ebx, r_ecx, r_edx;
+    } regs;
+
+    char tmpbuf[20];
+    int ret = 0;
+    int fd;
+
+    /* returns -1, errno 22 if in 32-bit mode */
+    *longmode = (sysinfo(SI_ARCHITECTURE_64, tmpbuf, sizeof(tmpbuf)) != -1);
+
+    if ((fd = open("/dev/cpu/self/cpuid", O_RDONLY)) == -1 ||
+        pread(fd, &regs, sizeof(regs), 0) != sizeof(regs)) {
+        virReportSystemError(errno, "%s", _("could not read CPU flags"));
+        goto out;
+    }
+
+    *pae = 0;
+    *hvm = "";
+
+    if (STREQLEN((const char *)&regs.r_ebx, "AuthcAMDenti", 12)) {
+        if (pread(fd, &regs, sizeof (regs), 0x80000001) == sizeof (regs)) {
+            /* Read secure virtual machine bit (bit 2 of ECX feature ID) */
+            if ((regs.r_ecx >> 2) & 1) {
+                *hvm = "svm";
+            }
+            if ((regs.r_edx >> 6) & 1)
+                *pae = 1;
+        }
+    } else if (STREQLEN((const char *)&regs.r_ebx, "GenuntelineI", 12)) {
+        if (pread(fd, &regs, sizeof (regs), 0x00000001) == sizeof (regs)) {
+            /* Read VMXE feature bit (bit 5 of ECX feature ID) */
+            if ((regs.r_ecx >> 5) & 1)
+                *hvm = "vmx";
+            if ((regs.r_edx >> 6) & 1)
+                *pae = 1;
+        }
+    }
+
+    ret = 1;
+
+out:
+    if (fd != -1)
+        close(fd);
+    return ret;
+}
+
+static virCapsPtr
+xenHypervisorMakeCapabilitiesSunOS(virConnectPtr conn)
+{
+    struct guest_arch guest_arches[32];
+    int i = 0;
+    virCapsPtr caps = NULL;
+    struct utsname utsname;
+    int pae, longmode;
+    const char *hvm;
+
+    if (!get_cpu_flags(conn, &hvm, &pae, &longmode))
+        return NULL;
+
+    /* Really, this never fails - look at the man-page. */
+    uname (&utsname);
+
+    guest_arches[i].model = "i686";
+    guest_arches[i].bits = 32;
+    guest_arches[i].hvm = 0;
+    guest_arches[i].pae = pae;
+    guest_arches[i].nonpae = !pae;
+    guest_arches[i].ia64_be = 0;
+    i++;
+
+    if (longmode) {
+        guest_arches[i].model = "x86_64";
+        guest_arches[i].bits = 64;
+        guest_arches[i].hvm = 0;
+        guest_arches[i].pae = 0;
+        guest_arches[i].nonpae = 0;
+        guest_arches[i].ia64_be = 0;
+        i++;
+    }
+
+    if (hvm[0] != '\0') {
+        guest_arches[i].model = "i686";
+        guest_arches[i].bits = 32;
+        guest_arches[i].hvm = 1;
+        guest_arches[i].pae = pae;
+        guest_arches[i].nonpae = 1;
+        guest_arches[i].ia64_be = 0;
+        i++;
+
+        if (longmode) {
+            guest_arches[i].model = "x86_64";
+            guest_arches[i].bits = 64;
+            guest_arches[i].hvm = 1;
+            guest_arches[i].pae = 0;
+            guest_arches[i].nonpae = 0;
+            guest_arches[i].ia64_be = 0;
+            i++;
+        }
+    }
+
+    if ((caps = xenHypervisorBuildCapabilities(conn,
+                                               utsname.machine,
+                                               pae, hvm,
+                                               guest_arches, i)) == NULL)
+        virReportOOMError();
+
+    return caps;
+}
+
+#endif /* __sun */
+
+/**
+ * xenHypervisorMakeCapabilitiesInternal:
+ * @conn: pointer to the connection block
+ * @cpuinfo: file handle containing /proc/cpuinfo data, or NULL
+ * @capabilities: file handle containing /sys/hypervisor/properties/capabilities data, or NULL
+ *
+ * Return the capabilities of this hypervisor.
+ */
+virCapsPtr
+xenHypervisorMakeCapabilitiesInternal(virConnectPtr conn,
+                                      const char *hostmachine,
+                                      FILE *cpuinfo, FILE *capabilities)
+{
+    char line[1024], *str, *token;
+    regmatch_t subs[4];
+    char *saveptr = NULL;
+    int i;
+
+    char hvm_type[4] = ""; /* "vmx" or "svm" (or "" if not in CPU). */
+    int host_pae = 0;
+    struct guest_arch guest_archs[32];
+    int nr_guest_archs = 0;
+    virCapsPtr caps = NULL;
+
+    memset(guest_archs, 0, sizeof(guest_archs));
+
+    /* /proc/cpuinfo: flags: Intel calls HVM "vmx", AMD calls it "svm".
+     * It's not clear if this will work on IA64, let alone other
+     * architectures and non-Linux. (XXX)
+     */
+    if (cpuinfo) {
+        while (fgets (line, sizeof line, cpuinfo)) {
+            if (regexec (&flags_hvm_rec, line, sizeof(subs)/sizeof(regmatch_t), subs, 0) == 0
+                && subs[0].rm_so != -1) {
+                if (virStrncpy(hvm_type,
+                               &line[subs[1].rm_so],
+                               subs[1].rm_eo-subs[1].rm_so,
+                               sizeof(hvm_type)) == NULL)
+                    return NULL;
+            } else if (regexec (&flags_pae_rec, line, 0, NULL, 0) == 0)
+                host_pae = 1;
+        }
+    }
+
+    /* Most of the useful info is in /sys/hypervisor/properties/capabilities
+     * which is documented in the code in xen-unstable.hg/xen/arch/.../setup.c.
+     *
+     * It is a space-separated list of supported guest architectures.
+     *
+     * For x86:
+     *    TYP-VER-ARCH[p]
+     *    ^   ^   ^    ^
+     *    |   |   |    +-- PAE supported
+     *    |   |   +------- x86_32 or x86_64
+     *    |   +----------- the version of Xen, eg. "3.0"
+     *    +--------------- "xen" or "hvm" for para or full virt respectively
+     *
+     * For PPC this file appears to be always empty (?)
+     *
+     * For IA64:
+     *    TYP-VER-ARCH[be]
+     *    ^   ^   ^    ^
+     *    |   |   |    +-- Big-endian supported
+     *    |   |   +------- always "ia64"
+     *    |   +----------- the version of Xen, eg. "3.0"
+     *    +--------------- "xen" or "hvm" for para or full virt respectively
+     */
+
+    /* Expecting one line in this file - ignore any more. */
+    if ((capabilities) && (fgets (line, sizeof line, capabilities))) {
+        /* Split the line into tokens.  strtok_r is OK here because we "own"
+         * this buffer.  Parse out the features from each token.
+         */
+        for (str = line, nr_guest_archs = 0;
+             nr_guest_archs < sizeof guest_archs / sizeof guest_archs[0]
+                 && (token = strtok_r (str, " ", &saveptr)) != NULL;
+             str = NULL) {
+
+            if (regexec (&xen_cap_rec, token, sizeof subs / sizeof subs[0],
+                         subs, 0) == 0) {
+                int hvm = STRPREFIX(&token[subs[1].rm_so], "hvm");
+                const char *model;
+                int bits, pae = 0, nonpae = 0, ia64_be = 0;
+
+                if (STRPREFIX(&token[subs[2].rm_so], "x86_32")) {
+                    model = "i686";
+                    bits = 32;
+                    if (subs[3].rm_so != -1 &&
+                        STRPREFIX(&token[subs[3].rm_so], "p"))
+                        pae = 1;
+                    else
+                        nonpae = 1;
+                }
+                else if (STRPREFIX(&token[subs[2].rm_so], "x86_64")) {
+                    model = "x86_64";
+                    bits = 64;
+                }
+                else if (STRPREFIX(&token[subs[2].rm_so], "ia64")) {
+                    model = "ia64";
+                    bits = 64;
+                    if (subs[3].rm_so != -1 &&
+                        STRPREFIX(&token[subs[3].rm_so], "be"))
+                        ia64_be = 1;
+                }
+                else if (STRPREFIX(&token[subs[2].rm_so], "powerpc64")) {
+                    model = "ppc64";
+                    bits = 64;
+                } else {
+                    /* XXX surely no other Xen archs exist  */
+                    continue;
+                }
+
+                /* Search for existing matching (model,hvm) tuple */
+                for (i = 0 ; i < nr_guest_archs ; i++) {
+                    if (STREQ(guest_archs[i].model, model) &&
+                        guest_archs[i].hvm == hvm) {
+                        break;
+                    }
+                }
+
+                /* Too many arch flavours - highly unlikely ! */
+                if (i >= ARRAY_CARDINALITY(guest_archs))
+                    continue;
+                /* Didn't find a match, so create a new one */
+                if (i == nr_guest_archs)
+                    nr_guest_archs++;
+
+                guest_archs[i].model = model;
+                guest_archs[i].bits = bits;
+                guest_archs[i].hvm = hvm;
+
+                /* Careful not to overwrite a previous positive
+                   setting with a negative one here - some archs
+                   can do both pae & non-pae, but Xen reports
+                   separately capabilities so we're merging archs */
+                if (pae)
+                    guest_archs[i].pae = pae;
+                if (nonpae)
+                    guest_archs[i].nonpae = nonpae;
+                if (ia64_be)
+                    guest_archs[i].ia64_be = ia64_be;
+            }
+        }
+    }
+
+    if ((caps = xenHypervisorBuildCapabilities(conn,
+                                               hostmachine,
+                                               host_pae,
+                                               hvm_type,
+                                               guest_archs,
+                                               nr_guest_archs)) == NULL)
+        goto no_memory;
+
+    return caps;
+
+ no_memory:
+    virReportOOMError();
+    virCapabilitiesFree(caps);
+    return NULL;
+}
+
+/**
+ * xenHypervisorMakeCapabilities:
+ *
+ * Return the capabilities of this hypervisor.
+ */
+virCapsPtr
+xenHypervisorMakeCapabilities(virConnectPtr conn)
+{
+#ifdef __sun
+    return xenHypervisorMakeCapabilitiesSunOS(conn);
+#else
+    virCapsPtr caps;
+    FILE *cpuinfo, *capabilities;
+    struct utsname utsname;
+
+    /* Really, this never fails - look at the man-page. */
+    uname (&utsname);
+
+    cpuinfo = fopen ("/proc/cpuinfo", "r");
+    if (cpuinfo == NULL) {
+        if (errno != ENOENT) {
+            virReportSystemError(errno,
+                                 _("cannot read file %s"),
+                                 "/proc/cpuinfo");
+            return NULL;
+        }
+    }
+
+    capabilities = fopen ("/sys/hypervisor/properties/capabilities", "r");
+    if (capabilities == NULL) {
+        if (errno != ENOENT) {
+            fclose(cpuinfo);
+            virReportSystemError(errno,
+                                 _("cannot read file %s"),
+                                 "/sys/hypervisor/properties/capabilities");
+            return NULL;
+        }
+    }
+
+    caps = xenHypervisorMakeCapabilitiesInternal(conn,
+                                                 utsname.machine,
+                                                 cpuinfo,
+                                                 capabilities);
+
+    if (cpuinfo)
+        fclose(cpuinfo);
+    if (capabilities)
+        fclose(capabilities);
+
+    return caps;
+#endif /* __sun */
+}
+
+
+
+/**
+ * xenHypervisorGetCapabilities:
+ * @conn: pointer to the connection block
+ *
+ * Return the capabilities of this hypervisor.
+ */
+char *
+xenHypervisorGetCapabilities (virConnectPtr conn)
+{
+    xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData;
+    char *xml;
+
+    if (!(xml = virCapabilitiesFormatXML(priv->caps))) {
+        virReportOOMError();
+        return NULL;
+    }
+
+    return xml;
+}
+
+
+/**
+ * xenHypervisorNumOfDomains:
+ * @conn: pointer to the connection block
+ *
+ * Provides the number of active domains.
+ *
+ * Returns the number of domain found or -1 in case of error
+ */
+int
+xenHypervisorNumOfDomains(virConnectPtr conn)
+{
+    xen_getdomaininfolist dominfos;
+    int ret, nbids;
+    static int last_maxids = 2;
+    int maxids = last_maxids;
+    xenUnifiedPrivatePtr priv;
+
+    if (conn == NULL)
+        return -1;
+    priv = (xenUnifiedPrivatePtr) conn->privateData;
+    if (priv->handle < 0)
+        return (-1);
+
+ retry:
+    if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
+        virReportOOMError();
+        return(-1);
+    }
+
+    XEN_GETDOMAININFOLIST_CLEAR(dominfos, maxids);
+
+    ret = virXen_getdomaininfolist(priv->handle, 0, maxids, &dominfos);
+
+    XEN_GETDOMAININFOLIST_FREE(dominfos);
+
+    if (ret < 0)
+        return (-1);
+
+    nbids = ret;
+    /* Can't possibly have more than 65,000 concurrent guests
+     * so limit how many times we try, to avoid increasing
+     * without bound & thus allocating all of system memory !
+     * XXX I'll regret this comment in a few years time ;-)
+     */
+    if (nbids == maxids) {
+        if (maxids < 65000) {
+            last_maxids *= 2;
+            maxids *= 2;
+            goto retry;
+        }
+        nbids = -1;
+    }
+    if ((nbids < 0) || (nbids > maxids))
+        return(-1);
+    return(nbids);
+}
+
+/**
+ * xenHypervisorListDomains:
+ * @conn: pointer to the connection block
+ * @ids: array to collect the list of IDs of active domains
+ * @maxids: size of @ids
+ *
+ * Collect the list of active domains, and store their ID in @maxids
+ *
+ * Returns the number of domain found or -1 in case of error
+ */
+int
+xenHypervisorListDomains(virConnectPtr conn, int *ids, int maxids)
+{
+    xen_getdomaininfolist dominfos;
+    int ret, nbids, i;
+    xenUnifiedPrivatePtr priv;
+
+    if (conn == NULL)
+        return -1;
+
+    priv = (xenUnifiedPrivatePtr) conn->privateData;
+    if (priv->handle < 0 ||
+        (ids == NULL) || (maxids < 0))
+        return (-1);
+
+    if (maxids == 0)
+        return(0);
+
+    if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
+        virReportOOMError();
+        return(-1);
+    }
+
+    XEN_GETDOMAININFOLIST_CLEAR(dominfos, maxids);
+    memset(ids, 0, maxids * sizeof(int));
+
+    ret = virXen_getdomaininfolist(priv->handle, 0, maxids, &dominfos);
+
+    if (ret < 0) {
+        XEN_GETDOMAININFOLIST_FREE(dominfos);
+        return (-1);
+    }
+
+    nbids = ret;
+    if ((nbids < 0) || (nbids > maxids)) {
+        XEN_GETDOMAININFOLIST_FREE(dominfos);
+        return(-1);
+    }
+
+    for (i = 0;i < nbids;i++) {
+        ids[i] = XEN_GETDOMAININFOLIST_DOMAIN(dominfos, i);
+    }
+
+    XEN_GETDOMAININFOLIST_FREE(dominfos);
+    return (nbids);
+}
+
+
+#ifndef PROXY
+char *
+xenHypervisorDomainGetOSType (virDomainPtr dom)
+{
+    xenUnifiedPrivatePtr priv;
+    xen_getdomaininfo dominfo;
+    char *ostype = NULL;
+
+    priv = (xenUnifiedPrivatePtr) dom->conn->privateData;
+    if (priv->handle < 0) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        _("domain shut off or invalid"), 0);
+        return (NULL);
+    }
+
+    /* HV's earlier than 3.1.0 don't include the HVM flags in guests status*/
+    if (hypervisor_version < 2 ||
+        dom_interface_version < 4) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        _("unsupported in dom interface < 4"), 0);
+        return (NULL);
+    }
+
+    XEN_GETDOMAININFO_CLEAR(dominfo);
+
+    if (virXen_getdomaininfo(priv->handle, dom->id, &dominfo) < 0) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        _("cannot get domain details"), 0);
+        return (NULL);
+    }
+
+    if (XEN_GETDOMAININFO_DOMAIN(dominfo) != dom->id) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        _("cannot get domain details"), 0);
+        return (NULL);
+    }
+
+    if (XEN_GETDOMAININFO_FLAGS(dominfo) & DOMFLAGS_HVM)
+        ostype = strdup("hvm");
+    else
+        ostype = strdup("linux");
+
+    if (ostype == NULL)
+        virReportOOMError();
+
+    return ostype;
+}
+
+int
+xenHypervisorHasDomain(virConnectPtr conn,
+                       int id)
+{
+    xenUnifiedPrivatePtr priv;
+    xen_getdomaininfo dominfo;
+
+    priv = (xenUnifiedPrivatePtr) conn->privateData;
+    if (priv->handle < 0)
+        return 0;
+
+    XEN_GETDOMAININFO_CLEAR(dominfo);
+
+    if (virXen_getdomaininfo(priv->handle, id, &dominfo) < 0)
+        return 0;
+
+    if (XEN_GETDOMAININFO_DOMAIN(dominfo) != id)
+        return 0;
+
+    return 1;
+}
+
+virDomainPtr
+xenHypervisorLookupDomainByID(virConnectPtr conn,
+                              int id)
+{
+    xenUnifiedPrivatePtr priv;
+    xen_getdomaininfo dominfo;
+    virDomainPtr ret;
+    char *name;
+
+    priv = (xenUnifiedPrivatePtr) conn->privateData;
+    if (priv->handle < 0)
+        return (NULL);
+
+    XEN_GETDOMAININFO_CLEAR(dominfo);
+
+    if (virXen_getdomaininfo(priv->handle, id, &dominfo) < 0)
+        return (NULL);
+
+    if (XEN_GETDOMAININFO_DOMAIN(dominfo) != id)
+        return (NULL);
+
+    xenUnifiedLock(priv);
+    name = xenStoreDomainGetName(conn, id);
+    xenUnifiedUnlock(priv);
+    if (!name)
+        return (NULL);
+
+    ret = virGetDomain(conn, name, XEN_GETDOMAININFO_UUID(dominfo));
+    if (ret)
+        ret->id = id;
+    VIR_FREE(name);
+    return ret;
+}
+
+
+virDomainPtr
+xenHypervisorLookupDomainByUUID(virConnectPtr conn,
+                                const unsigned char *uuid)
+{
+    xen_getdomaininfolist dominfos;
+    xenUnifiedPrivatePtr priv;
+    virDomainPtr ret;
+    char *name;
+    int maxids = 100, nids, i, id;
+
+    priv = (xenUnifiedPrivatePtr) conn->privateData;
+    if (priv->handle < 0)
+        return (NULL);
+
+ retry:
+    if (!(XEN_GETDOMAININFOLIST_ALLOC(dominfos, maxids))) {
+        virReportOOMError();
+        return(NULL);
+    }
+
+    XEN_GETDOMAININFOLIST_CLEAR(dominfos, maxids);
+
+    nids = virXen_getdomaininfolist(priv->handle, 0, maxids, &dominfos);
+
+    if (nids < 0) {
+        XEN_GETDOMAININFOLIST_FREE(dominfos);
+        return (NULL);
+    }
+
+    /* Can't possibly have more than 65,000 concurrent guests
+     * so limit how many times we try, to avoid increasing
+     * without bound & thus allocating all of system memory !
+     * XXX I'll regret this comment in a few years time ;-)
+     */
+    if (nids == maxids) {
+        XEN_GETDOMAININFOLIST_FREE(dominfos);
+        if (maxids < 65000) {
+            maxids *= 2;
+            goto retry;
+        }
+        return (NULL);
+    }
+
+    id = -1;
+    for (i = 0 ; i < nids ; i++) {
+        if (memcmp(XEN_GETDOMAININFOLIST_UUID(dominfos, i), uuid, VIR_UUID_BUFLEN) == 0) {
+            id = XEN_GETDOMAININFOLIST_DOMAIN(dominfos, i);
+            break;
+        }
+    }
+    XEN_GETDOMAININFOLIST_FREE(dominfos);
+
+    if (id == -1)
+        return (NULL);
+
+    xenUnifiedLock(priv);
+    name = xenStoreDomainGetName(conn, id);
+    xenUnifiedUnlock(priv);
+    if (!name)
+        return (NULL);
+
+    ret = virGetDomain(conn, name, uuid);
+    if (ret)
+        ret->id = id;
+    VIR_FREE(name);
+    return ret;
+}
+#endif
+
+/**
+ * xenHypervisorGetMaxVcpus:
+ *
+ * Returns the maximum of CPU defined by Xen.
+ */
+int
+xenHypervisorGetMaxVcpus(virConnectPtr conn,
+                         const char *type ATTRIBUTE_UNUSED)
+{
+    xenUnifiedPrivatePtr priv;
+
+    if (conn == NULL)
+        return -1;
+    priv = (xenUnifiedPrivatePtr) conn->privateData;
+    if (priv->handle < 0)
+        return (-1);
+
+    return MAX_VIRT_CPUS;
+}
+
+/**
+ * xenHypervisorGetDomMaxMemory:
+ * @conn: connection data
+ * @id: domain id
+ *
+ * Retrieve the maximum amount of physical memory allocated to a
+ * domain.
+ *
+ * Returns the memory size in kilobytes or 0 in case of error.
+ */
+unsigned long
+xenHypervisorGetDomMaxMemory(virConnectPtr conn, int id)
+{
+    xenUnifiedPrivatePtr priv;
+    xen_getdomaininfo dominfo;
+    int ret;
+
+    if (conn == NULL)
+        return 0;
+
+    priv = (xenUnifiedPrivatePtr) conn->privateData;
+    if (priv->handle < 0)
+        return 0;
+
+    if (kb_per_pages == 0) {
+        kb_per_pages = sysconf(_SC_PAGESIZE) / 1024;
+        if (kb_per_pages <= 0)
+            kb_per_pages = 4;
+    }
+
+    XEN_GETDOMAININFO_CLEAR(dominfo);
+
+    ret = virXen_getdomaininfo(priv->handle, id, &dominfo);
+
+    if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != id))
+        return (0);
+
+    return((unsigned long) XEN_GETDOMAININFO_MAX_PAGES(dominfo) * kb_per_pages);
+}
+
+#ifndef PROXY
+/**
+ * xenHypervisorGetMaxMemory:
+ * @domain: a domain object or NULL
+ *
+ * Retrieve the maximum amount of physical memory allocated to a
+ * domain. If domain is NULL, then this get the amount of memory reserved
+ * to Domain0 i.e. the domain where the application runs.
+ *
+ * Returns the memory size in kilobytes or 0 in case of error.
+ */
+static unsigned long ATTRIBUTE_NONNULL (1)
+xenHypervisorGetMaxMemory(virDomainPtr domain)
+{
+    xenUnifiedPrivatePtr priv;
+
+    if (domain->conn == NULL)
+        return 0;
+
+    priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
+    if (priv->handle < 0 || domain->id < 0)
+        return (0);
+
+    return(xenHypervisorGetDomMaxMemory(domain->conn, domain->id));
+}
+#endif
+
+/**
+ * xenHypervisorGetDomInfo:
+ * @conn: connection data
+ * @id: the domain ID
+ * @info: the place where information should be stored
+ *
+ * Do an hypervisor call to get the related set of domain information.
+ *
+ * Returns 0 in case of success, -1 in case of error.
+ */
+int
+xenHypervisorGetDomInfo(virConnectPtr conn, int id, virDomainInfoPtr info)
+{
+    xenUnifiedPrivatePtr priv;
+    xen_getdomaininfo dominfo;
+    int ret;
+    uint32_t domain_flags, domain_state, domain_shutdown_cause;
+
+    if (kb_per_pages == 0) {
+        kb_per_pages = sysconf(_SC_PAGESIZE) / 1024;
+        if (kb_per_pages <= 0)
+            kb_per_pages = 4;
+    }
+
+    if (conn == NULL)
+        return -1;
+
+    priv = (xenUnifiedPrivatePtr) conn->privateData;
+    if (priv->handle < 0 || info == NULL)
+        return (-1);
+
+    memset(info, 0, sizeof(virDomainInfo));
+    XEN_GETDOMAININFO_CLEAR(dominfo);
+
+    ret = virXen_getdomaininfo(priv->handle, id, &dominfo);
+
+    if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != id))
+        return (-1);
+
+    domain_flags = XEN_GETDOMAININFO_FLAGS(dominfo);
+    domain_flags &= ~DOMFLAGS_HVM; /* Mask out HVM flags */
+    domain_state = domain_flags & 0xFF; /* Mask out high bits */
+    switch (domain_state) {
+        case DOMFLAGS_DYING:
+            info->state = VIR_DOMAIN_SHUTDOWN;
+            break;
+        case DOMFLAGS_SHUTDOWN:
+            /* The domain is shutdown.  Determine the cause. */
+            domain_shutdown_cause = domain_flags >> DOMFLAGS_SHUTDOWNSHIFT;
+            switch (domain_shutdown_cause) {
+                case SHUTDOWN_crash:
+                    info->state = VIR_DOMAIN_CRASHED;
+                    break;
+                default:
+                    info->state = VIR_DOMAIN_SHUTOFF;
+            }
+            break;
+        case DOMFLAGS_PAUSED:
+            info->state = VIR_DOMAIN_PAUSED;
+            break;
+        case DOMFLAGS_BLOCKED:
+            info->state = VIR_DOMAIN_BLOCKED;
+            break;
+        case DOMFLAGS_RUNNING:
+            info->state = VIR_DOMAIN_RUNNING;
+            break;
+        default:
+            info->state = VIR_DOMAIN_NOSTATE;
+    }
+
+    /*
+     * the API brings back the cpu time in nanoseconds,
+     * convert to microseconds, same thing convert to
+     * kilobytes from page counts
+     */
+    info->cpuTime = XEN_GETDOMAININFO_CPUTIME(dominfo);
+    info->memory = XEN_GETDOMAININFO_TOT_PAGES(dominfo) * kb_per_pages;
+    info->maxMem = XEN_GETDOMAININFO_MAX_PAGES(dominfo);
+    if(info->maxMem != UINT_MAX)
+        info->maxMem *= kb_per_pages;
+    info->nrVirtCpu = XEN_GETDOMAININFO_CPUCOUNT(dominfo);
+    return (0);
+}
+
+/**
+ * xenHypervisorGetDomainInfo:
+ * @domain: pointer to the domain block
+ * @info: the place where information should be stored
+ *
+ * Do an hypervisor call to get the related set of domain information.
+ *
+ * Returns 0 in case of success, -1 in case of error.
+ */
+int
+xenHypervisorGetDomainInfo(virDomainPtr domain, virDomainInfoPtr info)
+{
+    xenUnifiedPrivatePtr priv;
+
+    if (domain->conn == NULL)
+        return -1;
+
+    priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
+    if (priv->handle < 0 || info == NULL ||
+        (domain->id < 0))
+        return (-1);
+
+    return(xenHypervisorGetDomInfo(domain->conn, domain->id, info));
+
+}
+
+#ifndef PROXY
+/**
+ * xenHypervisorNodeGetCellsFreeMemory:
+ * @conn: pointer to the hypervisor connection
+ * @freeMems: pointer to the array of unsigned long long
+ * @startCell: index of first cell to return freeMems info on.
+ * @maxCells: Maximum number of cells for which freeMems information can
+ *            be returned.
+ *
+ * This call returns the amount of free memory in one or more NUMA cells.
+ * The @freeMems array must be allocated by the caller and will be filled
+ * with the amount of free memory in kilobytes for each cell requested,
+ * starting with startCell (in freeMems[0]), up to either
+ * (startCell + maxCells), or the number of additional cells in the node,
+ * whichever is smaller.
+ *
+ * Returns the number of entries filled in freeMems, or -1 in case of error.
+ */
+int
+xenHypervisorNodeGetCellsFreeMemory(virConnectPtr conn, unsigned long long *freeMems,
+                                    int startCell, int maxCells)
+{
+    xen_op_v2_sys op_sys;
+    int i, j, ret;
+    xenUnifiedPrivatePtr priv;
+
+    if (conn == NULL) {
+        virXenErrorFunc(VIR_ERR_INVALID_ARG, __FUNCTION__,
+                        "invalid argument", 0);
+        return -1;
+    }
+
+    priv = conn->privateData;
+
+    if (priv->nbNodeCells < 0) {
+        virXenErrorFunc(VIR_ERR_XEN_CALL, __FUNCTION__,
+                        "cannot determine actual number of cells",0);
+        return(-1);
+    }
+
+    if ((maxCells < 1) || (startCell >= priv->nbNodeCells)) {
+        virXenErrorFunc(VIR_ERR_INVALID_ARG, __FUNCTION__,
+                        "invalid argument", 0);
+        return -1;
+    }
+
+    /*
+     * Support only sys_interface_version >=4
+     */
+    if (sys_interface_version < SYS_IFACE_MIN_VERS_NUMA) {
+        virXenErrorFunc(VIR_ERR_XEN_CALL, __FUNCTION__,
+                        "unsupported in sys interface < 4", 0);
+        return -1;
+    }
+
+    if (priv->handle < 0) {
+        virXenErrorFunc(VIR_ERR_INTERNAL_ERROR, __FUNCTION__,
+                        "priv->handle invalid", 0);
+        return -1;
+    }
+
+    memset(&op_sys, 0, sizeof(op_sys));
+    op_sys.cmd = XEN_V2_OP_GETAVAILHEAP;
+
+    for (i = startCell, j = 0;(i < priv->nbNodeCells) && (j < maxCells);i++,j++) {
+        if (sys_interface_version >= 5)
+            op_sys.u.availheap5.node = i;
+        else
+            op_sys.u.availheap.node = i;
+        ret = xenHypervisorDoV2Sys(priv->handle, &op_sys);
+        if (ret < 0) {
+            return(-1);
+        }
+        if (sys_interface_version >= 5)
+            freeMems[j] = op_sys.u.availheap5.avail_bytes;
+        else
+            freeMems[j] = op_sys.u.availheap.avail_bytes;
+    }
+    return (j);
+}
+
+
+/**
+ * xenHypervisorPauseDomain:
+ * @domain: pointer to the domain block
+ *
+ * Do an hypervisor call to pause the given domain
+ *
+ * Returns 0 in case of success, -1 in case of error.
+ */
+int
+xenHypervisorPauseDomain(virDomainPtr domain)
+{
+    int ret;
+    xenUnifiedPrivatePtr priv;
+
+    if (domain->conn == NULL)
+        return -1;
+
+    priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
+    if (priv->handle < 0 || domain->id < 0)
+        return (-1);
+
+    ret = virXen_pausedomain(priv->handle, domain->id);
+    if (ret < 0)
+        return (-1);
+    return (0);
+}
+
+/**
+ * xenHypervisorResumeDomain:
+ * @domain: pointer to the domain block
+ *
+ * Do an hypervisor call to resume the given domain
+ *
+ * Returns 0 in case of success, -1 in case of error.
+ */
+int
+xenHypervisorResumeDomain(virDomainPtr domain)
+{
+    int ret;
+    xenUnifiedPrivatePtr priv;
+
+    if (domain->conn == NULL)
+        return -1;
+
+    priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
+    if (priv->handle < 0 || domain->id < 0)
+        return (-1);
+
+    ret = virXen_unpausedomain(priv->handle, domain->id);
+    if (ret < 0)
+        return (-1);
+    return (0);
+}
+
+/**
+ * xenHypervisorDestroyDomain:
+ * @domain: pointer to the domain block
+ *
+ * Do an hypervisor call to destroy the given domain
+ *
+ * Returns 0 in case of success, -1 in case of error.
+ */
+int
+xenHypervisorDestroyDomain(virDomainPtr domain)
+{
+    int ret;
+    xenUnifiedPrivatePtr priv;
+
+    if (domain->conn == NULL)
+        return -1;
+
+    priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
+    if (priv->handle < 0 || domain->id < 0)
+        return (-1);
+
+    ret = virXen_destroydomain(priv->handle, domain->id);
+    if (ret < 0)
+        return (-1);
+    return (0);
+}
+
+/**
+ * xenHypervisorSetMaxMemory:
+ * @domain: pointer to the domain block
+ * @memory: the max memory size in kilobytes.
+ *
+ * Do an hypervisor call to change the maximum amount of memory used
+ *
+ * Returns 0 in case of success, -1 in case of error.
+ */
+int
+xenHypervisorSetMaxMemory(virDomainPtr domain, unsigned long memory)
+{
+    int ret;
+    xenUnifiedPrivatePtr priv;
+
+    if (domain->conn == NULL)
+        return -1;
+
+    priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
+    if (priv->handle < 0 || domain->id < 0)
+        return (-1);
+
+    ret = virXen_setmaxmem(priv->handle, domain->id, memory);
+    if (ret < 0)
+        return (-1);
+    return (0);
+}
+#endif /* PROXY */
+
+#ifndef PROXY
+/**
+ * xenHypervisorSetVcpus:
+ * @domain: pointer to domain object
+ * @nvcpus: the new number of virtual CPUs for this domain
+ *
+ * Dynamically change the number of virtual CPUs used by the domain.
+ *
+ * Returns 0 in case of success, -1 in case of failure.