On Fri, 2010-10-01 at 17:26 +0100, Stefano Stabellini wrote:
> this patch doesn't apply anymore, could you please rebase and resend?
It's in my queue after the hypercall buffer stuff which is needed to
remove pthreads from libxc for compatibility with the ocaml runtime.
I'll resurrect it once that has gone in.
Ian.
>
> On Fri, 10 Sep 2010, Ian Campbell wrote:
> > # HG changeset patch
> > # User Ian Campbell <ian.campbell@xxxxxxxxxx>
> > # Date 1284113402 -3600
> > # Node ID c2610f86abfb2c34a5a653dea29d5518fb355628
> > # Parent 8a710e0eb0881cad6156500bd4cedcebc7824a18
> > 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.
> >
> > Signed-off-by: Ian Campbell <ian.campbell@xxxxxxxxxx>
> > Cc: Vincent Hanquez <Vincent.Hanquez@xxxxxxxxxxxxx>
> >
> > diff -r 8a710e0eb088 -r c2610f86abfb tools/ocaml/Makefile.rules
> > --- a/tools/ocaml/Makefile.rules Fri Sep 10 11:10:00 2010 +0100
> > +++ b/tools/ocaml/Makefile.rules Fri Sep 10 11:10:02 2010 +0100
> > @@ -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 8a710e0eb088 -r c2610f86abfb tools/ocaml/libs/xc/Makefile
> > --- a/tools/ocaml/libs/xc/Makefile Fri Sep 10 11:10:00 2010 +0100
> > +++ b/tools/ocaml/libs/xc/Makefile Fri Sep 10 11:10:02 2010 +0100
> > @@ -2,15 +2,17 @@ XEN_ROOT=$(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 8a710e0eb088 -r c2610f86abfb tools/ocaml/libs/xc/xc.h
> > --- a/tools/ocaml/libs/xc/xc.h Fri Sep 10 11:10:00 2010 +0100
> > +++ /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 8a710e0eb088 -r c2610f86abfb tools/ocaml/libs/xc/xc.ml
> > --- a/tools/ocaml/libs/xc/xc.ml Fri Sep 10 11:10:00 2010 +0100
> > +++ b/tools/ocaml/libs/xc/xc.ml Fri Sep 10 11:10:02 2010 +0100
> > @@ -127,9 +127,6 @@ let domain_sethandle handle n uuid =
> > 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"
> >
> > @@ -207,13 +204,13 @@ external domain_get_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
> > @@ -229,17 +226,6 @@ external domain_deassign_device: handle
> > = "stub_xc_domain_deassign_device"
> > 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
> > diff -r 8a710e0eb088 -r c2610f86abfb tools/ocaml/libs/xc/xc.mli
> > --- a/tools/ocaml/libs/xc/xc.mli Fri Sep 10 11:10:00 2010 +0100
> > +++ b/tools/ocaml/libs/xc/xc.mli Fri Sep 10 11:10:02 2010 +0100
> > @@ -80,8 +80,6 @@ external _domain_sethandle : handle -> 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"
> > @@ -147,16 +145,6 @@ external domain_test_assign_device: hand
> > 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_get_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 8a710e0eb088 -r c2610f86abfb tools/ocaml/libs/xc/xc_cpufeature.h
> > --- a/tools/ocaml/libs/xc/xc_cpufeature.h Fri Sep 10 11:10:00 2010
> > +0100
> > +++ /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 8a710e0eb088 -r c2610f86abfb tools/ocaml/libs/xc/xc_cpuid.h
> > --- a/tools/ocaml/libs/xc/xc_cpuid.h Fri Sep 10 11:10:00 2010 +0100
> > +++ /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 8a710e0eb088 -r c2610f86abfb tools/ocaml/libs/xc/xc_e820.h
> > --- a/tools/ocaml/libs/xc/xc_e820.h Fri Sep 10 11:10:00 2010 +0100
> > +++ /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 8a710e0eb088 -r c2610f86abfb tools/ocaml/libs/xc/xc_lib.c
> > --- a/tools/ocaml/libs/xc/xc_lib.c Fri Sep 10 11:10:00 2010 +0100
> > +++ /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 8a710e0eb088 -r c2610f86abfb tools/ocaml/libs/xc/xc_stubs.c
> > --- a/tools/ocaml/libs/xc/xc_stubs.c Fri Sep 10 11:10:00 2010 +0100
> > +++ b/tools/ocaml/libs/xc/xc_stubs.c Fri Sep 10 11:10:02 2010 +0100
> > @@ -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,12 @@
> > 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.
> > - */
> > +#define ERROR_STRLEN 256
> > void failwith_xc(void)
> > {
> > - caml_raise_with_string(*caml_named_value("xc.error"),
> > xc_error_get());
> > + static char error_str[ERROR_STRLEN];
> > + snprintf(error_str, ERROR_STRLEN, "%d: %s", errno, strerror(errno));
> > + caml_raise_with_string(*caml_named_value("xc.error"), error_str);
> > }
> >
> > CAMLprim value stub_sizeof_core_header(value unit)
> > @@ -101,11 +102,11 @@ CAMLprim value stub_marshall_core_header
> >
> > CAMLprim value stub_xc_interface_open(void)
> > {
> > - int handle;
> > - handle = xc_interface_open();
> > - if (handle == -1)
> > + xc_interface *xch;
> > + xch = xc_interface_open(NULL, NULL, 0);
> > + if (xch == NULL)
> > failwith_xc();
> > - return Val_int(handle);
> > + return (value)xch;
> > }
> >
> >
> > @@ -116,20 +117,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 +136,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,7 +162,7 @@ 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)
> > @@ -176,37 +171,23 @@ CAMLprim value stub_xc_domain_create(val
> > 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();
> >
> > 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,55 +198,63 @@ 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();
> >
> > 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();
> > 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();
> > + 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();
> >
> > @@ -307,12 +296,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,11 +313,10 @@ 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();
> >
> > @@ -349,33 +337,34 @@ 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);
> > + ret = xc_domain_getinfolist(_H(xch), _D(domid), 1, &info);
> > if (ret != 0)
> > + failwith_xc();
> > + if (info.domain != _D(domid))
> > failwith_xc();
> >
> > 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)
> > @@ -391,15 +380,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,59 +396,60 @@ CAMLprim value stub_xc_vcpu_context_get(
> > CAMLreturn(context);
> > }
> >
> > -CAMLprim value stub_xc_vcpu_setaffinity(value xc_handle, value domid,
> > +CAMLprim value stub_xc_vcpu_setaffinity(value xch, value domid,
> > value vcpu, value cpumap)
> > {
> > - CAMLparam4(xc_handle, domid, vcpu, cpumap);
> > + CAMLparam4(xch, domid, vcpu, cpumap);
> > uint64_t c_cpumap;
> > int retval;
> >
> > c_cpumap = Int64_val(cpumap);
> > - retval = xc_vcpu_setaffinity(_H(xc_handle), _D(domid),
> > - Int_val(vcpu), c_cpumap);
> > + retval = xc_vcpu_setaffinity(_H(xch), _D(domid),
> > + Int_val(vcpu),
> > + &c_cpumap, sizeof(c_cpumap));
> > if (retval < 0)
> > failwith_xc();
> > 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;
> > int retval;
> >
> > - retval = xc_vcpu_getaffinity(_H(xc_handle), _D(domid),
> > - Int_val(vcpu), &cpumap);
> > + retval = xc_vcpu_getaffinity(_H(xch), _D(domid),
> > + Int_val(vcpu),
> > + &cpumap, sizeof(cpumap));
> > if (retval < 0)
> > failwith_xc();
> > ret = caml_copy_int64(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))
> > + if (xc_sched_id(_H(xch), &sched_id))
> > failwith_xc();
> > 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();
> >
> > @@ -483,16 +473,15 @@ 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)
> > @@ -501,26 +490,26 @@ CAMLprim value stub_xc_readconsolering(v
> > 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();
> > 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)
> > @@ -550,11 +539,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,7 +554,7 @@ 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) {
> > @@ -586,16 +575,15 @@ 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)
> > @@ -603,33 +591,32 @@ CAMLprim value stub_xc_domain_setmaxmem(
> > 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();
> >
> > 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,
> > + int retval = xc_domain_memory_increase_reservation(_H(xch), c_domid,
> > nr_extents, 0,
> > 0, NULL);
> > // caml_leave_blocking_section();
> >
> > @@ -638,49 +625,48 @@ CAMLprim value stub_xc_domain_memory_inc
> > 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();
> > 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();
> > 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 +681,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();
> > 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();
> > 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 +712,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,7 +727,7 @@ 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();
> >
> > @@ -751,18 +738,17 @@ 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)
> > @@ -778,16 +764,15 @@ 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)
> > @@ -804,14 +789,13 @@ 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)
> > @@ -821,19 +805,19 @@ static value xc_version_single_string(va
> > }
> >
> >
> > -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 +829,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 +843,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,15 +855,15 @@ 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();
> > @@ -893,17 +875,17 @@ 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();
> > @@ -911,15 +893,17 @@ CAMLprim value stub_sched_credit_domain_
> > 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();
> > @@ -928,16 +912,18 @@ CAMLprim value stub_shadow_allocation_ge
> > 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();
> > @@ -945,10 +931,10 @@ CAMLprim value stub_shadow_allocation_se
> > 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,8 +946,8 @@ 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();
> > @@ -977,11 +963,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,7 +976,7 @@ 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();
> > @@ -998,11 +984,11 @@ CAMLprim value stub_xc_domain_ioport_per
> > 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,7 +997,7 @@ 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();
> > @@ -1019,10 +1005,10 @@ CAMLprim value stub_xc_domain_iomem_perm
> > 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,7 +1016,7 @@ 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();
> > @@ -1038,97 +1024,68 @@ CAMLprim value stub_xc_domain_irq_permis
> > 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();
> > 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);
> > - if (ret < 0)
> > - failwith_xc();
> > - CAMLreturn(Val_unit);
> > -}
> > + ret = xc_deassign_device(_H(xch), _D(domid), bdf);
> >
> > -CAMLprim value stub_xc_domain_set_timer_mode(value handle, value id, value
> > mode)
> > -{
> > - 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);
> > @@ -1140,26 +1097,7 @@ CAMLprim value stub_xc_watchdog(value ha
> > int ret;
> > unsigned int c_timeout = Int32_val(timeout);
> >
> > - ret = xc_domain_watchdog(_H(handle), _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));
> > + ret = xc_watchdog(_H(handle), _D(domid), c_timeout);
> > if (ret < 0)
> > failwith_xc();
> >
> > diff -r 8a710e0eb088 -r c2610f86abfb tools/ocaml/xenstored/Makefile
> > --- a/tools/ocaml/xenstored/Makefile Fri Sep 10 11:10:00 2010 +0100
> > +++ b/tools/ocaml/xenstored/Makefile Fri Sep 10 11:10:02 2010 +0100
> > @@ -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-devel mailing list
> > Xen-devel@xxxxxxxxxxxxxxxxxxx
> > http://lists.xensource.com/xen-devel
> >
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel
|
Home