WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-api

[Xen-API] [PATCH 6 of 7] ocaml: xc bindings: use libxenctrl and libxengu

To: xen-devel@xxxxxxxxxxxxxxxxxxx, xen-api@xxxxxxxxxxxxxxxxxxx
Subject: [Xen-API] [PATCH 6 of 7] ocaml: xc bindings: use libxenctrl and libxenguest
From: Ian Campbell <ian.campbell@xxxxxxxxxx>
Date: Thu, 18 Nov 2010 10:50:38 +0000
Cc: Ian Campbell <ian.campbell@xxxxxxxxxx>
Delivery-date: Thu, 18 Nov 2010 03:24:37 -0800
Envelope-to: www-data@xxxxxxxxxxxxxxxxxxx
In-reply-to: <patchbomb.1290077432@xxxxxxxxxxxxxxxxxxxxxx>
List-help: <mailto:xen-api-request@lists.xensource.com?subject=help>
List-id: Discussion of API issues surrounding Xen <xen-api.lists.xensource.com>
List-post: <mailto:xen-api@lists.xensource.com>
List-subscribe: <http://lists.xensource.com/mailman/listinfo/xen-api>, <mailto:xen-api-request@lists.xensource.com?subject=subscribe>
List-unsubscribe: <http://lists.xensource.com/mailman/listinfo/xen-api>, <mailto:xen-api-request@lists.xensource.com?subject=unsubscribe>
References: <patchbomb.1290077432@xxxxxxxxxxxxxxxxxxxxxx>
Sender: xen-api-bounces@xxxxxxxxxxxxxxxxxxx
User-agent: Mercurial-patchbomb/1.5.2
# HG changeset patch
# User root@xxxxxxxxxxxxxxxxxxxxx
# Date 1290077186 18000
# Node ID 4e6556dc40d36822bddf8ebb55294762e3279f33
# Parent  ac5b6ac9ec0d6fafed037d89a9802c542a77b5ce
ocaml: xc bindings: use libxenctrl and libxenguest

Now that tools/libxc is licensed under LGPL I don't think there is any need for
an LGPL reimplementation under tools/ocaml.

For the most part the conversion to the up-to-date libxc API (xc_lib.c
essentially implemented the same interface as an older libxc) was pretty
automatic. There are some functions which appear to no longer exist in libxc
which I therefore simply removed the bindings for and a small number of
interfaces which had changed.

Many of the functions bound by the stubs have no in-tree users (which I think
is fine for a language binding) so I have no way to confirm correctness other
than by eye. I was however able to confirm that oxenstored still worked and to
build a XCP toolstack which could successfully start a PV guest.

Uses the new XC_OPENFLAG_NON_REENTRANT option to avoid potential conflicts
between pthreads and the ocaml runtime.

Signed-off-by: Ian Campbell <ian.campbell@xxxxxxxxxx>
Cc: Vincent Hanquez <Vincent.Hanquez@xxxxxxxxxxxxx>

diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/Makefile.rules
--- a/tools/ocaml/Makefile.rules        Thu Nov 18 05:46:26 2010 -0500
+++ b/tools/ocaml/Makefile.rules        Thu Nov 18 05:46:26 2010 -0500
@@ -54,18 +54,18 @@ mk-caml-lib-bytecode = $(call quiet-comm
 
 mk-caml-stubs = $(call quiet-command, $(OCAMLMKLIB) -o `basename $1 .a` 
$2,MKLIB,$1)
 mk-caml-lib-stubs = \
-       $(call quiet-command, $(AR) rcs $1 $2 && $(OCAMLMKLIB) -o `basename $1 
.a | sed -e 's/^lib//'` $2,MKLIB,$1)
+       $(call quiet-command, $(AR) rcs $1 $2 && $(OCAMLMKLIB) -o `basename $1 
.a | sed -e 's/^lib//'` $3 $2,MKLIB,$1)
 
 # define a library target <name>.cmxa and <name>.cma
 define OCAML_LIBRARY_template
  $(1).cmxa: lib$(1)_stubs.a $(foreach obj,$($(1)_OBJS),$(obj).cmx)
-       $(call mk-caml-lib-native,$$@, -cclib -l$(1)_stubs, $(foreach 
obj,$($(1)_OBJS),$(obj).cmx))
+       $(call mk-caml-lib-native,$$@, -cclib -l$(1)_stubs $(foreach 
lib,$(LIBS_$(1)),-cclib $(lib)), $(foreach obj,$($(1)_OBJS),$(obj).cmx))
  $(1).cma: $(foreach obj,$($(1)_OBJS),$(obj).cmo)
        $(call mk-caml-lib-bytecode,$$@, -dllib dll$(1)_stubs.so -cclib 
-l$(1)_stubs, $$+)
  $(1)_stubs.a: $(foreach obj,$$($(1)_C_OBJS),$(obj).o)
        $(call mk-caml-stubs,$$@, $$+)
  lib$(1)_stubs.a: $(foreach obj,$($(1)_C_OBJS),$(obj).o)
-       $(call mk-caml-lib-stubs,$$@, $$+)
+       $(call mk-caml-lib-stubs,$$@, $$+, $(LIBS_$(1)))
 endef
 
 define OCAML_NOC_LIBRARY_template
diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/libs/xc/Makefile
--- a/tools/ocaml/libs/xc/Makefile      Thu Nov 18 05:46:26 2010 -0500
+++ b/tools/ocaml/libs/xc/Makefile      Thu Nov 18 05:46:26 2010 -0500
@@ -2,15 +2,17 @@ TOPLEVEL=../..
 XEN_ROOT=$(TOPLEVEL)/../..
 include $(TOPLEVEL)/common.make
 
-CFLAGS += -I../mmap -I./
-OCAMLINCLUDE += -I ../mmap -I ../uuid
+CFLAGS += -I../mmap -I./ -I$(XEN_ROOT)/tools/libxc
+OCAMLINCLUDE += -I ../mmap -I ../uuid -I $(XEN_ROOT)/tools/libxc
 
 OBJS = xc
 INTF = xc.cmi
 LIBS = xc.cma xc.cmxa
 
+LIBS_xc = -L$(XEN_ROOT)/tools/libxc -lxenctrl -lxenguest
+
 xc_OBJS = $(OBJS)
-xc_C_OBJS = xc_lib xc_stubs
+xc_C_OBJS = xc_stubs
 
 OCAML_LIBRARY = xc
 
diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/libs/xc/xc.h
--- a/tools/ocaml/libs/xc/xc.h  Thu Nov 18 05:46:26 2010 -0500
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,186 +0,0 @@
-/*
- * Copyright (C) 2006-2007 XenSource Ltd.
- * Copyright (C) 2008      Citrix Ltd.
- * Author Vincent Hanquez <vincent.hanquez@xxxxxxxxxxxxx>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- */
-
-#include <xen/xen.h>
-#include <xen/memory.h>
-#include <xen/sysctl.h>
-#include <xen/domctl.h>
-#include <xen/sched.h>
-#include <xen/sysctl.h>
-#include <xen/sys/privcmd.h>
-#include <xen/version.h>
-#include <xen/foreign/x86_32.h>
-#include <xen/foreign/x86_64.h>
-#include <xen/hvm/params.h>
-#include "xc_e820.h"
-
-typedef xen_domctl_getdomaininfo_t xc_domaininfo_t;
-typedef xen_domctl_getvcpuinfo_t xc_vcpuinfo_t;
-typedef xen_sysctl_physinfo_t xc_physinfo_t;
-
-struct xc_core_header {
-       unsigned int xch_magic;
-       unsigned int xch_nr_vcpus;
-       unsigned int xch_nr_pages;
-       unsigned int xch_ctxt_offset;
-       unsigned int xch_index_offset;
-       unsigned int xch_pages_offset;
-};
-
-typedef union {
-#if defined(__i386__) || defined(__x86_64__)
-       vcpu_guest_context_x86_64_t x64;
-       vcpu_guest_context_x86_32_t x32;
-#endif
-       vcpu_guest_context_t c;
-} vcpu_guest_context_any_t;
-
-char * xc_error_get(void);
-void xc_error_clear(void);
-
-int xc_using_injection(void);
-
-int xc_interface_open(void);
-int xc_interface_close(int handle);
-
-int xc_domain_create(int handle, unsigned int ssidref,
-                     xen_domain_handle_t dhandle,
-                     unsigned int flags, unsigned int *pdomid);
-int xc_domain_pause(int handle, unsigned int domid);
-int xc_domain_unpause(int handle, unsigned int domid);
-int xc_domain_resume_fast(int handle, unsigned int domid);
-int xc_domain_destroy(int handle, unsigned int domid);
-int xc_domain_shutdown(int handle, int domid, int reason);
-
-int xc_vcpu_setaffinity(int handle, unsigned int domid, int vcpu,
-                        uint64_t cpumap);
-int xc_vcpu_getaffinity(int handle, unsigned int domid, int vcpu,
-                        uint64_t *cpumap);
-
-int xc_domain_getinfolist(int handle, unsigned int first_domain,
-                          unsigned int max_domains, xc_domaininfo_t *info);
-int xc_domain_getinfo(int handle, unsigned int first_domain,
-                      xc_domaininfo_t *info);
-
-int xc_domain_setmaxmem(int handle, unsigned int domid, unsigned int 
max_memkb);
-int xc_domain_set_memmap_limit(int handle, unsigned int domid,
-                               unsigned long map_limitkb);
-
-int xc_domain_set_time_offset(int handle, unsigned int domid, int time_offset);
-
-int xc_domain_memory_increase_reservation(int handle, unsigned int domid,
-                                          unsigned long nr_extents,
-                                          unsigned int extent_order,
-                                          unsigned int address_bits,
-                                          xen_pfn_t *extent_start);
-int xc_domain_memory_decrease_reservation(int handle, unsigned int domid,
-                                          unsigned long nr_extents,
-                                          unsigned int extent_order,
-                                          unsigned int address_bits,
-                                          xen_pfn_t *extent_start);
-int xc_domain_memory_populate_physmap(int handle, unsigned int domid,
-                                      unsigned long nr_extents,
-                                      unsigned int extent_order,
-                                      unsigned int address_bits,
-                                      xen_pfn_t *extent_start);
-int xc_domain_setvmxassist(int handle, unsigned int domid, int use_vmxassist);
-int xc_domain_max_vcpus(int handle, unsigned int domid, unsigned int max);
-int xc_domain_sethandle(int handle, unsigned int domid,
-                        xen_domain_handle_t dhandle);
-int xc_vcpu_getinfo(int handle, unsigned int domid, unsigned int vcpu,
-                    xc_vcpuinfo_t *info);
-int xc_domain_ioport_permission(int handle, unsigned int domid,
-                                unsigned int first_port, unsigned int nr_ports,
-                                unsigned int allow_access);
-int xc_vcpu_setcontext(int handle, unsigned int domid,
-                       unsigned int vcpu, vcpu_guest_context_any_t *ctxt);
-int xc_vcpu_getcontext(int handle, unsigned int domid,
-                       unsigned int vcpu, vcpu_guest_context_any_t *ctxt);
-int xc_domain_irq_permission(int handle, unsigned int domid,
-                             unsigned char pirq, unsigned char allow_access);
-int xc_domain_iomem_permission(int handle, unsigned int domid,
-                               unsigned long first_mfn, unsigned long nr_mfns,
-                               unsigned char allow_access);
-long long xc_domain_get_cpu_usage(int handle, unsigned int domid,
-                                  unsigned int vcpu);
-void *xc_map_foreign_range(int handle, unsigned int domid,
-                           int size, int prot, unsigned long mfn);
-int xc_map_foreign_ranges(int handle, unsigned int domid,
-                          privcmd_mmap_entry_t *entries, int nr);
-int xc_readconsolering(int handle, char **pbuffer,
-                       unsigned int *pnr_chars, int clear);
-int xc_send_debug_keys(int handle, char *keys);
-int xc_physinfo(int handle, xc_physinfo_t *put_info);
-int xc_pcpu_info(
-       int handle, int max_cpus, xen_sysctl_cpuinfo_t *info, int *nr_cpus);
-int xc_sched_id(int handle, int *sched_id);
-int xc_version(int handle, int cmd, void *arg);
-int xc_evtchn_alloc_unbound(int handle, unsigned int domid,
-                            unsigned int remote_domid);
-int xc_evtchn_reset(int handle, unsigned int domid);
-
-int xc_sched_credit_domain_set(int handle, unsigned int domid,
-                               struct xen_domctl_sched_credit *sdom);
-int xc_sched_credit_domain_get(int handle, unsigned int domid,
-                               struct xen_domctl_sched_credit *sdom);
-int xc_shadow_allocation_get(int handle, unsigned int domid,
-                            uint32_t *mb);
-int xc_shadow_allocation_set(int handle, unsigned int domid,
-                            uint32_t mb);
-int xc_domain_get_pfn_list(int handle, unsigned int domid,
-                           uint64_t *pfn_array, unsigned long max_pfns);
-int xc_hvm_check_pvdriver(int handle, unsigned int domid);
-
-int xc_domain_assign_device(int handle, unsigned int domid,
-                            int domain, int bus, int slot, int func);
-int xc_domain_deassign_device(int handle, unsigned int domid,
-                              int domain, int bus, int slot, int func);
-int xc_domain_test_assign_device(int handle, unsigned int domid,
-                                 int domain, int bus, int slot, int func);
-int xc_domain_watchdog(int handle, int id, uint32_t timeout);
-int xc_domain_set_machine_address_size(int xc, uint32_t domid, unsigned int 
width);
-int xc_domain_get_machine_address_size(int xc, uint32_t domid);
-
-int xc_domain_cpuid_set(int xc, unsigned int domid, int hvm,
-                        uint32_t input, uint32_t oinput,
-                        char *config[4], char *config_out[4]);
-int xc_domain_cpuid_apply(int xc, unsigned int domid, int hvm);
-int xc_cpuid_check(uint32_t input, uint32_t optsubinput,
-                   char *config[4], char *config_out[4]);
-
-int xc_domain_send_s3resume(int handle, unsigned int domid);
-int xc_domain_set_vpt_align(int handle, unsigned int domid, int vpt_align);
-int xc_domain_set_hpet(int handle, unsigned int domid, int hpet);
-int xc_domain_set_timer_mode(int handle, unsigned int domid, int mode);
-int xc_domain_get_acpi_s_state(int handle, unsigned int domid);
-
-#if XEN_SYSCTL_INTERFACE_VERSION >= 6
-#define SAFEDIV(a, b)                                  (((b) > 0) ? (a) / (b) 
: (a))
-#define COMPAT_FIELD_physinfo_get_nr_cpus(p)           (p).nr_cpus
-#define COMPAT_FIELD_physinfo_get_sockets_per_node(p)  \
-       SAFEDIV((p).nr_cpus, ((p).threads_per_core * (p).cores_per_socket * 
(p).nr_nodes))
-#else
-#define COMPAT_FIELD_physinfo_get_nr_cpus(p)           \
-       ((p).threads_per_core * (p).sockets_per_node *  \
-        (p).cores_per_socket * (p).threads_per_core)
-#define COMPAT_FIELD_physinfo_get_sockets_per_node(p)  (p).sockets_per_node
-#endif
-
-#if __XEN_LATEST_INTERFACE_VERSION__ >= 0x00030209
-#define COMPAT_FIELD_ADDRESS_BITS              mem_flags
-#else
-#define COMPAT_FIELD_ADDRESS_BITS              address_bits
-#endif
diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/libs/xc/xc.ml
--- a/tools/ocaml/libs/xc/xc.ml Thu Nov 18 05:46:26 2010 -0500
+++ b/tools/ocaml/libs/xc/xc.ml Thu Nov 18 05:46:26 2010 -0500
@@ -127,9 +127,6 @@ external _domain_sethandle: handle -> do
 let domain_sethandle handle n uuid =
        _domain_sethandle handle n (Uuid.int_array_of_uuid uuid)
 
-external domain_setvmxassist: handle -> domid -> bool -> unit
-       = "stub_xc_domain_setvmxassist"
-
 external domain_max_vcpus: handle -> domid -> int -> unit
        = "stub_xc_domain_max_vcpus"
 
@@ -165,9 +162,9 @@ external domain_iomem_permission: handle
 external domain_irq_permission: handle -> domid -> int -> bool -> unit
        = "stub_xc_domain_irq_permission"
 
-external vcpu_affinity_set: handle -> domid -> int -> int64 -> unit
+external vcpu_affinity_set: handle -> domid -> int -> bool array -> unit
        = "stub_xc_vcpu_setaffinity"
-external vcpu_affinity_get: handle -> domid -> int -> int64
+external vcpu_affinity_get: handle -> domid -> int -> bool array
        = "stub_xc_vcpu_getaffinity"
 
 external vcpu_context_get: handle -> domid -> int -> string
@@ -207,13 +204,13 @@ external domain_set_machine_address_size
 external domain_get_machine_address_size: handle -> domid -> int
        = "stub_xc_domain_get_machine_address_size"
 
-external domain_cpuid_set: handle -> domid -> bool -> (int64 * (int64 option))
+external domain_cpuid_set: handle -> domid -> (int64 * (int64 option))
                         -> string option array
                         -> string option array
        = "stub_xc_domain_cpuid_set"
-external domain_cpuid_apply: handle -> domid -> bool -> unit
-       = "stub_xc_domain_cpuid_apply"
-external cpuid_check: (int64 * (int64 option)) -> string option array -> (bool 
* string option array)
+external domain_cpuid_apply_policy: handle -> domid -> unit
+       = "stub_xc_domain_cpuid_apply_policy"
+external cpuid_check: handle -> (int64 * (int64 option)) -> string option 
array -> (bool * string option array)
        = "stub_xc_cpuid_check"
 
 external map_foreign_range: handle -> domid -> int
@@ -230,17 +227,6 @@ external domain_deassign_device: handle 
 external domain_test_assign_device: handle -> domid -> (int * int * int * int) 
-> bool
        = "stub_xc_domain_test_assign_device"
 
-external domain_set_timer_mode: handle -> domid -> int -> unit = 
"stub_xc_domain_set_timer_mode"
-external domain_set_hpet: handle -> domid -> int -> unit = 
"stub_xc_domain_set_hpet"
-external domain_set_vpt_align: handle -> domid -> int -> unit = 
"stub_xc_domain_set_vpt_align"
-
-external domain_send_s3resume: handle -> domid -> unit = 
"stub_xc_domain_send_s3resume"
-external domain_get_acpi_s_state: handle -> domid -> int = 
"stub_xc_domain_get_acpi_s_state"
-
-(** check if some hvm domain got pv driver or not *)
-external hvm_check_pvdriver: handle -> domid -> bool
-       = "stub_xc_hvm_check_pvdriver"
-
 external version: handle -> version = "stub_xc_version_version"
 external version_compile_info: handle -> compile_info
        = "stub_xc_version_compile_info"
diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/libs/xc/xc.mli
--- a/tools/ocaml/libs/xc/xc.mli        Thu Nov 18 05:46:26 2010 -0500
+++ b/tools/ocaml/libs/xc/xc.mli        Thu Nov 18 05:46:26 2010 -0500
@@ -80,8 +80,6 @@ val domain_create : handle -> int32 -> d
 external _domain_sethandle : handle -> domid -> int array -> unit
   = "stub_xc_domain_sethandle"
 val domain_sethandle : handle -> domid -> 'a Uuid.t -> unit
-external domain_setvmxassist: handle -> domid -> bool -> unit
-  = "stub_xc_domain_setvmxassist"
 external domain_max_vcpus : handle -> domid -> int -> unit
   = "stub_xc_domain_max_vcpus"
 external domain_pause : handle -> domid -> unit = "stub_xc_domain_pause"
@@ -104,9 +102,9 @@ external domain_iomem_permission: handle
        = "stub_xc_domain_iomem_permission"
 external domain_irq_permission: handle -> domid -> int -> bool -> unit
        = "stub_xc_domain_irq_permission"
-external vcpu_affinity_set : handle -> domid -> int -> int64 -> unit
+external vcpu_affinity_set : handle -> domid -> int -> bool array -> unit
   = "stub_xc_vcpu_setaffinity"
-external vcpu_affinity_get : handle -> domid -> int -> int64
+external vcpu_affinity_get : handle -> domid -> int -> bool array
   = "stub_xc_vcpu_getaffinity"
 external vcpu_context_get : handle -> domid -> int -> string
   = "stub_xc_vcpu_context_get"
@@ -147,16 +145,6 @@ external domain_deassign_device: handle 
 external domain_test_assign_device: handle -> domid -> (int * int * int * int) 
-> bool
        = "stub_xc_domain_test_assign_device"
 
-external domain_set_timer_mode: handle -> domid -> int -> unit = 
"stub_xc_domain_set_timer_mode"
-external domain_set_hpet: handle -> domid -> int -> unit = 
"stub_xc_domain_set_hpet"
-external domain_set_vpt_align: handle -> domid -> int -> unit = 
"stub_xc_domain_set_vpt_align"
-
-external domain_send_s3resume: handle -> domid -> unit
-  = "stub_xc_domain_send_s3resume"
-external domain_get_acpi_s_state: handle -> domid -> int = 
"stub_xc_domain_get_acpi_s_state"
-
-external hvm_check_pvdriver : handle -> domid -> bool
-  = "stub_xc_hvm_check_pvdriver"
 external version : handle -> version = "stub_xc_version_version"
 external version_compile_info : handle -> compile_info
   = "stub_xc_version_compile_info"
@@ -185,12 +173,12 @@ external domain_set_machine_address_size
 external domain_get_machine_address_size: handle -> domid -> int
        = "stub_xc_domain_get_machine_address_size"
 
-external domain_cpuid_set: handle -> domid -> bool -> (int64 * (int64 option))
+external domain_cpuid_set: handle -> domid -> (int64 * (int64 option))
                         -> string option array
                         -> string option array
        = "stub_xc_domain_cpuid_set"
-external domain_cpuid_apply: handle -> domid -> bool -> unit
-       = "stub_xc_domain_cpuid_apply"
-external cpuid_check: (int64 * (int64 option)) -> string option array -> (bool 
* string option array)
+external domain_cpuid_apply_policy: handle -> domid -> unit
+       = "stub_xc_domain_cpuid_apply_policy"
+external cpuid_check: handle -> (int64 * (int64 option)) -> string option 
array -> (bool * string option array)
        = "stub_xc_cpuid_check"
 
diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/libs/xc/xc_cpufeature.h
--- a/tools/ocaml/libs/xc/xc_cpufeature.h       Thu Nov 18 05:46:26 2010 -0500
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,116 +0,0 @@
-#ifndef __LIBXC_CPUFEATURE_H
-#define __LIBXC_CPUFEATURE_H
-
-/* Intel-defined CPU features, CPUID level 0x00000001 (edx), word 0 */
-#define X86_FEATURE_FPU                (0*32+ 0) /* Onboard FPU */
-#define X86_FEATURE_VME                (0*32+ 1) /* Virtual Mode Extensions */
-#define X86_FEATURE_DE         (0*32+ 2) /* Debugging Extensions */
-#define X86_FEATURE_PSE        (0*32+ 3) /* Page Size Extensions */
-#define X86_FEATURE_TSC                (0*32+ 4) /* Time Stamp Counter */
-#define X86_FEATURE_MSR                (0*32+ 5) /* Model-Specific Registers, 
RDMSR, WRMSR */
-#define X86_FEATURE_PAE                (0*32+ 6) /* Physical Address 
Extensions */
-#define X86_FEATURE_MCE                (0*32+ 7) /* Machine Check Architecture 
*/
-#define X86_FEATURE_CX8                (0*32+ 8) /* CMPXCHG8 instruction */
-#define X86_FEATURE_APIC       (0*32+ 9) /* Onboard APIC */
-#define X86_FEATURE_SEP                (0*32+11) /* SYSENTER/SYSEXIT */
-#define X86_FEATURE_MTRR       (0*32+12) /* Memory Type Range Registers */
-#define X86_FEATURE_PGE                (0*32+13) /* Page Global Enable */
-#define X86_FEATURE_MCA                (0*32+14) /* Machine Check Architecture 
*/
-#define X86_FEATURE_CMOV       (0*32+15) /* CMOV instruction (FCMOVCC and 
FCOMI too if FPU present) */
-#define X86_FEATURE_PAT                (0*32+16) /* Page Attribute Table */
-#define X86_FEATURE_PSE36      (0*32+17) /* 36-bit PSEs */
-#define X86_FEATURE_PN         (0*32+18) /* Processor serial number */
-#define X86_FEATURE_CLFLSH     (0*32+19) /* Supports the CLFLUSH instruction */
-#define X86_FEATURE_DS         (0*32+21) /* Debug Store */
-#define X86_FEATURE_ACPI       (0*32+22) /* ACPI via MSR */
-#define X86_FEATURE_MMX                (0*32+23) /* Multimedia Extensions */
-#define X86_FEATURE_FXSR       (0*32+24) /* FXSAVE and FXRSTOR instructions 
(fast save and restore */
-                                         /* of FPU context), and CR4.OSFXSR 
available */
-#define X86_FEATURE_XMM                (0*32+25) /* Streaming SIMD Extensions 
*/
-#define X86_FEATURE_XMM2       (0*32+26) /* Streaming SIMD Extensions-2 */
-#define X86_FEATURE_SELFSNOOP  (0*32+27) /* CPU self snoop */
-#define X86_FEATURE_HT         (0*32+28) /* Hyper-Threading */
-#define X86_FEATURE_ACC                (0*32+29) /* Automatic clock control */
-#define X86_FEATURE_IA64       (0*32+30) /* IA-64 processor */
-#define X86_FEATURE_PBE                (0*32+31) /* Pending Break Enable */
-
-/* AMD-defined CPU features, CPUID level 0x80000001, word 1 */
-/* Don't duplicate feature flags which are redundant with Intel! */
-#define X86_FEATURE_SYSCALL    (1*32+11) /* SYSCALL/SYSRET */
-#define X86_FEATURE_MP         (1*32+19) /* MP Capable. */
-#define X86_FEATURE_NX         (1*32+20) /* Execute Disable */
-#define X86_FEATURE_MMXEXT     (1*32+22) /* AMD MMX extensions */
-#define X86_FEATURE_FFXSR       (1*32+25) /* FFXSR instruction optimizations */
-#define X86_FEATURE_PAGE1GB    (1*32+26) /* 1Gb large page support */
-#define X86_FEATURE_RDTSCP     (1*32+27) /* RDTSCP */
-#define X86_FEATURE_LM         (1*32+29) /* Long Mode (x86-64) */
-#define X86_FEATURE_3DNOWEXT   (1*32+30) /* AMD 3DNow! extensions */
-#define X86_FEATURE_3DNOW      (1*32+31) /* 3DNow! */
-
-/* Transmeta-defined CPU features, CPUID level 0x80860001, word 2 */
-#define X86_FEATURE_RECOVERY   (2*32+ 0) /* CPU in recovery mode */
-#define X86_FEATURE_LONGRUN    (2*32+ 1) /* Longrun power control */
-#define X86_FEATURE_LRTI       (2*32+ 3) /* LongRun table interface */
-
-/* Other features, Linux-defined mapping, word 3 */
-/* This range is used for feature bits which conflict or are synthesized */
-#define X86_FEATURE_CXMMX      (3*32+ 0) /* Cyrix MMX extensions */
-#define X86_FEATURE_K6_MTRR    (3*32+ 1) /* AMD K6 nonstandard MTRRs */
-#define X86_FEATURE_CYRIX_ARR  (3*32+ 2) /* Cyrix ARRs (= MTRRs) */
-#define X86_FEATURE_CENTAUR_MCR        (3*32+ 3) /* Centaur MCRs (= MTRRs) */
-/* cpu types for specific tunings: */
-#define X86_FEATURE_K8         (3*32+ 4) /* Opteron, Athlon64 */
-#define X86_FEATURE_K7         (3*32+ 5) /* Athlon */
-#define X86_FEATURE_P3         (3*32+ 6) /* P3 */
-#define X86_FEATURE_P4         (3*32+ 7) /* P4 */
-#define X86_FEATURE_CONSTANT_TSC (3*32+ 8) /* TSC ticks at a constant rate */
-
-/* Intel-defined CPU features, CPUID level 0x00000001 (ecx), word 4 */
-#define X86_FEATURE_XMM3       (4*32+ 0) /* Streaming SIMD Extensions-3 */
-#define X86_FEATURE_DTES64     (4*32+ 2) /* 64-bit Debug Store */
-#define X86_FEATURE_MWAIT      (4*32+ 3) /* Monitor/Mwait support */
-#define X86_FEATURE_DSCPL      (4*32+ 4) /* CPL Qualified Debug Store */
-#define X86_FEATURE_VMXE       (4*32+ 5) /* Virtual Machine Extensions */
-#define X86_FEATURE_SMXE       (4*32+ 6) /* Safer Mode Extensions */
-#define X86_FEATURE_EST                (4*32+ 7) /* Enhanced SpeedStep */
-#define X86_FEATURE_TM2                (4*32+ 8) /* Thermal Monitor 2 */
-#define X86_FEATURE_SSSE3      (4*32+ 9) /* Supplemental Streaming SIMD 
Extensions-3 */
-#define X86_FEATURE_CID                (4*32+10) /* Context ID */
-#define X86_FEATURE_CX16        (4*32+13) /* CMPXCHG16B */
-#define X86_FEATURE_XTPR       (4*32+14) /* Send Task Priority Messages */
-#define X86_FEATURE_PDCM       (4*32+15) /* Perf/Debug Capability MSR */
-#define X86_FEATURE_DCA                (4*32+18) /* Direct Cache Access */
-#define X86_FEATURE_SSE4_1     (4*32+19) /* Streaming SIMD Extensions 4.1 */
-#define X86_FEATURE_SSE4_2     (4*32+20) /* Streaming SIMD Extensions 4.2 */
-#define X86_FEATURE_POPCNT     (4*32+23) /* POPCNT instruction */
-#define X86_FEATURE_HYPERVISOR (4*32+31) /* Running under some hypervisor */
-
-/* VIA/Cyrix/Centaur-defined CPU features, CPUID level 0xC0000001, word 5 */
-#define X86_FEATURE_XSTORE     (5*32+ 2) /* on-CPU RNG present (xstore insn) */
-#define X86_FEATURE_XSTORE_EN  (5*32+ 3) /* on-CPU RNG enabled */
-#define X86_FEATURE_XCRYPT     (5*32+ 6) /* on-CPU crypto (xcrypt insn) */
-#define X86_FEATURE_XCRYPT_EN  (5*32+ 7) /* on-CPU crypto enabled */
-#define X86_FEATURE_ACE2       (5*32+ 8) /* Advanced Cryptography Engine v2 */
-#define X86_FEATURE_ACE2_EN    (5*32+ 9) /* ACE v2 enabled */
-#define X86_FEATURE_PHE                (5*32+ 10) /* PadLock Hash Engine */
-#define X86_FEATURE_PHE_EN     (5*32+ 11) /* PHE enabled */
-#define X86_FEATURE_PMM                (5*32+ 12) /* PadLock Montgomery 
Multiplier */
-#define X86_FEATURE_PMM_EN     (5*32+ 13) /* PMM enabled */
-
-/* More extended AMD flags: CPUID level 0x80000001, ecx, word 6 */
-#define X86_FEATURE_LAHF_LM    (6*32+ 0) /* LAHF/SAHF in long mode */
-#define X86_FEATURE_CMP_LEGACY (6*32+ 1) /* If yes HyperThreading not valid */
-#define X86_FEATURE_SVME        (6*32+ 2) /* Secure Virtual Machine */
-#define X86_FEATURE_EXTAPICSPACE (6*32+ 3) /* Extended APIC space */
-#define X86_FEATURE_ALTMOVCR   (6*32+ 4) /* LOCK MOV CR accesses CR+8 */
-#define X86_FEATURE_ABM                (6*32+ 5) /* Advanced Bit Manipulation 
*/
-#define X86_FEATURE_SSE4A      (6*32+ 6) /* AMD Streaming SIMD Extensions-4a */
-#define X86_FEATURE_MISALIGNSSE        (6*32+ 7) /* Misaligned SSE Access */
-#define X86_FEATURE_3DNOWPF    (6*32+ 8) /* 3DNow! Prefetch */
-#define X86_FEATURE_OSVW       (6*32+ 9) /* OS Visible Workaround */
-#define X86_FEATURE_IBS                (6*32+ 10) /* Instruction Based 
Sampling */
-#define X86_FEATURE_SSE5       (6*32+ 11) /* AMD Streaming SIMD Extensions-5 */
-#define X86_FEATURE_SKINIT     (6*32+ 12) /* SKINIT, STGI/CLGI, DEV */
-#define X86_FEATURE_WDT                (6*32+ 13) /* Watchdog Timer */
-
-#endif /* __LIBXC_CPUFEATURE_H */
diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/libs/xc/xc_cpuid.h
--- a/tools/ocaml/libs/xc/xc_cpuid.h    Thu Nov 18 05:46:26 2010 -0500
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,285 +0,0 @@
-#ifndef XC_CPUID_H
-#define XC_CPUID_H
-
-#ifdef XEN_DOMCTL_set_cpuid
-
-#include "xc_cpufeature.h"
-
-#define bitmaskof(idx)      (1u << ((idx) & 31))
-#define clear_bit(idx, dst) ((dst) &= ~(1u << ((idx) & 31)))
-#define set_bit(idx, dst)   ((dst) |= (1u << ((idx) & 31)))
-
-#define DEF_MAX_BASE 0x00000004u
-#define DEF_MAX_EXT  0x80000008u
-
-static void xc_cpuid(uint32_t eax, uint32_t ecx, uint32_t regs[4])
-{
-       unsigned int realecx = (ecx == XEN_CPUID_INPUT_UNUSED) ? 0 : ecx;
-       asm (
-#ifdef __i386__
-            "push %%ebx; cpuid; mov %%ebx,%1; pop %%ebx"
-#else
-            "push %%rbx; cpuid; mov %%ebx,%1; pop %%rbx"
-#endif
-           : "=a" (regs[0]), "=r" (regs[1]), "=c" (regs[2]), "=d" (regs[3])
-           : "0" (eax), "2" (realecx));
-}
-
-enum { CPU_BRAND_INTEL, CPU_BRAND_AMD, CPU_BRAND_UNKNOWN };
-
-static int xc_cpuid_brand_get(void)
-{
-       uint32_t regs[4];
-       char str[13];
-       uint32_t *istr = (uint32_t *) str;
-
-       xc_cpuid(0, 0, regs);
-       istr[0] = regs[1];
-       istr[1] = regs[3];
-       istr[2] = regs[2];
-       str[12] = '\0';
-       if      (strcmp(str, "AuthenticAMD") == 0) {
-               return CPU_BRAND_AMD;
-       } else if (strcmp(str, "GenuineIntel") == 0) {
-               return CPU_BRAND_INTEL;
-       } else
-               return CPU_BRAND_UNKNOWN;
-}
-
-static int hypervisor_is_64bit(int xc)
-{
-       xen_capabilities_info_t xen_caps;
-       return ((xc_version(xc, XENVER_capabilities, &xen_caps) == 0) &&
-               (strstr(xen_caps, "x86_64") != NULL));
-}
-
-static void do_hvm_cpuid_policy(int xc, int domid, uint32_t input, uint32_t 
regs[4])
-{
-       unsigned long is_pae;
-       int brand;
-
-       /* pae ? */
-       xc_get_hvm_param(xc, domid, HVM_PARAM_PAE_ENABLED, &is_pae);
-       is_pae = !!is_pae;
-
-       switch (input) {
-       case 0x00000000:
-               if (regs[0] > DEF_MAX_BASE)
-                       regs[0] = DEF_MAX_BASE;
-               break;
-       case 0x00000001:
-               regs[2] &= (bitmaskof(X86_FEATURE_XMM3) |
-                               bitmaskof(X86_FEATURE_SSSE3) |
-                               bitmaskof(X86_FEATURE_CX16) |
-                               bitmaskof(X86_FEATURE_SSE4_1) |
-                               bitmaskof(X86_FEATURE_SSE4_2) |
-                               bitmaskof(X86_FEATURE_POPCNT));
-
-                regs[2] |= bitmaskof(X86_FEATURE_HYPERVISOR);
-
-               regs[3] &= (bitmaskof(X86_FEATURE_FPU) |
-                               bitmaskof(X86_FEATURE_VME) |
-                               bitmaskof(X86_FEATURE_DE) |
-                               bitmaskof(X86_FEATURE_PSE) |
-                               bitmaskof(X86_FEATURE_TSC) |
-                               bitmaskof(X86_FEATURE_MSR) |
-                               bitmaskof(X86_FEATURE_PAE) |
-                               bitmaskof(X86_FEATURE_MCE) |
-                               bitmaskof(X86_FEATURE_CX8) |
-                               bitmaskof(X86_FEATURE_APIC) |
-                               bitmaskof(X86_FEATURE_SEP) |
-                               bitmaskof(X86_FEATURE_MTRR) |
-                               bitmaskof(X86_FEATURE_PGE) |
-                               bitmaskof(X86_FEATURE_MCA) |
-                               bitmaskof(X86_FEATURE_CMOV) |
-                               bitmaskof(X86_FEATURE_PAT) |
-                               bitmaskof(X86_FEATURE_CLFLSH) |
-                               bitmaskof(X86_FEATURE_MMX) |
-                               bitmaskof(X86_FEATURE_FXSR) |
-                               bitmaskof(X86_FEATURE_XMM) |
-                               bitmaskof(X86_FEATURE_XMM2));
-               /* We always support MTRR MSRs. */
-               regs[3] |= bitmaskof(X86_FEATURE_MTRR);
-
-               if (!is_pae)
-                       clear_bit(X86_FEATURE_PAE, regs[3]);
-               break;
-       case 0x80000000:
-               if (regs[0] > DEF_MAX_EXT)
-                       regs[0] = DEF_MAX_EXT;
-               break;
-       case 0x80000001:
-               if (!is_pae)
-                       clear_bit(X86_FEATURE_NX, regs[3]);
-               break;
-       case 0x80000008:
-               regs[0] &= 0x0000ffffu;
-               regs[1] = regs[2] = regs[3] = 0;
-               break;
-       case 0x00000002: /* Intel cache info (dumped by AMD policy) */
-       case 0x00000004: /* Intel cache info (dumped by AMD policy) */
-       case 0x80000002: /* Processor name string */
-       case 0x80000003: /* ... continued         */
-       case 0x80000004: /* ... continued         */
-       case 0x80000005: /* AMD L1 cache/TLB info (dumped by Intel policy) */
-       case 0x80000006: /* AMD L2/3 cache/TLB info ; Intel L2 cache features */
-               break;
-       default:
-               regs[0] = regs[1] = regs[2] = regs[3] = 0;
-               break;
-       }
-       
-       brand = xc_cpuid_brand_get();
-       if (brand == CPU_BRAND_AMD) {
-               switch (input) {
-               case 0x00000001:
-                       /* Mask Intel-only features. */
-                       regs[2] &= ~(bitmaskof(X86_FEATURE_SSSE3) |
-                                       bitmaskof(X86_FEATURE_SSE4_1) |
-                                       bitmaskof(X86_FEATURE_SSE4_2));
-                       break;
-
-               case 0x00000002:
-               case 0x00000004:
-                       regs[0] = regs[1] = regs[2] = 0;
-                       break;
-
-               case 0x80000001: {
-                       int is_64bit = hypervisor_is_64bit(xc) && is_pae;
-
-                       if (!is_pae)
-                                clear_bit(X86_FEATURE_PAE, regs[3]);
-                       clear_bit(X86_FEATURE_PSE36, regs[3]);
-
-                       /* Filter all other features according to a whitelist. 
*/
-                       regs[2] &= ((is_64bit ? bitmaskof(X86_FEATURE_LAHF_LM) 
: 0) |
-                                        bitmaskof(X86_FEATURE_ALTMOVCR) |
-                                        bitmaskof(X86_FEATURE_ABM) |
-                                        bitmaskof(X86_FEATURE_SSE4A) |
-                                        bitmaskof(X86_FEATURE_MISALIGNSSE) |
-                                        bitmaskof(X86_FEATURE_3DNOWPF));
-                       regs[3] &= (0x0183f3ff | /* features shared with 
0x00000001:EDX */
-                                        (is_pae ? bitmaskof(X86_FEATURE_NX) : 
0) |
-                                        (is_64bit ? bitmaskof(X86_FEATURE_LM) 
: 0) |
-                                        bitmaskof(X86_FEATURE_SYSCALL) |
-                                        bitmaskof(X86_FEATURE_MP) |
-                                        bitmaskof(X86_FEATURE_MMXEXT) |
-                                        bitmaskof(X86_FEATURE_FFXSR) |
-                                        bitmaskof(X86_FEATURE_3DNOW) |
-                                        bitmaskof(X86_FEATURE_3DNOWEXT));
-                       break;
-                       }
-               }
-       } else if (brand == CPU_BRAND_INTEL) {
-               switch (input) {
-               case 0x00000001:
-                       /* Mask AMD-only features. */
-                       regs[2] &= ~(bitmaskof(X86_FEATURE_POPCNT));
-                       break;
-
-               case 0x00000004:
-                       regs[0] &= 0x3FF;
-                       regs[3] &= 0x3FF;
-                       break;
-
-               case 0x80000001:
-                       {
-                       int is_64bit = hypervisor_is_64bit(xc) && is_pae;
-
-                       /* Only a few features are advertised in Intel's 
0x80000001. */
-                       regs[2] &= (is_64bit ? bitmaskof(X86_FEATURE_LAHF_LM) : 
0);
-                       regs[3] &= ((is_pae ? bitmaskof(X86_FEATURE_NX) : 0) |
-                                       (is_64bit ? bitmaskof(X86_FEATURE_LM) : 
0) |
-                                       (is_64bit ? 
bitmaskof(X86_FEATURE_SYSCALL) : 0));
-                       break;
-                       }
-               case 0x80000005:
-                       {
-                       regs[0] = regs[1] = regs[2] = 0;
-                       break;
-                       }
-               }
-       }
-}
-
-static void do_pv_cpuid_policy(int xc, int domid, uint32_t input, uint32_t 
regs[4])
-{
-       int brand;
-       int guest_64_bits, xen_64_bits;
-       int ret;
-       
-       ret = xc_domain_get_machine_address_size(xc, domid);
-       if (ret < 0)
-               return;
-       guest_64_bits = (ret == 64);
-       xen_64_bits = hypervisor_is_64bit(xc);
-       brand = xc_cpuid_brand_get();
-
-       if ((input & 0x7fffffff) == 1) {
-               clear_bit(X86_FEATURE_VME, regs[3]);
-               clear_bit(X86_FEATURE_PSE, regs[3]);
-               clear_bit(X86_FEATURE_PGE, regs[3]);
-               clear_bit(X86_FEATURE_MCE, regs[3]);
-               clear_bit(X86_FEATURE_MCA, regs[3]);
-               clear_bit(X86_FEATURE_MTRR, regs[3]);
-               clear_bit(X86_FEATURE_PSE36, regs[3]);
-       }
-
-       switch (input) {
-       case 1:
-               if (!xen_64_bits || brand == CPU_BRAND_AMD)
-                       clear_bit(X86_FEATURE_SEP, regs[3]);
-               clear_bit(X86_FEATURE_DS, regs[3]);
-               clear_bit(X86_FEATURE_ACC, regs[3]);
-               clear_bit(X86_FEATURE_PBE, regs[3]);
-
-               clear_bit(X86_FEATURE_DTES64, regs[2]);
-               clear_bit(X86_FEATURE_MWAIT, regs[2]);
-               clear_bit(X86_FEATURE_DSCPL, regs[2]);
-               clear_bit(X86_FEATURE_VMXE, regs[2]);
-               clear_bit(X86_FEATURE_SMXE, regs[2]);
-               clear_bit(X86_FEATURE_EST, regs[2]);
-               clear_bit(X86_FEATURE_TM2, regs[2]);
-               if (!guest_64_bits)
-                       clear_bit(X86_FEATURE_CX16, regs[2]);
-               clear_bit(X86_FEATURE_XTPR, regs[2]);
-               clear_bit(X86_FEATURE_PDCM, regs[2]);
-               clear_bit(X86_FEATURE_DCA, regs[2]);
-               break;
-       case 0x80000001:
-               if (!guest_64_bits) {
-                       clear_bit(X86_FEATURE_LM, regs[3]);
-                       clear_bit(X86_FEATURE_LAHF_LM, regs[2]);
-                       if (brand != CPU_BRAND_AMD)
-                               clear_bit(X86_FEATURE_SYSCALL, regs[3]);
-               } else
-                       set_bit(X86_FEATURE_SYSCALL, regs[3]);
-               clear_bit(X86_FEATURE_PAGE1GB, regs[3]);
-               clear_bit(X86_FEATURE_RDTSCP, regs[3]);
-
-               clear_bit(X86_FEATURE_SVME, regs[2]);
-               clear_bit(X86_FEATURE_OSVW, regs[2]);
-               clear_bit(X86_FEATURE_IBS, regs[2]);
-               clear_bit(X86_FEATURE_SKINIT, regs[2]);
-               clear_bit(X86_FEATURE_WDT, regs[2]);
-               break;
-       case 5: /* MONITOR/MWAIT */
-       case 0xa: /* Architectural Performance Monitor Features */
-       case 0x8000000a: /* SVM revision and features */
-       case 0x8000001b: /* Instruction Based Sampling */
-               regs[0] = regs[1] = regs[2] = regs[3] = 0;
-               break;
-       }
-}
-
-static void do_cpuid_policy(int xc, int domid, int hvm, uint32_t input, 
uint32_t regs[4])
-{
-       if (hvm)
-               do_hvm_cpuid_policy(xc, domid, input, regs);
-       else
-               do_pv_cpuid_policy(xc, domid, input, regs);
-}
-
-#endif
-
-#endif
diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/libs/xc/xc_e820.h
--- a/tools/ocaml/libs/xc/xc_e820.h     Thu Nov 18 05:46:26 2010 -0500
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,20 +0,0 @@
-#ifndef __XC_E820_H__
-#define __XC_E820_H__
-
-#include <xen/hvm/e820.h>
-
-/*
- * PC BIOS standard E820 types and structure.
- */
-#define E820_RAM          1
-#define E820_RESERVED     2
-#define E820_ACPI         3
-#define E820_NVS          4
-
-struct e820entry {
-    uint64_t addr;
-    uint64_t size;
-    uint32_t type;
-} __attribute__((packed));
-
-#endif /* __XC_E820_H__ */
diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/libs/xc/xc_lib.c
--- a/tools/ocaml/libs/xc/xc_lib.c      Thu Nov 18 05:46:26 2010 -0500
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,1537 +0,0 @@
-/*
- * Copyright (C) 2006-2007 XenSource Ltd.
- * Copyright (C) 2008      Citrix Ltd.
- * Author Vincent Hanquez <vincent.hanquez@xxxxxxxxxxxxx>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- */
-
-#include <stdint.h>
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <stdlib.h>
-#include <stdarg.h>
-
-#include "xc.h"
-
-#define PAGE_SHIFT             12
-#define PAGE_SIZE               (1UL << PAGE_SHIFT)
-#define PAGE_MASK               (~(PAGE_SIZE-1))
-
-#define MIN(a, b)              (((a) < (b)) ? (a) : (b))
-
-#define DECLARE_DOMCTL(_cmd, _domain)  \
-       struct xen_domctl domctl = {    \
-               .cmd = _cmd,            \
-               .domain = _domain,      \
-               .interface_version = XEN_DOMCTL_INTERFACE_VERSION, \
-       }
-
-#define DECLARE_SYSCTL(_cmd)           \
-       struct xen_sysctl sysctl = {    \
-               .cmd = _cmd,            \
-               .interface_version = XEN_SYSCTL_INTERFACE_VERSION, \
-       }
-
-#define DECLARE_HYPERCALL2(_cmd, _arg0, _arg1) \
-       privcmd_hypercall_t hypercall = {       \
-               .op = _cmd,                     \
-               .arg[0] = (unsigned long) _arg0,\
-               .arg[1] = (unsigned long) _arg1,\
-       }
-#define DECLARE_HYPERCALL0(_cmd)       DECLARE_HYPERCALL2(_cmd, 0, 0);
-#define DECLARE_HYPERCALL1(_cmd, _arg0)        DECLARE_HYPERCALL2(_cmd, _arg0, 
0);
-
-/*---- Errors handlings ----*/
-#ifndef WITHOUT_GOOD_ERROR
-#define ERROR_STRLEN 256
-
-static char __error_str[ERROR_STRLEN];
-
-char * xc_error_get(void)
-{
-       return __error_str;
-}
-
-static void xc_error_set(const char *fmt, ...)
-{
-       va_list ap;
-       char __errordup[ERROR_STRLEN];
-
-       va_start(ap, fmt);
-       vsnprintf(__errordup, ERROR_STRLEN, fmt, ap);
-       va_end(ap);
-       memcpy(__error_str, __errordup, ERROR_STRLEN);
-}
-
-static void xc_error_dom_set(unsigned int domid, const char *fmt, ...)
-{
-       va_list ap;
-       char __errordup[ERROR_STRLEN];
-       int i;
-
-       i = snprintf(__errordup, ERROR_STRLEN, "domain %u - ", domid);
-       va_start(ap, fmt);
-       i += vsnprintf(__errordup + i, ERROR_STRLEN - i, fmt, ap);
-       va_end(ap);
-       snprintf(__errordup + i, ERROR_STRLEN - i,
-                " failed: %s", xc_error_get());
-       memcpy(__error_str, __errordup, ERROR_STRLEN);
-}
-
-void xc_error_clear(void)
-{
-       memset(__error_str, '\0', ERROR_STRLEN);
-}
-#else
-char * xc_error_get(void)
-{
-       return "";
-}
-#define xc_error_set(fmt, ...) do {} while (0)
-#define xc_error_dom_set(id, fmt, ...) do {} while (0)
-#define xc_error_clear() do {} while (0)
-#endif
-
-#define xc_error_hypercall(_h, _r) \
-       xc_error_set("hypercall %lld fail: %d: %s (ret %d)", _h.op, errno, 
errno ? strerror(errno) : strerror(-_r), _r)
-
-int xc_using_injection(void)
-{
-       return 0;
-}
-
-/*---- Trivia ----*/
-int xc_interface_open(void)
-{
-       int fd, ret;
-
-       fd = open("/proc/xen/privcmd", O_RDWR);
-       if (fd == -1) {
-               xc_error_set("open /proc/xen/privcmd failed: %s",
-                            strerror(errno));
-               return -1;
-       }
-
-       ret = fcntl(fd, F_GETFD);
-       if (ret < 0) {
-               xc_error_set("cannot get handle flags: %s",
-                            strerror(errno));
-               goto out;
-       }
-
-       ret = fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
-       if (ret < 0) {
-               xc_error_set("cannot set handle flags: %s",
-                            strerror(errno));
-               goto out;
-       }
-
-       return fd;
-out:
-       close(fd);
-       return -1;
-}
-
-int xc_interface_close(int handle)
-{
-       int ret;
-
-       ret = close(handle);
-       if (ret != 0)
-               xc_error_set("close xc failed: %s", strerror(errno));
-       return ret;
-}
-
-/*---- Low private operations ----*/
-static int do_xen_hypercall(int handle, privcmd_hypercall_t *hypercall)
-{
-       return ioctl(handle, IOCTL_PRIVCMD_HYPERCALL, (unsigned long) 
hypercall);
-}
-
-static int do_domctl(int handle, struct xen_domctl *domctl)
-{
-       int ret;
-       DECLARE_HYPERCALL1(__HYPERVISOR_domctl, domctl);
-
-       if (mlock(domctl, sizeof(*domctl)) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -1;
-       }
-
-       ret = do_xen_hypercall(handle, &hypercall);
-       if (ret < 0)
-               xc_error_hypercall(hypercall, ret);
-
-       munlock(domctl, sizeof(*domctl));
-       return ret;
-}
-
-static int do_sysctl(int handle, struct xen_sysctl *sysctl)
-{
-       int ret;
-       DECLARE_HYPERCALL1(__HYPERVISOR_sysctl, sysctl);
-
-       if (mlock(sysctl, sizeof(*sysctl)) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -1;
-       }
-
-       ret = do_xen_hypercall(handle, &hypercall);
-       if (ret < 0)
-               xc_error_hypercall(hypercall, ret);
-
-       munlock(sysctl, sizeof(*sysctl));
-       return ret;
-}
-
-static int do_evtchnctl(int handle, int cmd, void *arg, size_t arg_size)
-{
-       DECLARE_HYPERCALL2(__HYPERVISOR_event_channel_op, cmd, arg);
-       int ret;
-
-       if (mlock(arg, arg_size) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -1;
-       }
-
-       ret = do_xen_hypercall(handle, &hypercall);
-       if (ret < 0)
-               xc_error_hypercall(hypercall, ret);
-       munlock(arg, arg_size);
-       return ret;
-}
-
-static int do_memctl_reservation(int handle, int cmd,
-                                 struct xen_memory_reservation *reservation)
-{
-       int ret;
-       DECLARE_HYPERCALL2(__HYPERVISOR_memory_op, cmd, reservation);
-       xen_pfn_t *extent_start;
-
-       if (cmd != XENMEM_increase_reservation &&
-           cmd != XENMEM_decrease_reservation &&
-           cmd != XENMEM_populate_physmap) {
-               xc_error_set("do_memctl_reservation: unknown cmd %d", cmd);
-               return -EINVAL;
-       }
-
-       if (mlock(reservation, sizeof(*reservation)) == -1) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -ENOMEM;
-       }
-       get_xen_guest_handle(extent_start, reservation->extent_start);
-       if (extent_start && mlock(extent_start, reservation->nr_extents
-                                             * sizeof(xen_pfn_t)) == -1) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               munlock(reservation, sizeof(*reservation));
-               return -3;
-       }
-
-       ret = do_xen_hypercall(handle, &hypercall);
-       if (ret)
-               xc_error_hypercall(hypercall, ret);
-       munlock(extent_start, reservation->nr_extents * sizeof(xen_pfn_t));
-       get_xen_guest_handle(extent_start, reservation->extent_start);
-       munlock(reservation, sizeof(*reservation));
-       return ret;
-}
-
-static int do_ioctl(int handle, int cmd, void *arg)
-{
-       return ioctl(handle, cmd, arg);
-}
-
-static void * do_mmap(void *start, size_t length, int prot, int flags,
-                      int fd, off_t offset)
-{
-       return mmap(start, length, prot, flags, fd, offset);
-}
-
-int xc_get_hvm_param(int handle, unsigned int domid,
-                     int param, unsigned long *value)
-{
-       struct xen_hvm_param arg = {
-               .domid = domid,
-               .index = param,
-       };
-       DECLARE_HYPERCALL2(__HYPERVISOR_hvm_op, HVMOP_get_param,
-                          (unsigned long) &arg);
-       int ret;
-
-       if (mlock(&arg, sizeof(arg)) == -1) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -1;
-       }
-
-       ret = do_xen_hypercall(handle, &hypercall);
-       if (ret)
-               xc_error_hypercall(hypercall, ret);
-       *value = arg.value;
-       munlock(&arg, sizeof(arg));
-       return ret;
-}
-
-static int xc_set_hvm_param(int handle, unsigned int domid,
-                            int param, unsigned long value)
-{
-       struct xen_hvm_param arg = {
-               .domid = domid,
-               .index = param,
-               .value = value,
-       };
-       DECLARE_HYPERCALL2(__HYPERVISOR_hvm_op, HVMOP_set_param, (unsigned 
long) &arg);
-       int ret;
-
-       if (mlock(&arg, sizeof(arg)) == -1) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -1;
-       }
-
-       ret = do_xen_hypercall(handle, &hypercall);
-       if (ret)
-               xc_error_hypercall(hypercall, ret);
-       munlock(&arg, sizeof(arg));
-       return ret;
-}
-
-
-/*---- XC API ----*/
-int xc_domain_create(int handle, unsigned int ssidref,
-                     xen_domain_handle_t dhandle,
-                     unsigned int flags, unsigned int *pdomid)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_createdomain, *pdomid);
-       domctl.u.createdomain.ssidref = ssidref;
-       domctl.u.createdomain.flags = flags;
-       memcpy(domctl.u.createdomain.handle, dhandle, 
sizeof(xen_domain_handle_t));
-
-       ret = do_domctl(handle, &domctl);
-       if (ret != 0) {
-               xc_error_set("creating domain failed: %s", xc_error_get());
-               return ret;
-       }
-       *pdomid = domctl.domain;
-       return 0;
-}
-
-int xc_domain_pause(int handle, unsigned int domid)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_pausedomain, domid);
-
-       ret = do_domctl(handle, &domctl);
-       if (ret != 0)
-               xc_error_dom_set(domid, "pause");
-       return ret;
-}
-
-int xc_domain_unpause(int handle, unsigned int domid)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_unpausedomain, domid);
-
-       ret = do_domctl(handle, &domctl);
-       if (ret != 0)
-               xc_error_dom_set(domid, "unpause");
-       return ret;
-}
-
-/* return 1 if hvm domain got pv driver, 0 if not. -1 is error occurs */
-int xc_hvm_check_pvdriver(int handle, unsigned int domid)
-{
-       int ret;
-       unsigned long irq = 0;
-       xc_domaininfo_t info;
-
-       ret = xc_domain_getinfolist(handle, domid, 1, &info);
-       if (ret != 1) {
-               xc_error_set("domain getinfo failed: %s", strerror(errno));
-               xc_error_dom_set(domid, "hvm_check_pvdriver");
-               return -1;
-       }
-
-       if (!(info.flags & XEN_DOMINF_hvm_guest)) {
-               xc_error_set("domain is not hvm");
-               xc_error_dom_set(domid, "hvm_check_pvdriver");
-               return -1;
-       }
-       xc_get_hvm_param(handle, domid, HVM_PARAM_CALLBACK_IRQ, &irq);
-       return irq;
-}
-
-static int modify_returncode_register(int handle, unsigned int domid)
-{
-       int ret;
-       xc_domaininfo_t info;
-       xen_capabilities_info_t caps;
-       vcpu_guest_context_any_t context;
-
-       ret = xc_domain_getinfolist(handle, domid, 1, &info);
-       if (ret != 1) {
-               xc_error_set("domain getinfo failed: %s", strerror(errno));
-               return -1;
-       }
-
-       /* HVM guests without PV drivers do not have a return code to modify */
-       if (info.flags & XEN_DOMINF_hvm_guest) {
-               unsigned long irq = 0;
-               xc_get_hvm_param(handle, domid, HVM_PARAM_CALLBACK_IRQ, &irq);
-               if (!irq)
-                       return 0;
-       }
-
-       ret = xc_version(handle, XENVER_capabilities, &caps);
-       if (ret) {
-               xc_error_set("could not get Xen capabilities");
-               return ret;
-       }
-
-       ret = xc_vcpu_getcontext(handle, domid, 0, &context);
-       if (ret) {
-               xc_error_set("could not get vcpu 0 context");
-               return ret;
-       }
-
-       if (!(info.flags & XEN_DOMINF_hvm_guest))
-               context.c.user_regs.eax = 1;
-       else if (strstr(caps, "x86_64"))
-               context.x64.user_regs.eax = 1;
-       else
-               context.x32.user_regs.eax = 1;
-
-       ret = xc_vcpu_setcontext(handle, domid, 0, &context);
-       if (ret) {
-               xc_error_set("could not set vcpu 0 context");
-               return ret;
-       }
-       return 0;
-}
-
-int xc_domain_resume_fast(int handle, unsigned int domid)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_resumedomain, domid);
-
-       ret = modify_returncode_register(handle, domid);
-       if (ret != 0) {
-               xc_error_dom_set(domid, "resume_fast");
-               return ret;
-       }
-
-       ret = do_domctl(handle, &domctl);
-       if (ret != 0)
-               xc_error_dom_set(domid, "resume_fast");
-       return ret;
-}
-
-int xc_domain_destroy(int handle, unsigned int domid)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_destroydomain, domid);
-
-       do {
-               ret = do_domctl(handle, &domctl);
-       } while (ret && (errno == EAGAIN));
-       if (ret != 0)
-               xc_error_dom_set(domid, "destroy");
-       return ret;
-}
-
-int xc_domain_shutdown(int handle, int domid, int reason)
-{
-       sched_remote_shutdown_t arg = {
-               .domain_id = domid,
-               .reason = reason,
-       };
-       DECLARE_HYPERCALL2(__HYPERVISOR_sched_op, SCHEDOP_remote_shutdown, 
&arg);
-       int ret;
-
-       if (mlock(&arg, sizeof(arg)) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               xc_error_dom_set(domid, "shutdown %d", reason);
-               return -1;
-       }
-
-       ret = do_xen_hypercall(handle, &hypercall);
-       if (ret < 0) {
-               xc_error_hypercall(hypercall, ret);
-               xc_error_dom_set(domid, "shutdown %d", reason);
-       }
-       munlock(&arg, sizeof(arg));
-       return ret;
-}
-
-static void bitmap_64_to_byte(uint8_t *bp, const uint64_t *lp, int nbits)
-{
-    uint64_t l;
-    int i, j, b;
-
-    for (i = 0, b = 0; nbits > 0; i++, b += sizeof(l)) {
-        l = lp[i];
-        for (j = 0; (j < sizeof(l)) && (nbits > 0); j++) {
-            bp[b+j] = l;
-            l >>= 8;
-            nbits -= 8;
-        }
-    }
-}
-
-static void bitmap_byte_to_64(uint64_t *lp, const uint8_t *bp, int nbits)
-{
-    uint64_t l;
-    int i, j, b;
-
-    for (i = 0, b = 0; nbits > 0; i++, b += sizeof(l)) {
-        l = 0;
-        for (j = 0; (j < sizeof(l)) && (nbits > 0); j++) {
-            l |= (uint64_t)bp[b+j] << (j*8);
-            nbits -= 8;
-        }
-        lp[i] = l;
-    }
-}
-
-int xc_vcpu_setaffinity(int handle, unsigned int domid, int vcpu,
-                        uint64_t cpumap)
-{
-       int ret;
-       uint8_t local[sizeof(cpumap)];
-       DECLARE_DOMCTL(XEN_DOMCTL_setvcpuaffinity, domid);
-       domctl.u.vcpuaffinity.vcpu = vcpu;
-       domctl.u.vcpuaffinity.cpumap.nr_cpus = sizeof(cpumap) * 8;
-
-       bitmap_64_to_byte(local, &cpumap, sizeof(cpumap)*8);
-       set_xen_guest_handle(domctl.u.vcpuaffinity.cpumap.bitmap, local);
-
-       if (mlock(&cpumap, sizeof(cpumap)) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               xc_error_dom_set(domid, "vcpu %d set affinity", vcpu);
-               return -1;
-       }
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "vcpu %d set affinity", vcpu);
-       munlock(&cpumap, sizeof(cpumap));
-       return ret;
-}
-
-int xc_vcpu_getaffinity(int handle, unsigned int domid, int vcpu,
-                        uint64_t *cpumap)
-{
-       int ret;
-       uint8_t local[sizeof(*cpumap)];
-       DECLARE_DOMCTL(XEN_DOMCTL_getvcpuaffinity, domid);
-       domctl.u.vcpuaffinity.vcpu = vcpu;
-       domctl.u.vcpuaffinity.cpumap.nr_cpus = sizeof(*cpumap) * 8;
-
-       set_xen_guest_handle(domctl.u.vcpuaffinity.cpumap.bitmap, local);
-
-       if (mlock(cpumap, sizeof(*cpumap)) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               xc_error_dom_set(domid, "vcpu %d get affinity", vcpu);
-               return -1;
-       }
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "vcpu %d get affinity", vcpu);
-       munlock(cpumap, sizeof(*cpumap));
-       bitmap_byte_to_64(cpumap, local, sizeof(*cpumap) * 8);
-       return ret;
-}
-
-int xc_vcpu_context_get(int handle, unsigned int domid, unsigned short vcpu,
-                        struct vcpu_guest_context *ctxt)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_getvcpucontext, domid);
-       domctl.u.vcpucontext.vcpu = vcpu;
-
-       set_xen_guest_handle(domctl.u.vcpucontext.ctxt, ctxt);
-
-       if (mlock(ctxt, sizeof(struct vcpu_guest_context)) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               xc_error_dom_set(domid, "vcpu %d get context", vcpu);
-               return -1;
-       }
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "vcpu %d get context", vcpu);
-       munlock(ctxt, sizeof(struct vcpu_guest_context));
-
-       return ret;
-}
-
-int xc_domain_getinfolist(int handle, unsigned int first_domain,
-                          unsigned int max_domains, xc_domaininfo_t *info)
-{
-       int ret;
-       DECLARE_SYSCTL(XEN_SYSCTL_getdomaininfolist);
-       sysctl.u.getdomaininfolist.first_domain = first_domain;
-       sysctl.u.getdomaininfolist.max_domains = max_domains;
-       set_xen_guest_handle(sysctl.u.getdomaininfolist.buffer, info);
-
-       if (mlock(info, max_domains * sizeof(xc_domaininfo_t)) != 0) {
-               xc_error_set("getinfolist(%d, %u, %u, %x (%d)) failed: mlock 
failed: %s",
-                            handle, first_domain, max_domains, info, 
sizeof(xc_domaininfo_t),
-                            strerror(errno));
-               return -1;
-       }
-
-       ret = do_sysctl(handle, &sysctl);
-       if (ret < 0)
-               xc_error_set("getinfolist(%d, %u, %u, %x (%d)) failed: %s", 
-                            handle, first_domain, max_domains, info, 
sizeof(xc_domaininfo_t),
-                            xc_error_get());
-       else
-               ret = sysctl.u.getdomaininfolist.num_domains;
-
-       munlock(info, max_domains * sizeof(xc_domaininfo_t));
-       return ret;
-}
-
-int xc_domain_getinfo(int handle, unsigned int domid, xc_domaininfo_t *info)
-{
-       int ret;
-       ret = xc_domain_getinfolist(handle, domid, 1, info);
-       if (ret != 1) {
-               xc_error_set("getinfo failed: domain %d: %s", domid, 
xc_error_get());
-               return -1;
-       }
-
-       /* If the requested domain didn't exist but there exists one with a 
-          higher domain ID, this will be returned. We consider this an error 
since
-          we only wanted info about a specific domain. */
-       if (info->domain != domid) {
-               xc_error_set("getinfo failed: domain %d nolonger exists", 
domid);
-               return -1;
-       }
-
-       return 0;
-}
-
-int xc_domain_setmaxmem(int handle, unsigned int domid, unsigned int max_memkb)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_max_mem, domid);
-       domctl.u.max_mem.max_memkb = max_memkb;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "set max memory to %u", max_memkb);
-       return ret;
-}
-
-int xc_domain_set_memmap_limit(int handle, unsigned int domid,
-                               unsigned long map_limitkb)
-{
-       int ret;
-       struct xen_foreign_memory_map fmap = {
-               .domid = domid,
-               .map = { .nr_entries = 1 }
-       };
-       struct e820entry e820 = {
-               .addr = 0,
-               .size = (uint64_t)map_limitkb << 10,
-               .type = E820_RAM
-       };
-       DECLARE_HYPERCALL2(__HYPERVISOR_memory_op, XENMEM_set_memory_map, 
&fmap);
-
-       set_xen_guest_handle(fmap.map.buffer, &e820);
-
-       if (mlock(&fmap, sizeof(fmap)) != 0) {
-               xc_error_set("set_memmap_limit failed: mlock failed: %s",
-                            strerror(errno));
-               return -1;
-       }
-
-       if (mlock(&e820, sizeof(e820)) != 0) {
-               xc_error_set("set_memmap_limit failed: mlock failed: %s",
-                            strerror(errno));
-               munlock(&fmap, sizeof(fmap));
-               return -1;
-       }
-
-       ret = do_xen_hypercall(handle, &hypercall);
-       if (ret)
-               xc_error_hypercall(hypercall, ret);
-
-       munlock(&e820, sizeof(e820));
-       munlock(&fmap, sizeof(fmap));
-       return ret;
-}
-
-int xc_domain_set_time_offset(int handle, unsigned int domid, int time_offset)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_settimeoffset, domid);
-       domctl.u.settimeoffset.time_offset_seconds = time_offset;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "set time offset %d", time_offset);
-       return ret;
-}
-
-int xc_domain_memory_increase_reservation(int handle, unsigned int domid,
-                                          unsigned long nr_extents,
-                                          unsigned int extent_order,
-                                          unsigned int address_bits,
-                                          xen_pfn_t *extent_start)
-{
-       int ret;
-       struct xen_memory_reservation reservation = {
-               .nr_extents   = nr_extents,
-               .extent_order = extent_order,
-               .COMPAT_FIELD_ADDRESS_BITS = address_bits,
-               .domid        = domid
-       };
-
-       set_xen_guest_handle(reservation.extent_start, extent_start);
-
-       ret = do_memctl_reservation(handle, XENMEM_increase_reservation,
-                                   &reservation);
-       if (ret != nr_extents) {
-               xc_error_dom_set(domid, "increase reservation to %lu",
-                                nr_extents);
-               return (ret >= 0) ? -1 : ret;
-       }
-       return 0;
-}
-
-int xc_domain_memory_decrease_reservation(int handle, unsigned int domid,
-                                          unsigned long nr_extents,
-                                          unsigned int extent_order,
-                                          unsigned int address_bits,
-                                          xen_pfn_t *extent_start)
-{
-       int ret;
-       struct xen_memory_reservation reservation = {
-               .nr_extents   = nr_extents,
-               .extent_order = extent_order,
-               .COMPAT_FIELD_ADDRESS_BITS = 0,
-               .domid        = domid
-       };
-
-       set_xen_guest_handle(reservation.extent_start, extent_start);
-       if (!extent_start) {
-               xc_error_set("decrease reservation: extent start is NULL");
-               return -EINVAL;
-       }
-
-       ret = do_memctl_reservation(handle, XENMEM_decrease_reservation,
-                                   &reservation);
-       if (ret < nr_extents) {
-               xc_error_dom_set(domid, "decrease reservation to %lu",
-                                nr_extents);
-               return (ret >= 0) ? -1 : ret;
-       }
-       return 0;
-}
-
-int xc_domain_memory_populate_physmap(int handle, unsigned int domid,
-                                      unsigned long nr_extents,
-                                      unsigned int extent_order,
-                                      unsigned int address_bits,
-                                      xen_pfn_t *extent_start)
-{
-       int ret;
-       struct xen_memory_reservation reservation = {
-               .nr_extents   = nr_extents,
-               .extent_order = extent_order,
-               .COMPAT_FIELD_ADDRESS_BITS = address_bits,
-               .domid        = domid
-       };
-
-       set_xen_guest_handle(reservation.extent_start, extent_start);
-       ret = do_memctl_reservation(handle, XENMEM_populate_physmap,
-                                   &reservation);
-       if (ret < nr_extents) {
-               xc_error_dom_set(domid, "populate physmap");
-               return (ret >= 0) ? -1 : ret;
-       }
-       return 0;
-}
-
-int xc_domain_setvmxassist(int handle, unsigned int domid, int use_vmxassist)
-{
-       int ret = 0;
-#ifdef XEN_DOMCTL_setvmxassist
-       DECLARE_DOMCTL(XEN_DOMCTL_setvmxassist, domid);
-       domctl.u.setvmxassist.use_vmxassist = use_vmxassist;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret)
-               xc_error_dom_set(domid, "setting vmxassist to %d",
-                                use_vmxassist);
-#endif
-       return ret;
-}
-
-int xc_domain_max_vcpus(int handle, unsigned int domid, unsigned int max)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_max_vcpus, domid);
-       domctl.u.max_vcpus.max = max;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret)
-               xc_error_dom_set(domid, "setting max vcpus to %d", max);
-       return ret;
-}
-
-int xc_domain_sethandle(int handle, unsigned int domid,
-                        xen_domain_handle_t dhandle)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_setdomainhandle, domid);
-       memcpy(domctl.u.setdomainhandle.handle, dhandle, 
sizeof(xen_domain_handle_t));
-
-       ret = do_domctl(handle, &domctl);
-       if (ret)
-               xc_error_dom_set(domid, "set handle");
-       return ret;
-}
-
-int xc_vcpu_getinfo(int handle, unsigned int domid, unsigned int vcpu,
-                    xc_vcpuinfo_t *info)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_getvcpuinfo, domid);
-       domctl.u.getvcpuinfo.vcpu = vcpu;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0) {
-               xc_error_dom_set(domid, "vcpu %u getinfo", vcpu);
-               return ret;
-       }
-       memcpy(info, &domctl.u.getvcpuinfo, sizeof(*info));
-       return ret;
-}
-
-int xc_domain_ioport_permission(int handle, unsigned int domid,
-                                unsigned int first_port, unsigned int nr_ports,
-                                unsigned int allow_access)
-{
-       DECLARE_DOMCTL(XEN_DOMCTL_ioport_permission, domid);
-       domctl.u.ioport_permission.first_port = first_port;
-       domctl.u.ioport_permission.nr_ports = nr_ports;
-       domctl.u.ioport_permission.allow_access = allow_access;
-
-       return do_domctl(handle, &domctl);
-}
-
-int xc_vcpu_getcontext(int handle, unsigned int domid,
-                       unsigned int vcpu, vcpu_guest_context_any_t *ctxt)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_getvcpucontext, domid);
-       domctl.u.vcpucontext.vcpu = vcpu;
-       set_xen_guest_handle(domctl.u.vcpucontext.ctxt, &ctxt->c);
-
-       if (mlock(ctxt, sizeof(*ctxt)) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -1;
-       }
-
-       ret = do_domctl(handle, &domctl);
-       if (ret)
-               xc_error_dom_set(domid, "vcpu %u getcontext", vcpu);
-       munlock(ctxt, sizeof(*ctxt));
-       return ret;
-}
-
-int xc_vcpu_setcontext(int handle, unsigned int domid,
-                       unsigned int vcpu, vcpu_guest_context_any_t *ctxt)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_setvcpucontext, domid);
-       domctl.u.vcpucontext.vcpu = vcpu;
-       set_xen_guest_handle(domctl.u.vcpucontext.ctxt, &ctxt->c);
-
-       if (mlock(ctxt, sizeof(*ctxt)) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -1;
-       }
-
-       ret = do_domctl(handle, &domctl);
-       if (ret)
-               xc_error_dom_set(domid, "vcpu %u setcontext", vcpu);
-
-       munlock(ctxt, sizeof(*ctxt));
-       return ret;
-}
-
-int xc_domain_irq_permission(int handle, unsigned int domid,
-                             unsigned char pirq, unsigned char allow_access)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_irq_permission, domid);
-       domctl.u.irq_permission.pirq = pirq;
-       domctl.u.irq_permission.allow_access = allow_access;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret)
-               xc_error_dom_set(domid, "irq permission %u to %u",
-                                pirq, allow_access);
-       return ret;
-}
-
-int xc_domain_iomem_permission(int handle, unsigned int domid,
-                               unsigned long first_mfn, unsigned long nr_mfns,
-                               unsigned char allow_access)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_iomem_permission, domid);
-       domctl.u.iomem_permission.first_mfn = first_mfn;
-       domctl.u.iomem_permission.nr_mfns = nr_mfns;
-       domctl.u.iomem_permission.allow_access = allow_access;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret)
-               xc_error_dom_set(domid, "iomem permission [%lu, %lu] to %u",
-                                first_mfn, first_mfn + nr_mfns, allow_access);
-       return ret;
-}
-
-long long xc_domain_get_cpu_usage(int handle, unsigned int domid,
-                                  unsigned int vcpu)
-{
-       DECLARE_DOMCTL(XEN_DOMCTL_getvcpuinfo, domid);
-       domctl.u.getvcpuinfo.vcpu = vcpu;
-
-       if (do_domctl(handle, &domctl) < 0) {
-               xc_error_dom_set(domid, "get cpu %d usage", vcpu);
-               return -1;
-       }
-       return domctl.u.getvcpuinfo.cpu_time;
-}
-
-void *xc_map_foreign_range(int handle, unsigned int domid,
-                           int size, int prot, unsigned long mfn)
-{
-       privcmd_mmap_entry_t entry = {
-               .mfn = mfn,
-               .npages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT,
-       };
-       privcmd_mmap_t ioctlx = {
-               .num = 1,
-               .dom = domid,
-               .entry = &entry,
-       };
-       void *addr;
-
-       addr = do_mmap(NULL, size, prot, MAP_SHARED, handle, 0);
-       if (addr == MAP_FAILED) {
-               xc_error_set("mmap failed: %s", strerror(errno));
-               xc_error_dom_set(domid, "map foreign range [%lx,%lx] prot %u",
-                                mfn, mfn + size, prot);
-               return NULL;
-       }
-       entry.va = (unsigned long) addr;
-       if (do_ioctl(handle, IOCTL_PRIVCMD_MMAP, &ioctlx) < 0) {
-               xc_error_set("ioctl failed: %s", strerror(errno));
-               xc_error_dom_set(domid, "map foreign range [%lx,%lx] prot %u",
-                                mfn, mfn + size, prot);
-               munmap(addr, size);
-               return NULL;
-       }
-       return addr;
-}
-
-int xc_map_foreign_ranges(int handle, unsigned int domid,
-                          privcmd_mmap_entry_t *entries, int nr)
-{
-       privcmd_mmap_t ioctlx = {
-               .num = nr,
-               .dom = domid,
-               .entry = entries,
-       };
-       int ret;
-
-       ret = do_ioctl(handle, IOCTL_PRIVCMD_MMAP, &ioctlx);
-       if (ret < 0) {
-               xc_error_set("ioctl failed: %s", strerror(errno));
-               xc_error_dom_set(domid, "map foreign ranges");
-               return -1;
-       }
-       return ret;
-}
-
-int xc_readconsolering(int handle, char **pbuffer,
-                       unsigned int *pnr_chars, int clear)
-{
-       int ret;
-       DECLARE_SYSCTL(XEN_SYSCTL_readconsole);
-       char *buffer = *pbuffer;
-       unsigned int nr_chars = *pnr_chars;
-
-       set_xen_guest_handle(sysctl.u.readconsole.buffer, buffer);
-       sysctl.u.readconsole.count = nr_chars;
-       sysctl.u.readconsole.clear = clear;
-
-       if (mlock(buffer, nr_chars) != 0) {
-               xc_error_set("read console ring: mlock failed: %s",
-                            strerror(errno));
-               return -1;
-       }
-
-       ret = do_sysctl(handle, &sysctl);
-       if (ret != 0)
-               xc_error_set("read console ring failed: %s", xc_error_get());
-       else
-               *pnr_chars = sysctl.u.readconsole.count;
-
-       munlock(buffer, nr_chars);
-       return ret;
-}
-
-int xc_send_debug_keys(int handle, char *keys)
-{
-       int ret;
-       DECLARE_SYSCTL(XEN_SYSCTL_debug_keys);
-
-       set_xen_guest_handle(sysctl.u.debug_keys.keys, keys);
-       sysctl.u.debug_keys.nr_keys = strlen(keys);
-
-       if (mlock(keys, sysctl.u.debug_keys.nr_keys) != 0) {
-               xc_error_set("send debug keys: mlock failed: %s",
-                            strerror(errno));
-               return -1;
-       }
-
-       ret = do_sysctl(handle, &sysctl);
-       if (ret != 0)
-               xc_error_set("send debug keys: %s", xc_error_get());
-
-       munlock(keys, sysctl.u.debug_keys.nr_keys);
-       return ret;
-}
-
-int xc_physinfo(int handle, xc_physinfo_t *put_info)
-{
-       DECLARE_SYSCTL(XEN_SYSCTL_physinfo);
-       int ret;
-
-       ret = do_sysctl(handle, &sysctl);
-       if (ret) {
-               xc_error_set("physinfo failed: %s", xc_error_get());
-               return ret;
-       }
-       memcpy(put_info, &sysctl.u.physinfo, sizeof(*put_info));
-       return 0;
-}
-
-int xc_pcpu_info(
-       int handle, int max_cpus, xen_sysctl_cpuinfo_t *info, int *nr_cpus)
-{
-       DECLARE_SYSCTL(XEN_SYSCTL_getcpuinfo);
-       int ret;
-
-       sysctl.u.getcpuinfo.max_cpus = max_cpus;
-       set_xen_guest_handle(sysctl.u.getcpuinfo.info, info);
-
-       if (mlock(info, sizeof(*info) * max_cpus) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -1;
-       }
-
-       ret = do_sysctl(handle, &sysctl);
-       if (ret)
-               xc_error_set("pcpu info failed: %s", xc_error_get());
-       else if (ret == 0 && nr_cpus)
-               *nr_cpus = sysctl.u.getcpuinfo.nr_cpus;
-       munlock(info, sizeof(*info) * max_cpus);
-       return ret;
-}
-
-int xc_sched_id(int handle, int *sched_id)
-{
-       DECLARE_SYSCTL(XEN_SYSCTL_sched_id);
-       int ret;
-
-       ret = do_sysctl(handle, &sysctl);
-       if (ret) {
-               xc_error_set("sched id failed: %s", xc_error_get());
-               return ret;
-       }
-       *sched_id = sysctl.u.sched_id.sched_id;
-       return 0;
-}
-
-int xc_version(int handle, int cmd, void *arg)
-{
-       int argsize;
-       int ret;
-       DECLARE_HYPERCALL2(__HYPERVISOR_xen_version, cmd, arg);
-
-       switch (cmd) {
-       case XENVER_extraversion:
-               argsize = sizeof(xen_extraversion_t); break;
-       case XENVER_compile_info:
-               argsize = sizeof(xen_compile_info_t); break;
-       case XENVER_capabilities:
-               argsize = sizeof(xen_capabilities_info_t); break;
-       case XENVER_changeset:
-               argsize = sizeof(xen_changeset_info_t); break;
-       case XENVER_platform_parameters:
-               argsize = sizeof(xen_platform_parameters_t); break;
-       case XENVER_version:
-               argsize = 0; break;
-       default:
-               xc_error_set("version: unknown command");
-               return -1;
-       }
-       if (argsize && mlock(arg, argsize) == -1) {
-               xc_error_set("version: mlock failed: %s", strerror(errno));
-               return -ENOMEM;
-       }
-
-       ret = do_xen_hypercall(handle, &hypercall);
-       if (ret)
-               xc_error_hypercall(hypercall, ret);
-
-       if (argsize)
-               munlock(arg, argsize);
-       return ret;
-}
-
-int xc_evtchn_alloc_unbound(int handle, unsigned int domid,
-                            unsigned int remote_domid)
-{
-       struct evtchn_alloc_unbound arg = {
-               .dom = domid,
-               .remote_dom = remote_domid,
-       };
-       int ret;
-
-       ret = do_evtchnctl(handle, EVTCHNOP_alloc_unbound, &arg, sizeof(arg));
-       if (ret) {
-               xc_error_dom_set(domid, "alloc unbound evtchn to %d",
-                                remote_domid);
-               return ret;
-       }
-       return arg.port;
-}
-
-int xc_evtchn_reset(int handle, unsigned int domid)
-{
-       struct evtchn_reset arg = {
-               .dom = domid,
-       };
-       int ret;
-
-       ret = do_evtchnctl(handle, EVTCHNOP_reset, &arg, sizeof(arg));
-       if (ret)
-               xc_error_dom_set(domid, "reset evtchn of %d", domid);
-       return ret;
-}
-
-int xc_sched_credit_domain_set(int handle, unsigned int domid,
-                               struct xen_domctl_sched_credit *sdom)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_scheduler_op, domid);
-       domctl.u.scheduler_op.sched_id = XEN_SCHEDULER_CREDIT;
-       domctl.u.scheduler_op.cmd = XEN_DOMCTL_SCHEDOP_putinfo;
-       domctl.u.scheduler_op.u.credit = *sdom;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "credit scheduler domain set");
-       return ret;
-}
-
-int xc_sched_credit_domain_get(int handle, unsigned int domid,
-                               struct xen_domctl_sched_credit *sdom)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_scheduler_op, domid);
-
-       domctl.u.scheduler_op.sched_id = XEN_SCHEDULER_CREDIT;
-       domctl.u.scheduler_op.cmd = XEN_DOMCTL_SCHEDOP_getinfo;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "credit scheduler domain get");
-       else
-               *sdom = domctl.u.scheduler_op.u.credit;
-       return ret;
-}
-
-int xc_shadow_allocation_get(int handle, unsigned int domid, uint32_t *mb)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_shadow_op, domid);
-
-       domctl.u.shadow_op.op = XEN_DOMCTL_SHADOW_OP_GET_ALLOCATION;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "shadow allocation get");
-       else
-               *mb = domctl.u.shadow_op.mb;
-       return ret;
-}
-
-int xc_shadow_allocation_set(int handle, unsigned int domid, uint32_t mb)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_shadow_op, domid);
-
-       domctl.u.shadow_op.op = XEN_DOMCTL_SHADOW_OP_SET_ALLOCATION;
-       domctl.u.shadow_op.mb = mb;
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "shadow allocation set");
-       return ret;
-}
-
-int xc_domain_get_pfn_list(int handle, unsigned int domid,
-                           uint64_t *pfn_array, unsigned long max_pfns)
-{
-       int ret;
-       DECLARE_DOMCTL(XEN_DOMCTL_getmemlist, domid);
-
-       domctl.u.getmemlist.max_pfns = max_pfns;
-       set_xen_guest_handle(domctl.u.getmemlist.buffer, pfn_array);
-
-       if (mlock(pfn_array, max_pfns * sizeof(xen_pfn_t)) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -1;
-       }
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "get pfn list");
-
-       munlock(pfn_array, max_pfns * sizeof(xen_pfn_t));
-       return (ret < 0) ? ret : domctl.u.getmemlist.num_pfns;
-}
-
-#define MARSHALL_BDF(d,b,s,f) \
-       (((b) & 0xff) << 16 | ((s) & 0x1f) << 11 | ((f) & 0x7) << 8)
-
-int xc_domain_assign_device(int handle, unsigned int domid,
-                            int domain, int bus, int slot, int func)
-{
-       int ret = -EBADF;
-#ifdef XEN_DOMCTL_assign_device
-       DECLARE_DOMCTL(XEN_DOMCTL_assign_device, domid);
-
-       domctl.u.assign_device.machine_bdf = MARSHALL_BDF(domain, bus, slot, 
func);
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "assign device");
-#endif
-       return ret;
-}
-
-int xc_domain_deassign_device(int handle, unsigned int domid,
-                              int domain, int bus, int slot, int func)
-{
-       int ret = -EBADF;
-#ifdef XEN_DOMCTL_deassign_device
-       DECLARE_DOMCTL(XEN_DOMCTL_deassign_device, domid);
-
-       domctl.u.assign_device.machine_bdf = MARSHALL_BDF(domain, bus, slot, 
func);
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "deassign device");
-#endif
-       return ret;
-}
-
-int xc_domain_test_assign_device(int handle, unsigned int domid,
-                                 int domain, int bus, int slot, int func)
-{
-       int ret = -EBADF;
-#ifdef XEN_DOMCTL_test_assign_device
-       DECLARE_DOMCTL(XEN_DOMCTL_test_assign_device, domid);
-       domctl.u.assign_device.machine_bdf = MARSHALL_BDF(domain, bus, slot, 
func);
-
-       ret = do_domctl(handle, &domctl);
-       if (ret < 0)
-               xc_error_dom_set(domid, "test assign device");
-#endif
-       return ret;
-}
-
-int xc_domain_watchdog(int handle, int id, uint32_t timeout)
-{
-       int ret = -EBADF;
-#ifdef SCHEDOP_watchdog
-       sched_watchdog_t arg = {
-               .id = (uint32_t) id,
-               .timeout = timeout,
-       };
-       DECLARE_HYPERCALL2(__HYPERVISOR_sched_op, SCHEDOP_watchdog, &arg);
-
-       if (mlock(&arg, sizeof(arg)) != 0) {
-               xc_error_set("mlock failed: %s", strerror(errno));
-               return -1;
-       }
-
-       ret = do_xen_hypercall(handle, &hypercall);
-       if (ret < 0) {
-               xc_error_hypercall(hypercall, ret);
-       }
-       munlock(&arg, sizeof(arg));
-#endif
-       return ret;
-}
-
-int xc_domain_set_machine_address_size(int xc, uint32_t domid, unsigned int 
width)
-{
-       DECLARE_DOMCTL(XEN_DOMCTL_set_machine_address_size, domid);
-       int rc;
-
-       domctl.u.address_size.size = width;
-       rc = do_domctl(xc, &domctl);
-       if (rc != 0)
-               xc_error_dom_set(domid, "set machine address size");
-
-       return rc;
-}
-
-int xc_domain_get_machine_address_size(int xc, uint32_t domid)
-{
-       DECLARE_DOMCTL(XEN_DOMCTL_get_machine_address_size, domid);
-       int rc;
-
-       rc = do_domctl(xc, &domctl);
-       if (rc != 0)
-               xc_error_dom_set(domid, "get machine address size");
-       return rc == 0 ? domctl.u.address_size.size : rc;
-}
-
-#include "xc_cpuid.h"
-int xc_domain_cpuid_set(int xc, unsigned int domid, int hvm,
-                        uint32_t input, uint32_t oinput,
-                        char *config[4], char *config_out[4])
-{
-       int ret = -EBADF;
-#ifdef XEN_DOMCTL_set_cpuid
-       DECLARE_DOMCTL(XEN_DOMCTL_set_cpuid, domid);
-       uint32_t regs[4], polregs[4];
-       int i, j;
-
-       xc_cpuid(input, oinput, regs);
-       memcpy(polregs, regs, sizeof(regs));
-       do_cpuid_policy(xc, domid, hvm, input, polregs);
-
-       for (i = 0; i < 4; i++) {
-               if (!config[i]) {
-                       regs[i] = polregs[i];
-                       continue;
-               }
-               
-               for (j = 0; j < 32; j++) {
-                       unsigned char val, polval;
-
-                       val = !!((regs[i] & (1U << (31 - j))));
-                       polval = !!((regs[i] & (1U << (31 - j))));
-
-                       switch (config[i][j]) {
-                       case '1': val = 1; break; /* force to true */
-                       case '0': val = 0; break; /* force to false */
-                       case 'x': val = polval; break;
-                       case 'k': case 's': break;
-                       default:
-                               xc_error_dom_set(domid, "domain cpuid set: 
invalid config");
-                               ret = -EINVAL;
-                               goto out;
-                       }
-
-                       if (val)
-                               set_bit(31 - j, regs[i]);
-                       else
-                               clear_bit(31 - j, regs[i]);
-
-                       if (config_out && config_out[i]) {
-                               config_out[i][j] = (config[i][j] == 's')
-                                                  ? '0' + val
-                                                  : config[i][j];
-                       }
-               }
-       }
-
-       domctl.u.cpuid.input[0] = input;
-       domctl.u.cpuid.input[1] = oinput;
-       domctl.u.cpuid.eax = regs[0];
-       domctl.u.cpuid.ebx = regs[1];
-       domctl.u.cpuid.ecx = regs[2];
-       domctl.u.cpuid.edx = regs[3];
-       ret = do_domctl(xc, &domctl);
-       if (ret) {
-               xc_error_dom_set(domid, "cpuid set");
-               goto out;
-       }
-out:
-#endif
-       return ret;
-}
-
-int xc_domain_cpuid_apply(int xc, unsigned int domid, int hvm)
-{
-       int ret = -EBADF;
-#ifdef XEN_DOMCTL_set_cpuid
-       uint32_t regs[4], base_max, ext_max, eax, ecx;
-
-       /* determinate cpuid range */
-       xc_cpuid(0, 0, regs);
-       base_max = MIN(regs[0], DEF_MAX_BASE);
-       xc_cpuid(0x80000000, 0, regs);
-       ext_max = MIN(regs[0], DEF_MAX_EXT);
-
-       eax = ecx = 0;
-       while (!(eax & 0x80000000) || (eax <= ext_max)) {
-               xc_cpuid(eax, ecx, regs);
-
-               do_cpuid_policy(xc, domid, hvm, eax, regs);
-               
-               if (regs[0] || regs[1] || regs[2] || regs[3]) {
-                       DECLARE_DOMCTL(XEN_DOMCTL_set_cpuid, domid);
-                       
-                       domctl.u.cpuid.input[0] = eax;
-                       domctl.u.cpuid.input[1] = (eax == 4) ? ecx : 
XEN_CPUID_INPUT_UNUSED;
-                       domctl.u.cpuid.eax = regs[0];
-                       domctl.u.cpuid.ebx = regs[1];
-                       domctl.u.cpuid.ecx = regs[2];
-                       domctl.u.cpuid.edx = regs[3];
-
-                       ret = do_domctl(xc, &domctl);
-                       if (ret) {
-                               xc_error_dom_set(domid, "cpuid apply");
-                               goto out;
-                       }
-
-                       /* we repeat when doing node 4 (cache descriptor 
leaves) increasing ecx 
-                        * until the cpuid eax value masked is 0 */
-                       if (eax == 4) {
-                               ecx++;
-                               if ((regs[0] & 0x1f) != 0)
-                                       continue;
-                               ecx = 0;
-                       }
-               }
-
-               eax++;
-               if (!(eax & 0x80000000) && (eax > base_max))
-                       eax = 0x80000000;
-       }
-       ret = 0;
-out:
-#endif
-       return ret;
-}
-
-/*
- * return 1 on checking success 
- *        0 on checking failure
- *        -EINVAL if the config contains unknown character
- */
-int xc_cpuid_check(uint32_t input, uint32_t optsubinput,
-                   char *config[4], char *config_out[4])
-{
-       int ret = -EBADF;
-#ifdef XEN_DOMCTL_set_cpuid
-       uint32_t regs[4];
-       int i, j;
-
-       xc_cpuid(input, optsubinput, regs);
-
-       ret = 1;
-       for (i = 0; i < 4; i++) {
-               if (!config[i])
-                       continue;
-               for (j = 0; j < 32; j++) {
-                       unsigned char val;
-
-                       val = !!((regs[i] & (1U << (31 - j))));
-
-                       switch (config[i][j]) {
-                       case '1': if (!val) { ret = 0; goto out; }; break;
-                       case '0': if (val) { ret = 0; goto out; }; break;
-                       case 'x': case 's': break;
-                       default:
-                               xc_error_set("cpuid check: invalid config");
-                               ret = -EINVAL;
-                               goto out;
-                       }
-
-                       if (config_out && config_out[i]) {
-                               config_out[i][j] = (config[i][j] == 's')
-                                                  ? '0' + val
-                                                  : config[i][j];
-                       }
-               }
-       } 
-out:
-#endif
-       return ret;
-}
-
-#ifndef HVM_PARAM_HPET_ENABLED
-#define HVM_PARAM_HPET_ENABLED 11
-#endif
-
-#ifndef HVM_PARAM_ACPI_S_STATE
-#define HVM_PARAM_ACPI_S_STATE 14
-#endif
-
-#ifndef HVM_PARAM_VPT_ALIGN
-#define HVM_PARAM_VPT_ALIGN 16
-#endif
-
-int xc_domain_send_s3resume(int handle, unsigned int domid)
-{
-       return xc_set_hvm_param(handle, domid, HVM_PARAM_ACPI_S_STATE, 0);
-}
-
-int xc_domain_set_timer_mode(int handle, unsigned int domid, int mode)
-{
-       return xc_set_hvm_param(handle, domid,
-                               HVM_PARAM_TIMER_MODE, (unsigned long) mode);
-}
-
-int xc_domain_set_hpet(int handle, unsigned int domid, int hpet)
-{
-       return xc_set_hvm_param(handle, domid, HVM_PARAM_HPET_ENABLED, 
(unsigned long) hpet);
-}
-
-int xc_domain_set_vpt_align(int handle, unsigned int domid, int vpt_align)
-{
-       return xc_set_hvm_param(handle, domid, HVM_PARAM_HPET_ENABLED, 
(unsigned long) vpt_align);
-}
-
-int xc_domain_get_acpi_s_state(int handle, unsigned int domid)
-{
-       int ret;
-       unsigned long value;
-
-       ret = xc_get_hvm_param(handle, domid, HVM_PARAM_ACPI_S_STATE, &value);
-       if (ret != 0)
-               xc_error_dom_set(domid, "get acpi s-state");
-       return value;
-}
diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/libs/xc/xc_stubs.c
--- a/tools/ocaml/libs/xc/xc_stubs.c    Thu Nov 18 05:46:26 2010 -0500
+++ b/tools/ocaml/libs/xc/xc_stubs.c    Thu Nov 18 05:46:26 2010 -0500
@@ -16,6 +16,7 @@
 
 #define _XOPEN_SOURCE 600
 #include <stdlib.h>
+#include <errno.h>
 
 #define CAML_NAME_SPACE
 #include <caml/alloc.h>
@@ -28,7 +29,7 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "xc.h"
+#include <xenctrl.h>
 
 #include "mmap_stubs.h"
 
@@ -36,7 +37,7 @@
 #define PAGE_SIZE               (1UL << PAGE_SHIFT)
 #define PAGE_MASK               (~(PAGE_SIZE-1))
 
-#define _H(__h) (Int_val(__h))
+#define _H(__h) ((xc_interface *)(__h))
 #define _D(__d) ((uint32_t)Int_val(__d))
 
 #define Val_none (Val_int(0))
@@ -50,12 +51,23 @@
        i1 = (uint32_t) Int64_val(Field(input, 0)); \
        i2 = ((Field(input, 1) == Val_none) ? 0xffffffff : (uint32_t) 
Int64_val(Field(Field(input, 1), 0)));
 
-/**
- * Convert the given number of pages to an amount in MiB, rounded up.
- */
-void failwith_xc(void)
+#define ERROR_STRLEN 1024
+void failwith_xc(xc_interface *xch)
 {
-       caml_raise_with_string(*caml_named_value("xc.error"), xc_error_get());
+       static char error_str[ERROR_STRLEN];
+       if (xch) {
+               const xc_error *error = xc_get_last_error(xch);
+               if (error->code == XC_ERROR_NONE)
+                       snprintf(error_str, ERROR_STRLEN, "%d: %s", errno, 
strerror(errno));
+               else
+                       snprintf(error_str, ERROR_STRLEN, "%d: %s: %s",
+                                error->code,
+                                xc_error_code_to_desc(error->code),
+                                error->message);
+       } else {
+               snprintf(error_str, ERROR_STRLEN, "Unable to open XC 
interface");
+       }
+       caml_raise_with_string(*caml_named_value("xc.error"), error_str);
 }
 
 CAMLprim value stub_sizeof_core_header(value unit)
@@ -101,11 +113,11 @@ CAMLprim value stub_marshall_core_header
 
 CAMLprim value stub_xc_interface_open(void)
 {
-        int handle;
-        handle = xc_interface_open();
-        if (handle == -1)
-               failwith_xc();
-        return Val_int(handle);
+        xc_interface *xch;
+        xch = xc_interface_open(NULL, NULL, XC_OPENFLAG_NON_REENTRANT);
+        if (xch == NULL)
+               failwith_xc(NULL);
+        return (value)xch;
 }
 
 
@@ -116,20 +128,15 @@ CAMLprim value stub_xc_interface_open_fa
 
 CAMLprim value stub_xc_using_injection(void)
 {
-       if (xc_using_injection ()){
-               return Val_int(1);
-       } else {
-               return Val_int(0);
-       }
+       return Val_int(0);
 }
 
-CAMLprim value stub_xc_interface_close(value xc_handle)
+CAMLprim value stub_xc_interface_close(value xch)
 {
-       CAMLparam1(xc_handle);
+       CAMLparam1(xch);
 
-       int handle = _H(xc_handle);
        // caml_enter_blocking_section();
-       xc_interface_close(handle);
+       xc_interface_close(_H(xch));
        // caml_leave_blocking_section();
 
        CAMLreturn(Val_unit);
@@ -140,16 +147,15 @@ static int domain_create_flag_table[] = 
        XEN_DOMCTL_CDF_hap,
 };
 
-CAMLprim value stub_xc_domain_create(value xc_handle, value ssidref,
+CAMLprim value stub_xc_domain_create(value xch, value ssidref,
                                      value flags, value handle)
 {
-       CAMLparam4(xc_handle, ssidref, flags, handle);
+       CAMLparam4(xch, ssidref, flags, handle);
 
        uint32_t domid = 0;
        xen_domain_handle_t h = { 0 };
        int result;
        int i;
-       int c_xc_handle = _H(xc_handle);
        uint32_t c_ssidref = Int32_val(ssidref);
        unsigned int c_flags = 0;
        value l;
@@ -167,46 +173,32 @@ CAMLprim value stub_xc_domain_create(val
        }
 
        // caml_enter_blocking_section();
-       result = xc_domain_create(c_xc_handle, c_ssidref, h, c_flags, &domid);
+       result = xc_domain_create(_H(xch), c_ssidref, h, c_flags, &domid);
        // caml_leave_blocking_section();
 
        if (result < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_int(domid));
 }
 
-CAMLprim value stub_xc_domain_setvmxassist(value xc_handle, value domid,
-                                           value use_vmxassist)
+CAMLprim value stub_xc_domain_max_vcpus(value xch, value domid,
+                                        value max_vcpus)
 {
-       CAMLparam3(xc_handle, domid, use_vmxassist);
+       CAMLparam3(xch, domid, max_vcpus);
        int r;
 
-       r = xc_domain_setvmxassist(_H(xc_handle), _D(domid),
-                                  Bool_val(use_vmxassist));
+       r = xc_domain_max_vcpus(_H(xch), _D(domid), Int_val(max_vcpus));
        if (r)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_max_vcpus(value xc_handle, value domid,
-                                        value max_vcpus)
+
+value stub_xc_domain_sethandle(value xch, value domid, value handle)
 {
-       CAMLparam3(xc_handle, domid, max_vcpus);
-       int r;
-
-       r = xc_domain_max_vcpus(_H(xc_handle), _D(domid), Int_val(max_vcpus));
-       if (r)
-               failwith_xc();
-
-       CAMLreturn(Val_unit);
-}
-
-
-value stub_xc_domain_sethandle(value xc_handle, value domid, value handle)
-{
-       CAMLparam3(xc_handle, domid, handle);
+       CAMLparam3(xch, domid, handle);
        xen_domain_handle_t h = { 0 };
        int i;
 
@@ -217,57 +209,65 @@ value stub_xc_domain_sethandle(value xc_
                h[i] = Int_val(Field(handle, i)) & 0xff;
        }
 
-       i = xc_domain_sethandle(_H(xc_handle), _D(domid), h);
+       i = xc_domain_sethandle(_H(xch), _D(domid), h);
        if (i)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_unit);
 }
 
-static value dom_op(value xc_handle, value domid, int (*fn)(int, uint32_t))
+static value dom_op(value xch, value domid, int (*fn)(xc_interface *, 
uint32_t))
 {
-       CAMLparam2(xc_handle, domid);
+       CAMLparam2(xch, domid);
 
-       int c_xc_handle = _H(xc_handle);
        uint32_t c_domid = _D(domid);
 
        // caml_enter_blocking_section();
-       int result = fn(c_xc_handle, c_domid);
+       int result = fn(_H(xch), c_domid);
        // caml_leave_blocking_section();
         if (result)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_pause(value xc_handle, value domid)
+CAMLprim value stub_xc_domain_pause(value xch, value domid)
 {
-       return dom_op(xc_handle, domid, xc_domain_pause);
+       return dom_op(xch, domid, xc_domain_pause);
 }
 
 
-CAMLprim value stub_xc_domain_unpause(value xc_handle, value domid)
+CAMLprim value stub_xc_domain_unpause(value xch, value domid)
 {
-       return dom_op(xc_handle, domid, xc_domain_unpause);
+       return dom_op(xch, domid, xc_domain_unpause);
 }
 
-CAMLprim value stub_xc_domain_destroy(value xc_handle, value domid)
+CAMLprim value stub_xc_domain_destroy(value xch, value domid)
 {
-       return dom_op(xc_handle, domid, xc_domain_destroy);
+       return dom_op(xch, domid, xc_domain_destroy);
 }
 
-CAMLprim value stub_xc_domain_resume_fast(value xc_handle, value domid)
+CAMLprim value stub_xc_domain_resume_fast(value xch, value domid)
 {
-       return dom_op(xc_handle, domid, xc_domain_resume_fast);
+       CAMLparam2(xch, domid);
+
+       uint32_t c_domid = _D(domid);
+
+       // caml_enter_blocking_section();
+       int result = xc_domain_resume(_H(xch), c_domid, 1);
+       // caml_leave_blocking_section();
+        if (result)
+               failwith_xc(_H(xch));
+       CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_shutdown(value handle, value domid, value reason)
+CAMLprim value stub_xc_domain_shutdown(value xch, value domid, value reason)
 {
-       CAMLparam3(handle, domid, reason);
+       CAMLparam3(xch, domid, reason);
        int ret;
 
-       ret = xc_domain_shutdown(_H(handle), _D(domid), Int_val(reason));
+       ret = xc_domain_shutdown(_H(xch), _D(domid), Int_val(reason));
        if (ret < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_unit);
 }
@@ -307,12 +307,12 @@ static value alloc_domaininfo(xc_domaini
        CAMLreturn(result);
 }
 
-CAMLprim value stub_xc_domain_getinfolist(value xc_handle, value first_domain, 
value nb)
+CAMLprim value stub_xc_domain_getinfolist(value xch, value first_domain, value 
nb)
 {
-       CAMLparam3(xc_handle, first_domain, nb);
+       CAMLparam3(xch, first_domain, nb);
        CAMLlocal2(result, temp);
        xc_domaininfo_t * info;
-       int i, ret, toalloc, c_xc_handle, retval;
+       int i, ret, toalloc, retval;
        unsigned int c_max_domains;
        uint32_t c_first_domain;
 
@@ -324,17 +324,16 @@ CAMLprim value stub_xc_domain_getinfolis
 
        result = temp = Val_emptylist;
 
-       c_xc_handle = _H(xc_handle);
        c_first_domain = _D(first_domain);
        c_max_domains = Int_val(nb);
        // caml_enter_blocking_section();
-       retval = xc_domain_getinfolist(c_xc_handle, c_first_domain,
+       retval = xc_domain_getinfolist(_H(xch), c_first_domain,
                                       c_max_domains, info);
        // caml_leave_blocking_section();
 
        if (retval < 0) {
                free(info);
-               failwith_xc();
+               failwith_xc(_H(xch));
        }
        for (i = 0; i < retval; i++) {
                result = caml_alloc_small(2, Tag_cons);
@@ -349,37 +348,38 @@ CAMLprim value stub_xc_domain_getinfolis
        CAMLreturn(result);
 }
 
-CAMLprim value stub_xc_domain_getinfo(value xc_handle, value domid)
+CAMLprim value stub_xc_domain_getinfo(value xch, value domid)
 {
-       CAMLparam2(xc_handle, domid);
+       CAMLparam2(xch, domid);
        CAMLlocal1(result);
        xc_domaininfo_t info;
        int ret;
 
-       ret = xc_domain_getinfo(_H(xc_handle), _D(domid), &info);
-       if (ret != 0)
-               failwith_xc();
+       ret = xc_domain_getinfolist(_H(xch), _D(domid), 1, &info);
+       if (ret != 1)
+               failwith_xc(_H(xch));
+       if (info.domain != _D(domid))
+               failwith_xc(_H(xch));
 
        result = alloc_domaininfo(&info);
        CAMLreturn(result);
 }
 
-CAMLprim value stub_xc_vcpu_getinfo(value xc_handle, value domid, value vcpu)
+CAMLprim value stub_xc_vcpu_getinfo(value xch, value domid, value vcpu)
 {
-       CAMLparam3(xc_handle, domid, vcpu);
+       CAMLparam3(xch, domid, vcpu);
        CAMLlocal1(result);
        xc_vcpuinfo_t info;
        int retval;
 
-       int c_xc_handle = _H(xc_handle);
        uint32_t c_domid = _D(domid);
        uint32_t c_vcpu = Int_val(vcpu);
        // caml_enter_blocking_section();
-       retval = xc_vcpu_getinfo(c_xc_handle, c_domid,
+       retval = xc_vcpu_getinfo(_H(xch), c_domid,
                                 c_vcpu, &info);
        // caml_leave_blocking_section();
        if (retval < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        result = caml_alloc_tuple(5);
        Store_field(result, 0, Val_bool(info.online));
@@ -391,15 +391,15 @@ CAMLprim value stub_xc_vcpu_getinfo(valu
        CAMLreturn(result);
 }
 
-CAMLprim value stub_xc_vcpu_context_get(value xc_handle, value domid,
+CAMLprim value stub_xc_vcpu_context_get(value xch, value domid,
                                         value cpu)
 {
-       CAMLparam3(xc_handle, domid, cpu);
+       CAMLparam3(xch, domid, cpu);
        CAMLlocal1(context);
        int ret;
        vcpu_guest_context_any_t ctxt;
 
-       ret = xc_vcpu_getcontext(_H(xc_handle), _D(domid), Int_val(cpu), &ctxt);
+       ret = xc_vcpu_getcontext(_H(xch), _D(domid), Int_val(cpu), &ctxt);
 
        context = caml_alloc_string(sizeof(ctxt));
        memcpy(String_val(context), (char *) &ctxt.c, sizeof(ctxt.c));
@@ -407,75 +407,115 @@ CAMLprim value stub_xc_vcpu_context_get(
        CAMLreturn(context);
 }
 
-CAMLprim value stub_xc_vcpu_setaffinity(value xc_handle, value domid,
+static int get_cpumap_len(value xch, value cpumap)
+{
+       int ml_len = Wosize_val(cpumap);
+       int xc_len = xc_get_max_cpus(_H(xch));
+
+       if (ml_len < xc_len)
+               return ml_len;
+       else
+               return xc_len;
+}
+
+CAMLprim value stub_xc_vcpu_setaffinity(value xch, value domid,
                                         value vcpu, value cpumap)
 {
-       CAMLparam4(xc_handle, domid, vcpu, cpumap);
-       uint64_t c_cpumap;
+       CAMLparam4(xch, domid, vcpu, cpumap);
+       int i, len = get_cpumap_len(xch, cpumap);
+       xc_cpumap_t c_cpumap;
        int retval;
 
-       c_cpumap = Int64_val(cpumap);
-       retval = xc_vcpu_setaffinity(_H(xc_handle), _D(domid),
+       c_cpumap = xc_cpumap_alloc(_H(xch));
+       if (c_cpumap == NULL)
+               failwith_xc(_H(xch));
+
+       for (i=0; i<len; i++) {
+               if (Bool_val(Field(cpumap, i)))
+                       c_cpumap[i/8] |= i << (i&7);
+       }
+       retval = xc_vcpu_setaffinity(_H(xch), _D(domid),
                                     Int_val(vcpu), c_cpumap);
+       free(c_cpumap);
+
        if (retval < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_vcpu_getaffinity(value xc_handle, value domid,
+CAMLprim value stub_xc_vcpu_getaffinity(value xch, value domid,
                                         value vcpu)
 {
-       CAMLparam3(xc_handle, domid, vcpu);
+       CAMLparam3(xch, domid, vcpu);
        CAMLlocal1(ret);
-       uint64_t cpumap;
+       xc_cpumap_t c_cpumap;
+       int i, len = xc_get_max_cpus(_H(xch));
        int retval;
 
-       retval = xc_vcpu_getaffinity(_H(xc_handle), _D(domid),
-                                    Int_val(vcpu), &cpumap);
-       if (retval < 0)
-               failwith_xc();
-       ret = caml_copy_int64(cpumap);
+       c_cpumap = xc_cpumap_alloc(_H(xch));
+       if (c_cpumap == NULL)
+               failwith_xc(_H(xch));
+
+       retval = xc_vcpu_getaffinity(_H(xch), _D(domid),
+                                    Int_val(vcpu), c_cpumap);
+       free(c_cpumap);
+
+       if (retval < 0) {
+               free(c_cpumap);
+               failwith_xc(_H(xch));
+       }
+
+       ret = caml_alloc(len, 0);
+
+       for (i=0; i<len; i++) {
+               if (c_cpumap[i%8] & 1 << (i&7))
+                       Store_field(ret, i, Val_true);
+               else
+                       Store_field(ret, i, Val_false);
+       }
+
+       free(c_cpumap);
+
        CAMLreturn(ret);
 }
 
-CAMLprim value stub_xc_sched_id(value xc_handle)
+CAMLprim value stub_xc_sched_id(value xch)
 {
-       CAMLparam1(xc_handle);
+       CAMLparam1(xch);
        int sched_id;
 
-       if (xc_sched_id(_H(xc_handle), &sched_id))
-               failwith_xc();
+       if (xc_sched_id(_H(xch), &sched_id))
+               failwith_xc(_H(xch));
        CAMLreturn(Val_int(sched_id));
 }
 
-CAMLprim value stub_xc_evtchn_alloc_unbound(value xc_handle,
+CAMLprim value stub_xc_evtchn_alloc_unbound(value xch,
                                             value local_domid,
                                             value remote_domid)
 {
-       CAMLparam3(xc_handle, local_domid, remote_domid);
+       CAMLparam3(xch, local_domid, remote_domid);
 
-       int c_xc_handle = _H(xc_handle);
        uint32_t c_local_domid = _D(local_domid);
        uint32_t c_remote_domid = _D(remote_domid);
 
        // caml_enter_blocking_section();
-       int result = xc_evtchn_alloc_unbound(c_xc_handle, c_local_domid,
+       int result = xc_evtchn_alloc_unbound(_H(xch), c_local_domid,
                                             c_remote_domid);
        // caml_leave_blocking_section();
 
        if (result < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_int(result));
 }
 
-CAMLprim value stub_xc_evtchn_reset(value handle, value domid)
+CAMLprim value stub_xc_evtchn_reset(value xch, value domid)
 {
-       CAMLparam2(handle, domid);
+       CAMLparam2(xch, domid);
        int r;
 
-       r = xc_evtchn_reset(_H(handle), _D(domid));
+       r = xc_evtchn_reset(_H(xch), _D(domid));
        if (r < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_unit);
 }
 
@@ -483,48 +523,47 @@ CAMLprim value stub_xc_evtchn_reset(valu
 #define RING_SIZE 32768
 static char ring[RING_SIZE];
 
-CAMLprim value stub_xc_readconsolering(value xc_handle)
+CAMLprim value stub_xc_readconsolering(value xch)
 {
        unsigned int size = RING_SIZE;
        char *ring_ptr = ring;
 
-       CAMLparam1(xc_handle);
-       int c_xc_handle = _H(xc_handle);
+       CAMLparam1(xch);
 
        // caml_enter_blocking_section();
-       int retval = xc_readconsolering(c_xc_handle, &ring_ptr, &size, 0);
+       int retval = xc_readconsolering(_H(xch), ring_ptr, &size, 0, 0, NULL);
        // caml_leave_blocking_section();
 
        if (retval)
-               failwith_xc();
+               failwith_xc(_H(xch));
        ring[size] = '\0';
        CAMLreturn(caml_copy_string(ring));
 }
 
-CAMLprim value stub_xc_send_debug_keys(value xc_handle, value keys)
+CAMLprim value stub_xc_send_debug_keys(value xch, value keys)
 {
-       CAMLparam2(xc_handle, keys);
+       CAMLparam2(xch, keys);
        int r;
 
-       r = xc_send_debug_keys(_H(xc_handle), String_val(keys));
+       r = xc_send_debug_keys(_H(xch), String_val(keys));
        if (r)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_physinfo(value xc_handle)
+CAMLprim value stub_xc_physinfo(value xch)
 {
-       CAMLparam1(xc_handle);
+       CAMLparam1(xch);
        CAMLlocal3(physinfo, cap_list, tmp);
        xc_physinfo_t c_physinfo;
        int r;
 
        // caml_enter_blocking_section();
-       r = xc_physinfo(_H(xc_handle), &c_physinfo);
+       r = xc_physinfo(_H(xch), &c_physinfo);
        // caml_leave_blocking_section();
 
        if (r)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        tmp = cap_list = Val_emptylist;
        for (r = 0; r < 2; r++) {
@@ -550,11 +589,11 @@ CAMLprim value stub_xc_physinfo(value xc
        CAMLreturn(physinfo);
 }
 
-CAMLprim value stub_xc_pcpu_info(value xc_handle, value nr_cpus)
+CAMLprim value stub_xc_pcpu_info(value xch, value nr_cpus)
 {
-       CAMLparam2(xc_handle, nr_cpus);
+       CAMLparam2(xch, nr_cpus);
        CAMLlocal2(pcpus, v);
-       xen_sysctl_cpuinfo_t *info;
+       xc_cpuinfo_t *info;
        int r, size;
 
        if (Int_val(nr_cpus) < 1)
@@ -565,12 +604,12 @@ CAMLprim value stub_xc_pcpu_info(value x
                caml_raise_out_of_memory();
 
        // caml_enter_blocking_section();
-       r = xc_pcpu_info(_H(xc_handle), Int_val(nr_cpus), info, &size);
+       r = xc_getcpuinfo(_H(xch), Int_val(nr_cpus), info, &size);
        // caml_leave_blocking_section();
 
        if (r) {
                free(info);
-               failwith_xc();
+               failwith_xc(_H(xch));
        }
 
        if (size > 0) {
@@ -586,101 +625,98 @@ CAMLprim value stub_xc_pcpu_info(value x
        CAMLreturn(pcpus);
 }
 
-CAMLprim value stub_xc_domain_setmaxmem(value xc_handle, value domid,
+CAMLprim value stub_xc_domain_setmaxmem(value xch, value domid,
                                         value max_memkb)
 {
-       CAMLparam3(xc_handle, domid, max_memkb);
+       CAMLparam3(xch, domid, max_memkb);
 
-       int c_xc_handle = _H(xc_handle);
        uint32_t c_domid = _D(domid);
        unsigned int c_max_memkb = Int64_val(max_memkb);
        // caml_enter_blocking_section();
-       int retval = xc_domain_setmaxmem(c_xc_handle, c_domid,
+       int retval = xc_domain_setmaxmem(_H(xch), c_domid,
                                         c_max_memkb);
        // caml_leave_blocking_section();
        if (retval)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_set_memmap_limit(value xc_handle, value domid,
+CAMLprim value stub_xc_domain_set_memmap_limit(value xch, value domid,
                                                value map_limitkb)
 {
-       CAMLparam3(xc_handle, domid, map_limitkb);
+       CAMLparam3(xch, domid, map_limitkb);
        unsigned long v;
        int retval;
 
        v = Int64_val(map_limitkb);
-       retval = xc_domain_set_memmap_limit(_H(xc_handle), _D(domid), v);
+       retval = xc_domain_set_memmap_limit(_H(xch), _D(domid), v);
        if (retval)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_memory_increase_reservation(value xc_handle,
+CAMLprim value stub_xc_domain_memory_increase_reservation(value xch,
                                                           value domid,
                                                           value mem_kb)
 {
-       CAMLparam3(xc_handle, domid, mem_kb);
+       CAMLparam3(xch, domid, mem_kb);
 
        unsigned long nr_extents = ((unsigned long)(Int64_val(mem_kb))) >> 
(PAGE_SHIFT - 10);
 
-       int c_xc_handle = _H(xc_handle);
        uint32_t c_domid = _D(domid);
        // caml_enter_blocking_section();
-       int retval = xc_domain_memory_increase_reservation(c_xc_handle, c_domid,
-                                                          nr_extents, 0, 0, 
NULL);
+       int retval = xc_domain_increase_reservation_exact(_H(xch), c_domid,
+                                                         nr_extents, 0, 0, 
NULL);
        // caml_leave_blocking_section();
 
        if (retval)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_set_machine_address_size(value xc_handle,
+CAMLprim value stub_xc_domain_set_machine_address_size(value xch,
                                                       value domid,
                                                       value width)
 {
-       CAMLparam3(xc_handle, domid, width);
-       int c_xc_handle = _H(xc_handle);
+       CAMLparam3(xch, domid, width);
        uint32_t c_domid = _D(domid);
        int c_width = Int_val(width);
 
-       int retval = xc_domain_set_machine_address_size(c_xc_handle, c_domid, 
c_width);
+       int retval = xc_domain_set_machine_address_size(_H(xch), c_domid, 
c_width);
        if (retval)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_get_machine_address_size(value xc_handle,
+CAMLprim value stub_xc_domain_get_machine_address_size(value xch,
                                                        value domid)
 {
-       CAMLparam2(xc_handle, domid);
+       CAMLparam2(xch, domid);
        int retval;
 
-       retval = xc_domain_get_machine_address_size(_H(xc_handle), _D(domid));
+       retval = xc_domain_get_machine_address_size(_H(xch), _D(domid));
        if (retval < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_int(retval));
 }
 
-CAMLprim value stub_xc_domain_cpuid_set(value xc_handle, value domid,
-                                        value is_hvm, value input,
+CAMLprim value stub_xc_domain_cpuid_set(value xch, value domid,
+                                        value input,
                                         value config)
 {
-       CAMLparam5(xc_handle, domid, is_hvm, input, config);
+       CAMLparam4(xch, domid, input, config);
        CAMLlocal2(array, tmp);
        int r;
+       unsigned int c_input[2];
        char *c_config[4], *out_config[4];
-       uint32_t c_input, c_oinput;
 
        c_config[0] = string_of_option_array(config, 0);
        c_config[1] = string_of_option_array(config, 1);
        c_config[2] = string_of_option_array(config, 2);
        c_config[3] = string_of_option_array(config, 3);
 
-       cpuid_input_of_val(c_input, c_oinput, input);
+       cpuid_input_of_val(c_input[0], c_input[1], input);
 
        array = caml_alloc(4, 0);
        for (r = 0; r < 4; r++) {
@@ -695,29 +731,30 @@ CAMLprim value stub_xc_domain_cpuid_set(
        for (r = 0; r < 4; r++)
                out_config[r] = (c_config[r]) ? String_val(Field(Field(array, 
r), 0)) : NULL;
 
-       r = xc_domain_cpuid_set(_H(xc_handle), _D(domid), Bool_val(is_hvm),
-                               c_input, c_oinput, c_config, out_config);
+       r = xc_cpuid_set(_H(xch), _D(domid),
+                        c_input, (const char **)c_config, out_config);
        if (r < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(array);
 }
 
-CAMLprim value stub_xc_domain_cpuid_apply(value xc_handle, value domid, value 
is_hvm)
+CAMLprim value stub_xc_domain_cpuid_apply_policy(value xch, value domid)
 {
-       CAMLparam3(xc_handle, domid, is_hvm);
+       CAMLparam2(xch, domid);
        int r;
-       r = xc_domain_cpuid_apply(_H(xc_handle), _D(domid), Bool_val(is_hvm));
+
+       r = xc_cpuid_apply_policy(_H(xch), _D(domid));
        if (r < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_cpuid_check(value input, value config)
+CAMLprim value stub_xc_cpuid_check(value xch, value input, value config)
 {
-       CAMLparam2(input, config);
+       CAMLparam3(xch, input, config);
        CAMLlocal3(ret, array, tmp);
        int r;
-       uint32_t c_input, c_oinput;
+       unsigned int c_input[2];
        char *c_config[4], *out_config[4];
 
        c_config[0] = string_of_option_array(config, 0);
@@ -725,7 +762,7 @@ CAMLprim value stub_xc_cpuid_check(value
        c_config[2] = string_of_option_array(config, 2);
        c_config[3] = string_of_option_array(config, 3);
 
-       cpuid_input_of_val(c_input, c_oinput, input);
+       cpuid_input_of_val(c_input[0], c_input[1], input);
 
        array = caml_alloc(4, 0);
        for (r = 0; r < 4; r++) {
@@ -740,9 +777,9 @@ CAMLprim value stub_xc_cpuid_check(value
        for (r = 0; r < 4; r++)
                out_config[r] = (c_config[r]) ? String_val(Field(Field(array, 
r), 0)) : NULL;
 
-       r = xc_cpuid_check(c_input, c_oinput, c_config, out_config);
+       r = xc_cpuid_check(_H(xch), c_input, (const char **)c_config, 
out_config);
        if (r < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        ret = caml_alloc_tuple(2);
        Store_field(ret, 0, Val_bool(r));
@@ -751,22 +788,21 @@ CAMLprim value stub_xc_cpuid_check(value
        CAMLreturn(ret);
 }
 
-CAMLprim value stub_xc_version_version(value xc_handle)
+CAMLprim value stub_xc_version_version(value xch)
 {
-       CAMLparam1(xc_handle);
+       CAMLparam1(xch);
        CAMLlocal1(result);
        xen_extraversion_t extra;
        long packed;
        int retval;
 
-       int c_xc_handle = _H(xc_handle);
        // caml_enter_blocking_section();
-       packed = xc_version(c_xc_handle, XENVER_version, NULL);
-       retval = xc_version(c_xc_handle, XENVER_extraversion, &extra);
+       packed = xc_version(_H(xch), XENVER_version, NULL);
+       retval = xc_version(_H(xch), XENVER_extraversion, &extra);
        // caml_leave_blocking_section();
 
        if (retval)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        result = caml_alloc_tuple(3);
 
@@ -778,20 +814,19 @@ CAMLprim value stub_xc_version_version(v
 }
 
 
-CAMLprim value stub_xc_version_compile_info(value xc_handle)
+CAMLprim value stub_xc_version_compile_info(value xch)
 {
-       CAMLparam1(xc_handle);
+       CAMLparam1(xch);
        CAMLlocal1(result);
        xen_compile_info_t ci;
        int retval;
 
-       int c_xc_handle = _H(xc_handle);
        // caml_enter_blocking_section();
-       retval = xc_version(c_xc_handle, XENVER_compile_info, &ci);
+       retval = xc_version(_H(xch), XENVER_compile_info, &ci);
        // caml_leave_blocking_section();
 
        if (retval)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        result = caml_alloc_tuple(4);
 
@@ -804,36 +839,35 @@ CAMLprim value stub_xc_version_compile_i
 }
 
 
-static value xc_version_single_string(value xc_handle, int code, void *info)
+static value xc_version_single_string(value xch, int code, void *info)
 {
-       CAMLparam1(xc_handle);
+       CAMLparam1(xch);
        int retval;
 
-       int c_xc_handle = _H(xc_handle);
        // caml_enter_blocking_section();
-       retval = xc_version(c_xc_handle, code, info);
+       retval = xc_version(_H(xch), code, info);
        // caml_leave_blocking_section();
 
        if (retval)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(caml_copy_string((char *)info));
 }
 
 
-CAMLprim value stub_xc_version_changeset(value xc_handle)
+CAMLprim value stub_xc_version_changeset(value xch)
 {
        xen_changeset_info_t ci;
 
-       return xc_version_single_string(xc_handle, XENVER_changeset, &ci);
+       return xc_version_single_string(xch, XENVER_changeset, &ci);
 }
 
 
-CAMLprim value stub_xc_version_capabilities(value xc_handle)
+CAMLprim value stub_xc_version_capabilities(value xch)
 {
        xen_capabilities_info_t ci;
 
-       return xc_version_single_string(xc_handle, XENVER_capabilities, &ci);
+       return xc_version_single_string(xch, XENVER_capabilities, &ci);
 }
 
 
@@ -845,13 +879,12 @@ CAMLprim value stub_pages_to_kib(value p
 }
 
 
-CAMLprim value stub_map_foreign_range(value xc_handle, value dom,
+CAMLprim value stub_map_foreign_range(value xch, value dom,
                                       value size, value mfn)
 {
-       CAMLparam4(xc_handle, dom, size, mfn);
+       CAMLparam4(xch, dom, size, mfn);
        CAMLlocal1(result);
        struct mmap_interface *intf;
-       int c_xc_handle;
        uint32_t c_dom;
        unsigned long c_mfn;
 
@@ -860,11 +893,10 @@ CAMLprim value stub_map_foreign_range(va
 
        intf->len = Int_val(size);
 
-       c_xc_handle = _H(xc_handle);
        c_dom = _D(dom);
        c_mfn = Nativeint_val(mfn);
        // caml_enter_blocking_section();
-       intf->addr = xc_map_foreign_range(c_xc_handle, c_dom,
+       intf->addr = xc_map_foreign_range(_H(xch), c_dom,
                                          intf->len, PROT_READ|PROT_WRITE,
                                          c_mfn);
        // caml_leave_blocking_section();
@@ -873,18 +905,18 @@ CAMLprim value stub_map_foreign_range(va
        CAMLreturn(result);
 }
 
-CAMLprim value stub_sched_credit_domain_get(value xc_handle, value domid)
+CAMLprim value stub_sched_credit_domain_get(value xch, value domid)
 {
-       CAMLparam2(xc_handle, domid);
+       CAMLparam2(xch, domid);
        CAMLlocal1(sdom);
        struct xen_domctl_sched_credit c_sdom;
        int ret;
 
        // caml_enter_blocking_section();
-       ret = xc_sched_credit_domain_get(_H(xc_handle), _D(domid), &c_sdom);
+       ret = xc_sched_credit_domain_get(_H(xch), _D(domid), &c_sdom);
        // caml_leave_blocking_section();
        if (ret != 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        sdom = caml_alloc_tuple(2);
        Store_field(sdom, 0, Val_int(c_sdom.weight));
@@ -893,62 +925,66 @@ CAMLprim value stub_sched_credit_domain_
        CAMLreturn(sdom);
 }
 
-CAMLprim value stub_sched_credit_domain_set(value xc_handle, value domid,
+CAMLprim value stub_sched_credit_domain_set(value xch, value domid,
                                             value sdom)
 {
-       CAMLparam3(xc_handle, domid, sdom);
+       CAMLparam3(xch, domid, sdom);
        struct xen_domctl_sched_credit c_sdom;
        int ret;
 
        c_sdom.weight = Int_val(Field(sdom, 0));
        c_sdom.cap = Int_val(Field(sdom, 1));
        // caml_enter_blocking_section();
-       ret = xc_sched_credit_domain_set(_H(xc_handle), _D(domid), &c_sdom);
+       ret = xc_sched_credit_domain_set(_H(xch), _D(domid), &c_sdom);
        // caml_leave_blocking_section();
        if (ret != 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_shadow_allocation_get(value xc_handle, value domid)
+CAMLprim value stub_shadow_allocation_get(value xch, value domid)
 {
-       CAMLparam2(xc_handle, domid);
+       CAMLparam2(xch, domid);
        CAMLlocal1(mb);
-       uint32_t c_mb;
+       unsigned long c_mb;
        int ret;
 
        // caml_enter_blocking_section();
-       ret = xc_shadow_allocation_get(_H(xc_handle), _D(domid), &c_mb);
+       ret = xc_shadow_control(_H(xch), _D(domid),
+                               XEN_DOMCTL_SHADOW_OP_GET_ALLOCATION,
+                               NULL, 0, &c_mb, 0, NULL);
        // caml_leave_blocking_section();
        if (ret != 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        mb = Val_int(c_mb);
        CAMLreturn(mb);
 }
 
-CAMLprim value stub_shadow_allocation_set(value xc_handle, value domid,
+CAMLprim value stub_shadow_allocation_set(value xch, value domid,
                                          value mb)
 {
-       CAMLparam3(xc_handle, domid, mb);
-       uint32_t c_mb;
+       CAMLparam3(xch, domid, mb);
+       unsigned long c_mb;
        int ret;
 
        c_mb = Int_val(mb);
        // caml_enter_blocking_section();
-       ret = xc_shadow_allocation_set(_H(xc_handle), _D(domid), c_mb);
+       ret = xc_shadow_control(_H(xch), _D(domid),
+                               XEN_DOMCTL_SHADOW_OP_SET_ALLOCATION,
+                               NULL, 0, &c_mb, 0, NULL);
        // caml_leave_blocking_section();
        if (ret != 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_get_pfn_list(value xc_handle, value domid,
+CAMLprim value stub_xc_domain_get_pfn_list(value xch, value domid,
                                            value nr_pfns)
 {
-       CAMLparam3(xc_handle, domid, nr_pfns);
+       CAMLparam3(xch, domid, nr_pfns);
        CAMLlocal2(array, v);
        unsigned long c_nr_pfns;
        long ret, i;
@@ -960,11 +996,11 @@ CAMLprim value stub_xc_domain_get_pfn_li
        if (!c_array)
                caml_raise_out_of_memory();
 
-       ret = xc_domain_get_pfn_list(_H(xc_handle), _D(domid),
-                                    c_array, c_nr_pfns);
+       ret = xc_get_pfn_list(_H(xch), _D(domid),
+                             c_array, c_nr_pfns);
        if (ret < 0) {
                free(c_array);
-               failwith_xc();
+               failwith_xc(_H(xch));
        }
 
        array = caml_alloc(ret, 0);
@@ -977,11 +1013,11 @@ CAMLprim value stub_xc_domain_get_pfn_li
        CAMLreturn(array);
 }
 
-CAMLprim value stub_xc_domain_ioport_permission(value xc_handle, value domid,
+CAMLprim value stub_xc_domain_ioport_permission(value xch, value domid,
                                               value start_port, value nr_ports,
                                               value allow)
 {
-       CAMLparam5(xc_handle, domid, start_port, nr_ports, allow);
+       CAMLparam5(xch, domid, start_port, nr_ports, allow);
        uint32_t c_start_port, c_nr_ports;
        uint8_t c_allow;
        int ret;
@@ -990,19 +1026,19 @@ CAMLprim value stub_xc_domain_ioport_per
        c_nr_ports = Int_val(nr_ports);
        c_allow = Bool_val(allow);
 
-       ret = xc_domain_ioport_permission(_H(xc_handle), _D(domid),
+       ret = xc_domain_ioport_permission(_H(xch), _D(domid),
                                         c_start_port, c_nr_ports, c_allow);
        if (ret < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_iomem_permission(value xc_handle, value domid,
+CAMLprim value stub_xc_domain_iomem_permission(value xch, value domid,
                                               value start_pfn, value nr_pfns,
                                               value allow)
 {
-       CAMLparam5(xc_handle, domid, start_pfn, nr_pfns, allow);
+       CAMLparam5(xch, domid, start_pfn, nr_pfns, allow);
        unsigned long c_start_pfn, c_nr_pfns;
        uint8_t c_allow;
        int ret;
@@ -1011,18 +1047,18 @@ CAMLprim value stub_xc_domain_iomem_perm
        c_nr_pfns = Nativeint_val(nr_pfns);
        c_allow = Bool_val(allow);
 
-       ret = xc_domain_iomem_permission(_H(xc_handle), _D(domid),
+       ret = xc_domain_iomem_permission(_H(xch), _D(domid),
                                         c_start_pfn, c_nr_pfns, c_allow);
        if (ret < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_irq_permission(value xc_handle, value domid,
+CAMLprim value stub_xc_domain_irq_permission(value xch, value domid,
                                             value pirq, value allow)
 {
-       CAMLparam4(xc_handle, domid, pirq, allow);
+       CAMLparam4(xch, domid, pirq, allow);
        uint8_t c_pirq;
        uint8_t c_allow;
        int ret;
@@ -1030,138 +1066,90 @@ CAMLprim value stub_xc_domain_irq_permis
        c_pirq = Int_val(pirq);
        c_allow = Bool_val(allow);
 
-       ret = xc_domain_irq_permission(_H(xc_handle), _D(domid),
+       ret = xc_domain_irq_permission(_H(xch), _D(domid),
                                       c_pirq, c_allow);
        if (ret < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_hvm_check_pvdriver(value xc_handle, value domid)
+static uint32_t pci_dev_to_bdf(int domain, int bus, int slot, int func)
 {
-       CAMLparam2(xc_handle, domid);
-       int ret;
-
-       ret = xc_hvm_check_pvdriver(_H(xc_handle), _D(domid));
-       if (ret < 0)
-               failwith_xc();
-       CAMLreturn(Val_bool(ret));
+       uint32_t bdf = 0;
+       bdf |= (bus & 0xff) << 16;
+       bdf |= (slot & 0x1f) << 11;
+       bdf |= (func & 0x7) << 8;
+       return bdf;
 }
 
-CAMLprim value stub_xc_domain_test_assign_device(value xc_handle, value domid, 
value desc)
+CAMLprim value stub_xc_domain_test_assign_device(value xch, value domid, value 
desc)
 {
-       CAMLparam3(xc_handle, domid, desc);
+       CAMLparam3(xch, domid, desc);
        int ret;
        int domain, bus, slot, func;
+       uint32_t bdf;
 
        domain = Int_val(Field(desc, 0));
        bus = Int_val(Field(desc, 1));
        slot = Int_val(Field(desc, 2));
        func = Int_val(Field(desc, 3));
+       bdf = pci_dev_to_bdf(domain, bus, slot, func);
 
-       ret = xc_domain_test_assign_device(_H(xc_handle), _D(domid),
-                                          domain, bus, slot, func);
+       ret = xc_test_assign_device(_H(xch), _D(domid), bdf);
+
        CAMLreturn(Val_bool(ret == 0));
 }
 
-CAMLprim value stub_xc_domain_assign_device(value xc_handle, value domid, 
value desc)
+CAMLprim value stub_xc_domain_assign_device(value xch, value domid, value desc)
 {
-       CAMLparam3(xc_handle, domid, desc);
+       CAMLparam3(xch, domid, desc);
        int ret;
        int domain, bus, slot, func;
+       uint32_t bdf;
 
        domain = Int_val(Field(desc, 0));
        bus = Int_val(Field(desc, 1));
        slot = Int_val(Field(desc, 2));
        func = Int_val(Field(desc, 3));
+       bdf = pci_dev_to_bdf(domain, bus, slot, func);
 
-       ret = xc_domain_assign_device(_H(xc_handle), _D(domid),
-                                     domain, bus, slot, func);
+       ret = xc_assign_device(_H(xch), _D(domid), bdf);
+
        if (ret < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_deassign_device(value xc_handle, value domid, 
value desc)
+CAMLprim value stub_xc_domain_deassign_device(value xch, value domid, value 
desc)
 {
-       CAMLparam3(xc_handle, domid, desc);
+       CAMLparam3(xch, domid, desc);
        int ret;
        int domain, bus, slot, func;
+       uint32_t bdf;
 
        domain = Int_val(Field(desc, 0));
        bus = Int_val(Field(desc, 1));
        slot = Int_val(Field(desc, 2));
        func = Int_val(Field(desc, 3));
+       bdf = pci_dev_to_bdf(domain, bus, slot, func);
 
-       ret = xc_domain_deassign_device(_H(xc_handle), _D(domid),
-                                       domain, bus, slot, func);
+       ret = xc_deassign_device(_H(xch), _D(domid), bdf);
+
        if (ret < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
        CAMLreturn(Val_unit);
 }
 
-CAMLprim value stub_xc_domain_set_timer_mode(value handle, value id, value 
mode)
+CAMLprim value stub_xc_watchdog(value xch, value domid, value timeout)
 {
-       CAMLparam3(handle, id, mode);
-       int ret;
-
-       ret = xc_domain_set_timer_mode(_H(handle), _D(id), Int_val(mode));
-       if (ret < 0)
-               failwith_xc();
-       CAMLreturn(Val_unit);
-}
-
-CAMLprim value stub_xc_domain_set_hpet(value handle, value id, value mode)
-{
-       CAMLparam3(handle, id, mode);
-       int ret;
-
-       ret = xc_domain_set_hpet(_H(handle), _D(id), Int_val(mode));
-       if (ret < 0)
-               failwith_xc();
-       CAMLreturn(Val_unit);
-}
-
-CAMLprim value stub_xc_domain_set_vpt_align(value handle, value id, value mode)
-{
-       CAMLparam3(handle, id, mode);
-       int ret;
-
-       ret = xc_domain_set_vpt_align(_H(handle), _D(id), Int_val(mode));
-       if (ret < 0)
-               failwith_xc();
-       CAMLreturn(Val_unit);
-}
-
-CAMLprim value stub_xc_watchdog(value handle, value domid, value timeout)
-{
-       CAMLparam3(handle, domid, timeout);
+       CAMLparam3(xch, domid, timeout);
        int ret;
        unsigned int c_timeout = Int32_val(timeout);
 
-       ret = xc_domain_watchdog(_H(handle), _D(domid), c_timeout);
+       ret = xc_watchdog(_H(xch), _D(domid), c_timeout);
        if (ret < 0)
-               failwith_xc();
-
-       CAMLreturn(Val_int(ret));
-}
-
-CAMLprim value stub_xc_domain_send_s3resume(value handle, value domid)
-{
-       CAMLparam2(handle, domid);
-       xc_domain_send_s3resume(_H(handle), _D(domid));
-       CAMLreturn(Val_unit);
-}
-
-CAMLprim value stub_xc_domain_get_acpi_s_state(value handle, value domid)
-{
-       CAMLparam2(handle, domid);
-       int ret;
-
-       ret = xc_domain_get_acpi_s_state(_H(handle), _D(domid));
-       if (ret < 0)
-               failwith_xc();
+               failwith_xc(_H(xch));
 
        CAMLreturn(Val_int(ret));
 }
diff -r ac5b6ac9ec0d -r 4e6556dc40d3 tools/ocaml/xenstored/Makefile
--- a/tools/ocaml/xenstored/Makefile    Thu Nov 18 05:46:26 2010 -0500
+++ b/tools/ocaml/xenstored/Makefile    Thu Nov 18 05:46:26 2010 -0500
@@ -39,7 +39,8 @@ XENSTOREDLIBS = \
        -ccopt -L -ccopt $(OCAML_TOPLEVEL)/libs/log 
$(OCAML_TOPLEVEL)/libs/log/log.cmxa \
        -ccopt -L -ccopt $(OCAML_TOPLEVEL)/libs/eventchn 
$(OCAML_TOPLEVEL)/libs/eventchn/eventchn.cmxa \
        -ccopt -L -ccopt $(OCAML_TOPLEVEL)/libs/xc 
$(OCAML_TOPLEVEL)/libs/xc/xc.cmxa \
-       -ccopt -L -ccopt $(OCAML_TOPLEVEL)/libs/xb 
$(OCAML_TOPLEVEL)/libs/xb/xb.cmxa
+       -ccopt -L -ccopt $(OCAML_TOPLEVEL)/libs/xb 
$(OCAML_TOPLEVEL)/libs/xb/xb.cmxa \
+       -ccopt -L -ccopt $(XEN_ROOT)/tools/libxc
 
 PROGRAMS = oxenstored
 

_______________________________________________
xen-api mailing list
xen-api@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/mailman/listinfo/xen-api