Mailing List Archive

This patch moves the implementation of the dummy XSM module to a header
file that provides inline functions when XSM_ENABLE is not defined. This
reduces duplication between the dummy module and callers when the
implementation of the dummy return is not just "return 0", and also
provides better compile-time checking for completeness of the XSM
implementations in the dummy module.

Signed-off-by: Daniel De Graaf <dgdegra@tycho.nsa.gov>
Cc: Keir Fraser <keir@xen.org>
Cc: Jan Beulich <jbeulich@suse.com>
---
xen/common/domctl.c | 2 -
xen/include/xsm/dummy.h | 628 ++++++++++++++++++++++++++++++++++++++++++++++++
xen/include/xsm/xsm.h | 290 +++++++++++-----------
xen/xsm/dummy.c | 617 +----------------------------------------------
xen/xsm/xsm_core.c | 2 +-
5 files changed, 772 insertions(+), 767 deletions(-)
create mode 100644 xen/include/xsm/dummy.h

diff --git a/xen/common/domctl.c b/xen/common/domctl.c
index 2b1f182..d99ba67 100644
--- a/xen/common/domctl.c
+++ b/xen/common/domctl.c
@@ -267,10 +267,8 @@ long do_domctl(XEN_GUEST_HANDLE(xen_domctl_t) u_domctl)
return -EPERM;
break;
}
-#ifdef XSM_ENABLE
case XEN_DOMCTL_getdomaininfo:
break;
-#endif
default:
if ( !IS_PRIV(current->domain) )
return -EPERM;
diff --git a/xen/include/xsm/dummy.h b/xen/include/xsm/dummy.h
new file mode 100644
index 0000000..61c6f13
--- /dev/null
+++ b/xen/include/xsm/dummy.h
@@ -0,0 +1,628 @@
+/*
+ * Default XSM hooks - IS_PRIV and IS_PRIV_FOR checks
+ *
+ * Author: Daniel De Graaf <dgdegra@tyhco.nsa.gov>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2,
+ * as published by the Free Software Foundation.
+ */
+
+#include <xen/sched.h>
+#include <xsm/xsm.h>
+
+static XSM_DEFAULT(void, security_domaininfo)(struct domain *d,
+ struct xen_domctl_getdomaininfo *info)
+{
+ return;
+}
+
+static XSM_DEFAULT(int, setvcpucontext)(struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, pausedomain) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, unpausedomain) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, resumedomain) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, domain_create)(struct domain *d, u32 ssidref)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, max_vcpus)(struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, destroydomain) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, vcpuaffinity) (int cmd, struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, scheduler) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, getdomaininfo) (struct domain *d)
+{
+ if ( !IS_PRIV(current->domain) )
+ return -EPERM;
+ return 0;
+}
+
+static XSM_DEFAULT(int, getvcpucontext) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, getvcpuinfo) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, domain_settime) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, set_target) (struct domain *d, struct domain *e)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, domctl)(struct domain *d, int cmd)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, set_virq_handler)(struct domain *d, uint32_t virq)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, tbufcontrol) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, readconsole) (uint32_t clear)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, sched_id) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, setdomainmaxmem) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, setdomainhandle) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, setdebugging) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, perfcontrol) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, debug_keys) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, getcpuinfo) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, get_pmstat) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, setpminfo) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, pm_op) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, do_mca) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, availheap) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, alloc_security_domain) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(void, free_security_domain) (struct domain *d)
+{
+ return;
+}
+
+static XSM_DEFAULT(int, grant_mapref) (struct domain *d1, struct domain *d2,
+ uint32_t flags)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, grant_unmapref) (struct domain *d1, struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, grant_setup) (struct domain *d1, struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, grant_transfer) (struct domain *d1, struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, grant_copy) (struct domain *d1, struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, grant_query_size) (struct domain *d1, struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, memory_adjust_reservation) (struct domain *d1,
+ struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, memory_stat_reservation) (struct domain *d1, struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, console_io) (struct domain *d, int cmd)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, profile) (struct domain *d, int op)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, kexec) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, schedop_shutdown) (struct domain *d1, struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, memory_pin_page) (struct domain *d1, struct domain *d2,
+ struct page_info *page)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, evtchn_unbound) (struct domain *d, struct evtchn *chn,
+ domid_t id2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, evtchn_interdomain) (struct domain *d1, struct evtchn
+ *chan1, struct domain *d2, struct evtchn *chan2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(void, evtchn_close_post) (struct evtchn *chn)
+{
+ return;
+}
+
+static XSM_DEFAULT(int, evtchn_send) (struct domain *d, struct evtchn *chn)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, evtchn_status) (struct domain *d, struct evtchn *chn)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, evtchn_reset) (struct domain *d1, struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, alloc_security_evtchn) (struct evtchn *chn)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(void, free_security_evtchn) (struct evtchn *chn)
+{
+ return;
+}
+
+static XSM_DEFAULT(char *, show_security_evtchn) (struct domain *d, const struct evtchn *chn)
+{
+ return NULL;
+}
+
+static XSM_DEFAULT(int, get_pod_target)(struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, set_pod_target)(struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, get_device_group) (uint32_t machine_bdf)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, test_assign_device) (uint32_t machine_bdf)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, assign_device) (struct domain *d, uint32_t machine_bdf)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, deassign_device) (struct domain *d, uint32_t machine_bdf)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, resource_plug_core) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, resource_unplug_core) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, resource_plug_pci) (uint32_t machine_bdf)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, resource_unplug_pci) (uint32_t machine_bdf)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, resource_setup_pci) (uint32_t machine_bdf)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, resource_setup_gsi) (int gsi)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, resource_setup_misc) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, page_offline) (uint32_t cmd)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, lockprof) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, cpupool_op) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, sched_op) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(long, __do_xsm_op)(XEN_GUEST_HANDLE(xsm_op_t) op)
+{
+ return -ENOSYS;
+}
+
+static XSM_DEFAULT(char *, show_irq_sid) (int irq)
+{
+ return NULL;
+}
+
+static XSM_DEFAULT(int, map_domain_pirq) (struct domain *d, int irq, void *data)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, unmap_domain_pirq) (struct domain *d, int irq)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, irq_permission) (struct domain *d, int pirq, uint8_t allow)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, iomem_permission) (struct domain *d, uint64_t s, uint64_t e, uint8_t allow)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, iomem_mapping) (struct domain *d, uint64_t s, uint64_t e, uint8_t allow)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, pci_config_permission) (struct domain *d, uint32_t machine_bdf,
+ uint16_t start, uint16_t end,
+ uint8_t access)
+{
+ return 0;
+}
+
+#ifdef CONFIG_X86
+static XSM_DEFAULT(int, shadow_control) (struct domain *d, uint32_t op)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, getpageframeinfo) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, getmemlist) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, hypercall_init) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, hvmcontext) (struct domain *d, uint32_t cmd)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, address_size) (struct domain *d, uint32_t cmd)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, machine_address_size) (struct domain *d, uint32_t cmd)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, hvm_param) (struct domain *d, unsigned long op)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, hvm_set_pci_intx_level) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, hvm_set_isa_irq_level) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, hvm_set_pci_link_route) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, hvm_inject_msi) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, mem_event) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, mem_sharing) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, apic) (struct domain *d, int cmd)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, xen_settime) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, memtype) (uint32_t access)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, microcode) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, physinfo) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, platform_quirk) (uint32_t quirk)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, firmware_info) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, efi_call) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, acpi_sleep) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, change_freq) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, getidletime) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, machine_memory_map) (void)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, domain_memory_map) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, mmu_normal_update) (struct domain *d, struct domain *t,
+ struct domain *f, intpte_t fpte)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, mmu_machphys_update) (struct domain *d, struct domain *f,
+ unsigned long mfn)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, update_va_mapping) (struct domain *d, struct domain *f,
+ l1_pgentry_t pte)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, add_to_physmap) (struct domain *d1, struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, remove_from_physmap) (struct domain *d1, struct domain *d2)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, sendtrigger) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, bind_pt_irq) (struct domain *d, struct xen_domctl_bind_pt_irq *bind)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, unbind_pt_irq) (struct domain *d, struct xen_domctl_bind_pt_irq *bind)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, pin_mem_cacheattr) (struct domain *d)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, ext_vcpucontext) (struct domain *d, uint32_t cmd)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, vcpuextstate) (struct domain *d, uint32_t cmd)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, ioport_permission) (struct domain *d, uint32_t s, uint32_t e, uint8_t allow)
+{
+ return 0;
+}
+
+static XSM_DEFAULT(int, ioport_mapping) (struct domain *d, uint32_t s, uint32_t e, uint8_t allow)
+{
+ return 0;
+}
+
+#endif
diff --git a/xen/include/xsm/xsm.h b/xen/include/xsm/xsm.h
index cbbe673..ba5a89e 100644
--- a/xen/include/xsm/xsm.h
+++ b/xen/include/xsm/xsm.h
@@ -21,12 +21,6 @@
typedef void xsm_op_t;
DEFINE_XEN_GUEST_HANDLE(xsm_op_t);

-#ifdef XSM_ENABLE
- #define xsm_call(fn) xsm_ops->fn
-#else
- #define xsm_call(fn) 0
-#endif
-
/* policy magic number (defined by XSM_MAGIC) */
typedef u32 xsm_magic_t;
#ifndef XSM_MAGIC
@@ -187,645 +181,643 @@ struct xsm_operations {
#endif
};

-#endif
-
extern struct xsm_operations *xsm_ops;

static inline void xsm_security_domaininfo (struct domain *d,
struct xen_domctl_getdomaininfo *info)
{
- (void)xsm_call(security_domaininfo(d, info));
+ xsm_ops->security_domaininfo(d, info);
}

static inline int xsm_setvcpucontext(struct domain *d)
{
- return xsm_call(setvcpucontext(d));
+ return xsm_ops->setvcpucontext(d);
}

static inline int xsm_pausedomain (struct domain *d)
{
- return xsm_call(pausedomain(d));
+ return xsm_ops->pausedomain(d);
}

static inline int xsm_unpausedomain (struct domain *d)
{
- return xsm_call(unpausedomain(d));
+ return xsm_ops->unpausedomain(d);
}

static inline int xsm_resumedomain (struct domain *d)
{
- return xsm_call(resumedomain(d));
+ return xsm_ops->resumedomain(d);
}

static inline int xsm_domain_create (struct domain *d, u32 ssidref)
{
- return xsm_call(domain_create(d, ssidref));
+ return xsm_ops->domain_create(d, ssidref);
}

static inline int xsm_max_vcpus(struct domain *d)
{
- return xsm_call(max_vcpus(d));
+ return xsm_ops->max_vcpus(d);
}

static inline int xsm_destroydomain (struct domain *d)
{
- return xsm_call(destroydomain(d));
+ return xsm_ops->destroydomain(d);
}

static inline int xsm_vcpuaffinity (int cmd, struct domain *d)
{
- return xsm_call(vcpuaffinity(cmd, d));
+ return xsm_ops->vcpuaffinity(cmd, d);
}

static inline int xsm_scheduler (struct domain *d)
{
- return xsm_call(scheduler(d));
+ return xsm_ops->scheduler(d);
}

static inline int xsm_getdomaininfo (struct domain *d)
{
- return xsm_call(getdomaininfo(d));
+ return xsm_ops->getdomaininfo(d);
}

static inline int xsm_getvcpucontext (struct domain *d)
{
- return xsm_call(getvcpucontext(d));
+ return xsm_ops->getvcpucontext(d);
}

static inline int xsm_getvcpuinfo (struct domain *d)
{
- return xsm_call(getvcpuinfo(d));
+ return xsm_ops->getvcpuinfo(d);
}

static inline int xsm_domain_settime (struct domain *d)
{
- return xsm_call(domain_settime(d));
+ return xsm_ops->domain_settime(d);
}

static inline int xsm_set_target (struct domain *d, struct domain *e)
{
- return xsm_call(set_target(d, e));
+ return xsm_ops->set_target(d, e);
}

static inline int xsm_domctl (struct domain *d, int cmd)
{
- return xsm_call(domctl(d, cmd));
+ return xsm_ops->domctl(d, cmd);
}

static inline int xsm_set_virq_handler (struct domain *d, uint32_t virq)
{
- return xsm_call(set_virq_handler(d, virq));
+ return xsm_ops->set_virq_handler(d, virq);
}

static inline int xsm_tbufcontrol (void)
{
- return xsm_call(tbufcontrol());
+ return xsm_ops->tbufcontrol();
}

static inline int xsm_readconsole (uint32_t clear)
{
- return xsm_call(readconsole(clear));
+ return xsm_ops->readconsole(clear);
}

static inline int xsm_sched_id (void)
{
- return xsm_call(sched_id());
+ return xsm_ops->sched_id();
}

static inline int xsm_setdomainmaxmem (struct domain *d)
{
- return xsm_call(setdomainmaxmem(d));
+ return xsm_ops->setdomainmaxmem(d);
}

static inline int xsm_setdomainhandle (struct domain *d)
{
- return xsm_call(setdomainhandle(d));
+ return xsm_ops->setdomainhandle(d);
}

static inline int xsm_setdebugging (struct domain *d)
{
- return xsm_call(setdebugging(d));
+ return xsm_ops->setdebugging(d);
}

static inline int xsm_perfcontrol (void)
{
- return xsm_call(perfcontrol());
+ return xsm_ops->perfcontrol();
}

static inline int xsm_debug_keys (void)
{
- return xsm_call(debug_keys());
+ return xsm_ops->debug_keys();
}

static inline int xsm_availheap (void)
{
- return xsm_call(availheap());
+ return xsm_ops->availheap();
}

static inline int xsm_getcpuinfo (void)
{
- return xsm_call(getcpuinfo());
+ return xsm_ops->getcpuinfo();
}

static inline int xsm_get_pmstat(void)
{
- return xsm_call(get_pmstat());
+ return xsm_ops->get_pmstat();
}

static inline int xsm_setpminfo(void)
{
- return xsm_call(setpminfo());
+ return xsm_ops->setpminfo();
}

static inline int xsm_pm_op(void)
{
- return xsm_call(pm_op());
+ return xsm_ops->pm_op();
}

static inline int xsm_do_mca(void)
{
- return xsm_call(do_mca());
+ return xsm_ops->do_mca();
}

static inline int xsm_evtchn_unbound (struct domain *d1, struct evtchn *chn,
domid_t id2)
{
- return xsm_call(evtchn_unbound(d1, chn, id2));
+ return xsm_ops->evtchn_unbound(d1, chn, id2);
}

static inline int xsm_evtchn_interdomain (struct domain *d1,
struct evtchn *chan1, struct domain *d2, struct evtchn *chan2)
{
- return xsm_call(evtchn_interdomain(d1, chan1, d2, chan2));
+ return xsm_ops->evtchn_interdomain(d1, chan1, d2, chan2);
}

static inline void xsm_evtchn_close_post (struct evtchn *chn)
{
- (void)xsm_call(evtchn_close_post(chn));
+ xsm_ops->evtchn_close_post(chn);
}

static inline int xsm_evtchn_send (struct domain *d, struct evtchn *chn)
{
- return xsm_call(evtchn_send(d, chn));
+ return xsm_ops->evtchn_send(d, chn);
}

static inline int xsm_evtchn_status (struct domain *d, struct evtchn *chn)
{
- return xsm_call(evtchn_status(d, chn));
+ return xsm_ops->evtchn_status(d, chn);
}

static inline int xsm_evtchn_reset (struct domain *d1, struct domain *d2)
{
- return xsm_call(evtchn_reset(d1, d2));
+ return xsm_ops->evtchn_reset(d1, d2);
}

static inline int xsm_grant_mapref (struct domain *d1, struct domain *d2,
uint32_t flags)
{
- return xsm_call(grant_mapref(d1, d2, flags));
+ return xsm_ops->grant_mapref(d1, d2, flags);
}

static inline int xsm_grant_unmapref (struct domain *d1, struct domain *d2)
{
- return xsm_call(grant_unmapref(d1, d2));
+ return xsm_ops->grant_unmapref(d1, d2);
}

static inline int xsm_grant_setup (struct domain *d1, struct domain *d2)
{
- return xsm_call(grant_setup(d1, d2));
+ return xsm_ops->grant_setup(d1, d2);
}

static inline int xsm_grant_transfer (struct domain *d1, struct domain *d2)
{
- return xsm_call(grant_transfer(d1, d2));
+ return xsm_ops->grant_transfer(d1, d2);
}

static inline int xsm_grant_copy (struct domain *d1, struct domain *d2)
{
- return xsm_call(grant_copy(d1, d2));
+ return xsm_ops->grant_copy(d1, d2);
}

static inline int xsm_grant_query_size (struct domain *d1, struct domain *d2)
{
- return xsm_call(grant_query_size(d1, d2));
+ return xsm_ops->grant_query_size(d1, d2);
}

static inline int xsm_alloc_security_domain (struct domain *d)
{
- return xsm_call(alloc_security_domain(d));
+ return xsm_ops->alloc_security_domain(d);
}

static inline void xsm_free_security_domain (struct domain *d)
{
- (void)xsm_call(free_security_domain(d));
+ xsm_ops->free_security_domain(d);
}

static inline int xsm_alloc_security_evtchn (struct evtchn *chn)
{
- return xsm_call(alloc_security_evtchn(chn));
+ return xsm_ops->alloc_security_evtchn(chn);
}

static inline void xsm_free_security_evtchn (struct evtchn *chn)
{
- (void)xsm_call(free_security_evtchn(chn));
+ (void)xsm_ops->free_security_evtchn(chn);
}

static inline char *xsm_show_security_evtchn (struct domain *d, const struct evtchn *chn)
{
- return xsm_call(show_security_evtchn(d, chn));
+ return xsm_ops->show_security_evtchn(d, chn);
}

static inline int xsm_get_pod_target (struct domain *d)
{
- return xsm_call(get_pod_target(d));
+ return xsm_ops->get_pod_target(d);
}

static inline int xsm_set_pod_target (struct domain *d)
{
- return xsm_call(set_pod_target(d));
+ return xsm_ops->set_pod_target(d);
}

static inline int xsm_memory_adjust_reservation (struct domain *d1, struct
domain *d2)
{
- return xsm_call(memory_adjust_reservation(d1, d2));
+ return xsm_ops->memory_adjust_reservation(d1, d2);
}

static inline int xsm_memory_stat_reservation (struct domain *d1,
struct domain *d2)
{
- return xsm_call(memory_stat_reservation(d1, d2));
+ return xsm_ops->memory_stat_reservation(d1, d2);
}

static inline int xsm_memory_pin_page(struct domain *d1, struct domain *d2,
struct page_info *page)
{
- return xsm_call(memory_pin_page(d1, d2, page));
+ return xsm_ops->memory_pin_page(d1, d2, page);
}

static inline int xsm_remove_from_physmap(struct domain *d1, struct domain *d2)
{
- return xsm_call(remove_from_physmap(d1, d2));
+ return xsm_ops->remove_from_physmap(d1, d2);
}

static inline int xsm_console_io (struct domain *d, int cmd)
{
- return xsm_call(console_io(d, cmd));
+ return xsm_ops->console_io(d, cmd);
}

static inline int xsm_profile (struct domain *d, int op)
{
- return xsm_call(profile(d, op));
+ return xsm_ops->profile(d, op);
}

static inline int xsm_kexec (void)
{
- return xsm_call(kexec());
+ return xsm_ops->kexec();
}

static inline int xsm_schedop_shutdown (struct domain *d1, struct domain *d2)
{
- return xsm_call(schedop_shutdown(d1, d2));
+ return xsm_ops->schedop_shutdown(d1, d2);
}

static inline char *xsm_show_irq_sid (int irq)
{
- return xsm_call(show_irq_sid(irq));
+ return xsm_ops->show_irq_sid(irq);
}

static inline int xsm_map_domain_pirq (struct domain *d, int irq, void *data)
{
- return xsm_call(map_domain_pirq(d, irq, data));
+ return xsm_ops->map_domain_pirq(d, irq, data);
}

static inline int xsm_unmap_domain_pirq (struct domain *d, int irq)
{
- return xsm_call(unmap_domain_pirq(d, irq));
+ return xsm_ops->unmap_domain_pirq(d, irq);
}

static inline int xsm_irq_permission (struct domain *d, int pirq, uint8_t allow)
{
- return xsm_call(irq_permission(d, pirq, allow));
+ return xsm_ops->irq_permission(d, pirq, allow);
}

static inline int xsm_iomem_permission (struct domain *d, uint64_t s, uint64_t e, uint8_t allow)
{
- return xsm_call(iomem_permission(d, s, e, allow));
+ return xsm_ops->iomem_permission(d, s, e, allow);
}

static inline int xsm_iomem_mapping (struct domain *d, uint64_t s, uint64_t e, uint8_t allow)
{
- return xsm_call(iomem_mapping(d, s, e, allow));
+ return xsm_ops->iomem_mapping(d, s, e, allow);
}

static inline int xsm_pci_config_permission (struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access)
{
- return xsm_call(pci_config_permission(d, machine_bdf, start, end, access));
+ return xsm_ops->pci_config_permission(d, machine_bdf, start, end, access);
}

static inline int xsm_get_device_group(uint32_t machine_bdf)
{
- return xsm_call(get_device_group(machine_bdf));
+ return xsm_ops->get_device_group(machine_bdf);
}

static inline int xsm_test_assign_device(uint32_t machine_bdf)
{
- return xsm_call(test_assign_device(machine_bdf));
+ return xsm_ops->test_assign_device(machine_bdf);
}

static inline int xsm_assign_device(struct domain *d, uint32_t machine_bdf)
{
- return xsm_call(assign_device(d, machine_bdf));
+ return xsm_ops->assign_device(d, machine_bdf);
}

static inline int xsm_deassign_device(struct domain *d, uint32_t machine_bdf)
{
- return xsm_call(deassign_device(d, machine_bdf));
+ return xsm_ops->deassign_device(d, machine_bdf);
}

static inline int xsm_resource_plug_pci (uint32_t machine_bdf)
{
- return xsm_call(resource_plug_pci(machine_bdf));
+ return xsm_ops->resource_plug_pci(machine_bdf);
}

static inline int xsm_resource_unplug_pci (uint32_t machine_bdf)
{
- return xsm_call(resource_unplug_pci(machine_bdf));
+ return xsm_ops->resource_unplug_pci(machine_bdf);
}

static inline int xsm_resource_plug_core (void)
{
- return xsm_call(resource_plug_core());
+ return xsm_ops->resource_plug_core();
}

static inline int xsm_resource_unplug_core (void)
{
- return xsm_call(resource_unplug_core());
+ return xsm_ops->resource_unplug_core();
}

static inline int xsm_resource_setup_pci (uint32_t machine_bdf)
{
- return xsm_call(resource_setup_pci(machine_bdf));
+ return xsm_ops->resource_setup_pci(machine_bdf);
}

static inline int xsm_resource_setup_gsi (int gsi)
{
- return xsm_call(resource_setup_gsi(gsi));
+ return xsm_ops->resource_setup_gsi(gsi);
}

static inline int xsm_resource_setup_misc (void)
{
- return xsm_call(resource_setup_misc());
+ return xsm_ops->resource_setup_misc();
}

static inline int xsm_page_offline(uint32_t cmd)
{
- return xsm_call(page_offline(cmd));
+ return xsm_ops->page_offline(cmd);
}

static inline int xsm_lockprof(void)
{
- return xsm_call(lockprof());
+ return xsm_ops->lockprof();
}

static inline int xsm_cpupool_op(void)
{
- return xsm_call(cpupool_op());
+ return xsm_ops->cpupool_op();
}

static inline int xsm_sched_op(void)
{
- return xsm_call(sched_op());
+ return xsm_ops->sched_op();
}

-static inline long __do_xsm_op (XEN_GUEST_HANDLE(xsm_op_t) op)
+static inline long xsm___do_xsm_op (XEN_GUEST_HANDLE(xsm_op_t) op)
{
-#ifdef XSM_ENABLE
return xsm_ops->__do_xsm_op(op);
-#else
- return -ENOSYS;
-#endif
-}
-
-#ifdef XSM_ENABLE
-extern int xsm_init(unsigned long *module_map, const multiboot_info_t *mbi,
- void *(*bootstrap_map)(const module_t *));
-extern int xsm_policy_init(unsigned long *module_map,
- const multiboot_info_t *mbi,
- void *(*bootstrap_map)(const module_t *));
-extern int register_xsm(struct xsm_operations *ops);
-extern int unregister_xsm(struct xsm_operations *ops);
-#else
-static inline int xsm_init (unsigned long *module_map,
- const multiboot_info_t *mbi,
- void *(*bootstrap_map)(const module_t *))
-{
- return 0;
}
-#endif

#ifdef CONFIG_X86
static inline int xsm_shadow_control (struct domain *d, uint32_t op)
{
- return xsm_call(shadow_control(d, op));
+ return xsm_ops->shadow_control(d, op);
}

static inline int xsm_getpageframeinfo (struct domain *d)
{
- return xsm_call(getpageframeinfo(d));
+ return xsm_ops->getpageframeinfo(d);
}

static inline int xsm_getmemlist (struct domain *d)
{
- return xsm_call(getmemlist(d));
+ return xsm_ops->getmemlist(d);
}

static inline int xsm_hypercall_init (struct domain *d)
{
- return xsm_call(hypercall_init(d));
+ return xsm_ops->hypercall_init(d);
}

static inline int xsm_hvmcontext (struct domain *d, uint32_t cmd)
{
- return xsm_call(hvmcontext(d, cmd));
+ return xsm_ops->hvmcontext(d, cmd);
}

static inline int xsm_address_size (struct domain *d, uint32_t cmd)
{
- return xsm_call(address_size(d, cmd));
+ return xsm_ops->address_size(d, cmd);
}

static inline int xsm_machine_address_size (struct domain *d, uint32_t cmd)
{
- return xsm_call(machine_address_size(d, cmd));
+ return xsm_ops->machine_address_size(d, cmd);
}

static inline int xsm_hvm_param (struct domain *d, unsigned long op)
{
- return xsm_call(hvm_param(d, op));
+ return xsm_ops->hvm_param(d, op);
}

static inline int xsm_hvm_set_pci_intx_level (struct domain *d)
{
- return xsm_call(hvm_set_pci_intx_level(d));
+ return xsm_ops->hvm_set_pci_intx_level(d);
}

static inline int xsm_hvm_set_isa_irq_level (struct domain *d)
{
- return xsm_call(hvm_set_isa_irq_level(d));
+ return xsm_ops->hvm_set_isa_irq_level(d);
}

static inline int xsm_hvm_set_pci_link_route (struct domain *d)
{
- return xsm_call(hvm_set_pci_link_route(d));
+ return xsm_ops->hvm_set_pci_link_route(d);
}

static inline int xsm_hvm_inject_msi (struct domain *d)
{
- return xsm_call(hvm_inject_msi(d));
+ return xsm_ops->hvm_inject_msi(d);
}

static inline int xsm_mem_event (struct domain *d)
{
- return xsm_call(mem_event(d));
+ return xsm_ops->mem_event(d);
}

static inline int xsm_mem_sharing (struct domain *d)
{
- return xsm_call(mem_sharing(d));
+ return xsm_ops->mem_sharing(d);
}

static inline int xsm_apic (struct domain *d, int cmd)
{
- return xsm_call(apic(d, cmd));
+ return xsm_ops->apic(d, cmd);
}

static inline int xsm_xen_settime (void)
{
- return xsm_call(xen_settime());
+ return xsm_ops->xen_settime();
}

static inline int xsm_memtype (uint32_t access)
{
- return xsm_call(memtype(access));
+ return xsm_ops->memtype(access);
}

static inline int xsm_microcode (void)
{
- return xsm_call(microcode());
+ return xsm_ops->microcode();
}

static inline int xsm_physinfo (void)
{
- return xsm_call(physinfo());
+ return xsm_ops->physinfo();
}

static inline int xsm_platform_quirk (uint32_t quirk)
{
- return xsm_call(platform_quirk(quirk));
+ return xsm_ops->platform_quirk(quirk);
}

static inline int xsm_firmware_info (void)
{
- return xsm_call(firmware_info());
+ return xsm_ops->firmware_info();
}

static inline int xsm_efi_call (void)
{
- return xsm_call(efi_call());
+ return xsm_ops->efi_call();
}

static inline int xsm_acpi_sleep (void)
{
- return xsm_call(acpi_sleep());
+ return xsm_ops->acpi_sleep();
}

static inline int xsm_change_freq (void)
{
- return xsm_call(change_freq());
+ return xsm_ops->change_freq();
}

static inline int xsm_getidletime (void)
{
- return xsm_call(getidletime());
+ return xsm_ops->getidletime();
}

static inline int xsm_machine_memory_map(void)
{
- return xsm_call(machine_memory_map());
+ return xsm_ops->machine_memory_map();
}

static inline int xsm_domain_memory_map(struct domain *d)
{
- return xsm_call(domain_memory_map(d));
+ return xsm_ops->domain_memory_map(d);
}

static inline int xsm_mmu_normal_update (struct domain *d, struct domain *t,
struct domain *f, intpte_t fpte)
{
- return xsm_call(mmu_normal_update(d, t, f, fpte));
+ return xsm_ops->mmu_normal_update(d, t, f, fpte);
}

static inline int xsm_mmu_machphys_update (struct domain *d1, struct domain *d2,
unsigned long mfn)
{
- return xsm_call(mmu_machphys_update(d1, d2, mfn));
+ return xsm_ops->mmu_machphys_update(d1, d2, mfn);
}

static inline int xsm_update_va_mapping(struct domain *d, struct domain *f,
l1_pgentry_t pte)
{
- return xsm_call(update_va_mapping(d, f, pte));
+ return xsm_ops->update_va_mapping(d, f, pte);
}

static inline int xsm_add_to_physmap(struct domain *d1, struct domain *d2)
{
- return xsm_call(add_to_physmap(d1, d2));
+ return xsm_ops->add_to_physmap(d1, d2);
}

static inline int xsm_sendtrigger(struct domain *d)
{
- return xsm_call(sendtrigger(d));
+ return xsm_ops->sendtrigger(d);
}

static inline int xsm_bind_pt_irq(struct domain *d,
struct xen_domctl_bind_pt_irq *bind)
{
- return xsm_call(bind_pt_irq(d, bind));
+ return xsm_ops->bind_pt_irq(d, bind);
}

static inline int xsm_unbind_pt_irq(struct domain *d,
struct xen_domctl_bind_pt_irq *bind)
{
- return xsm_call(unbind_pt_irq(d, bind));
+ return xsm_ops->unbind_pt_irq(d, bind);
}

static inline int xsm_pin_mem_cacheattr(struct domain *d)
{
- return xsm_call(pin_mem_cacheattr(d));
+ return xsm_ops->pin_mem_cacheattr(d);
}

static inline int xsm_ext_vcpucontext(struct domain *d, uint32_t cmd)
{
- return xsm_call(ext_vcpucontext(d, cmd));
+ return xsm_ops->ext_vcpucontext(d, cmd);
}
static inline int xsm_vcpuextstate(struct domain *d, uint32_t cmd)
{
- return xsm_call(vcpuextstate(d, cmd));
+ return xsm_ops->vcpuextstate(d, cmd);
}

static inline int xsm_ioport_permission (struct domain *d, uint32_t s, uint32_t e, uint8_t allow)
{
- return xsm_call(ioport_permission(d, s, e, allow));
+ return xsm_ops->ioport_permission(d, s, e, allow);
}

static inline int xsm_ioport_mapping (struct domain *d, uint32_t s, uint32_t e, uint8_t allow)
{
- return xsm_call(ioport_mapping(d, s, e, allow));
+ return xsm_ops->ioport_mapping(d, s, e, allow);
}
#endif /* CONFIG_X86 */

+extern int xsm_init(unsigned long *module_map, const multiboot_info_t *mbi,
+ void *(*bootstrap_map)(const module_t *));
+extern int xsm_policy_init(unsigned long *module_map,
+ const multiboot_info_t *mbi,
+ void *(*bootstrap_map)(const module_t *));
+extern int register_xsm(struct xsm_operations *ops);
+extern int unregister_xsm(struct xsm_operations *ops);
+
extern struct xsm_operations dummy_xsm_ops;
extern void xsm_fixup_ops(struct xsm_operations *ops);

+#else /* XSM_ENABLE */
+
+#define XSM_DEFAULT(type, name) inline type xsm_ ## name
+#include <xsm/dummy.h>
+
+static inline int xsm_init (unsigned long *module_map,
+ const multiboot_info_t *mbi,
+ void *(*bootstrap_map)(const module_t *))
+{
+ return 0;
+}
+#endif /* XSM_ENABLE */
+
#endif /* __XSM_H */
diff --git a/xen/xsm/dummy.c b/xen/xsm/dummy.c
index a5dbfe7..af532b8 100644
--- a/xen/xsm/dummy.c
+++ b/xen/xsm/dummy.c
@@ -10,621 +10,8 @@
* as published by the Free Software Foundation.
*/

-#include <xen/sched.h>
-#include <xsm/xsm.h>
-
-static void dummy_security_domaininfo(struct domain *d,
- struct xen_domctl_getdomaininfo *info)
-{
- return;
-}
-
-static int dummy_setvcpucontext(struct domain *d)
-{
- return 0;
-}
-
-static int dummy_pausedomain (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_unpausedomain (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_resumedomain (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_domain_create(struct domain *d, u32 ssidref)
-{
- return 0;
-}
-
-static int dummy_max_vcpus(struct domain *d)
-{
- return 0;
-}
-
-static int dummy_destroydomain (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_vcpuaffinity (int cmd, struct domain *d)
-{
- return 0;
-}
-
-static int dummy_scheduler (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_getdomaininfo (struct domain *d)
-{
- if ( !IS_PRIV(current->domain) )
- return -EPERM;
- return 0;
-}
-
-static int dummy_getvcpucontext (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_getvcpuinfo (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_domain_settime (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_set_target (struct domain *d, struct domain *e)
-{
- return 0;
-}
-
-static int dummy_domctl(struct domain *d, int cmd)
-{
- return 0;
-}
-
-static int dummy_set_virq_handler(struct domain *d, uint32_t virq)
-{
- return 0;
-}
-
-static int dummy_tbufcontrol (void)
-{
- return 0;
-}
-
-static int dummy_readconsole (uint32_t clear)
-{
- return 0;
-}
-
-static int dummy_sched_id (void)
-{
- return 0;
-}
-
-static int dummy_setdomainmaxmem (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_setdomainhandle (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_setdebugging (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_perfcontrol (void)
-{
- return 0;
-}
-
-static int dummy_debug_keys (void)
-{
- return 0;
-}
-
-static int dummy_getcpuinfo (void)
-{
- return 0;
-}
-
-static int dummy_get_pmstat (void)
-{
- return 0;
-}
-
-static int dummy_setpminfo (void)
-{
- return 0;
-}
-
-static int dummy_pm_op (void)
-{
- return 0;
-}
-
-static int dummy_do_mca (void)
-{
- return 0;
-}
-
-static int dummy_availheap (void)
-{
- return 0;
-}
-
-static int dummy_alloc_security_domain (struct domain *d)
-{
- return 0;
-}
-
-static void dummy_free_security_domain (struct domain *d)
-{
- return;
-}
-
-static int dummy_grant_mapref (struct domain *d1, struct domain *d2,
- uint32_t flags)
-{
- return 0;
-}
-
-static int dummy_grant_unmapref (struct domain *d1, struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_grant_setup (struct domain *d1, struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_grant_transfer (struct domain *d1, struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_grant_copy (struct domain *d1, struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_grant_query_size (struct domain *d1, struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_memory_adjust_reservation (struct domain *d1,
- struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_memory_stat_reservation (struct domain *d1, struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_console_io (struct domain *d, int cmd)
-{
- return 0;
-}
-
-static int dummy_profile (struct domain *d, int op)
-{
- return 0;
-}
-
-static int dummy_kexec (void)
-{
- return 0;
-}
-
-static int dummy_schedop_shutdown (struct domain *d1, struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_memory_pin_page(struct domain *d1, struct domain *d2, struct page_info *page)
-{
- return 0;
-}
-
-static int dummy_evtchn_unbound (struct domain *d, struct evtchn *chn,
- domid_t id2)
-{
- return 0;
-}
-
-static int dummy_evtchn_interdomain (struct domain *d1, struct evtchn
- *chan1, struct domain *d2, struct evtchn *chan2)
-{
- return 0;
-}
-
-static void dummy_evtchn_close_post (struct evtchn *chn)
-{
- return;
-}
-
-static int dummy_evtchn_send (struct domain *d, struct evtchn *chn)
-{
- return 0;
-}
-
-static int dummy_evtchn_status (struct domain *d, struct evtchn *chn)
-{
- return 0;
-}
-
-static int dummy_evtchn_reset (struct domain *d1, struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_alloc_security_evtchn (struct evtchn *chn)
-{
- return 0;
-}
-
-static void dummy_free_security_evtchn (struct evtchn *chn)
-{
- return;
-}
-
-static char *dummy_show_security_evtchn (struct domain *d, const struct evtchn *chn)
-{
- return NULL;
-}
-
-static int dummy_get_pod_target(struct domain *d)
-{
- return 0;
-}
-
-static int dummy_set_pod_target(struct domain *d)
-{
- return 0;
-}
-
-static int dummy_get_device_group (uint32_t machine_bdf)
-{
- return 0;
-}
-
-static int dummy_test_assign_device (uint32_t machine_bdf)
-{
- return 0;
-}
-
-static int dummy_assign_device (struct domain *d, uint32_t machine_bdf)
-{
- return 0;
-}
-
-static int dummy_deassign_device (struct domain *d, uint32_t machine_bdf)
-{
- return 0;
-}
-
-static int dummy_resource_plug_core (void)
-{
- return 0;
-}
-
-static int dummy_resource_unplug_core (void)
-{
- return 0;
-}
-
-static int dummy_resource_plug_pci (uint32_t machine_bdf)
-{
- return 0;
-}
-
-static int dummy_resource_unplug_pci (uint32_t machine_bdf)
-{
- return 0;
-}
-
-static int dummy_resource_setup_pci (uint32_t machine_bdf)
-{
- return 0;
-}
-
-static int dummy_resource_setup_gsi (int gsi)
-{
- return 0;
-}
-
-static int dummy_resource_setup_misc (void)
-{
- return 0;
-}
-
-static int dummy_page_offline (uint32_t cmd)
-{
- return 0;
-}
-
-static int dummy_lockprof (void)
-{
- return 0;
-}
-
-static int dummy_cpupool_op (void)
-{
- return 0;
-}
-
-static int dummy_sched_op (void)
-{
- return 0;
-}
-
-static long dummy___do_xsm_op(XEN_GUEST_HANDLE(xsm_op_t) op)
-{
- return -ENOSYS;
-}
-
-static char *dummy_show_irq_sid (int irq)
-{
- return NULL;
-}
-
-static int dummy_map_domain_pirq (struct domain *d, int irq, void *data)
-{
- return 0;
-}
-
-static int dummy_unmap_domain_pirq (struct domain *d, int irq)
-{
- return 0;
-}
-
-static int dummy_irq_permission (struct domain *d, int pirq, uint8_t allow)
-{
- return 0;
-}
-
-static int dummy_iomem_permission (struct domain *d, uint64_t s, uint64_t e, uint8_t allow)
-{
- return 0;
-}
-
-static int dummy_iomem_mapping (struct domain *d, uint64_t s, uint64_t e, uint8_t allow)
-{
- return 0;
-}
-
-static int dummy_pci_config_permission (struct domain *d, uint32_t machine_bdf,
- uint16_t start, uint16_t end,
- uint8_t access)
-{
- return 0;
-}
-
-#ifdef CONFIG_X86
-static int dummy_shadow_control (struct domain *d, uint32_t op)
-{
- return 0;
-}
-
-static int dummy_getpageframeinfo (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_getmemlist (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_hypercall_init (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_hvmcontext (struct domain *d, uint32_t cmd)
-{
- return 0;
-}
-
-static int dummy_address_size (struct domain *d, uint32_t cmd)
-{
- return 0;
-}
-
-static int dummy_machine_address_size (struct domain *d, uint32_t cmd)
-{
- return 0;
-}
-
-static int dummy_hvm_param (struct domain *d, unsigned long op)
-{
- return 0;
-}
-
-static int dummy_hvm_set_pci_intx_level (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_hvm_set_isa_irq_level (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_hvm_set_pci_link_route (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_hvm_inject_msi (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_mem_event (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_mem_sharing (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_apic (struct domain *d, int cmd)
-{
- return 0;
-}
-
-static int dummy_xen_settime (void)
-{
- return 0;
-}
-
-static int dummy_memtype (uint32_t access)
-{
- return 0;
-}
-
-static int dummy_microcode (void)
-{
- return 0;
-}
-
-static int dummy_physinfo (void)
-{
- return 0;
-}
-
-static int dummy_platform_quirk (uint32_t quirk)
-{
- return 0;
-}
-
-static int dummy_firmware_info (void)
-{
- return 0;
-}
-
-static int dummy_efi_call(void)
-{
- return 0;
-}
-
-static int dummy_acpi_sleep (void)
-{
- return 0;
-}
-
-static int dummy_change_freq (void)
-{
- return 0;
-}
-
-static int dummy_getidletime (void)
-{
- return 0;
-}
-
-static int dummy_machine_memory_map (void)
-{
- return 0;
-}
-
-static int dummy_domain_memory_map (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_mmu_normal_update (struct domain *d, struct domain *t,
- struct domain *f, intpte_t fpte)
-{
- return 0;
-}
-
-static int dummy_mmu_machphys_update (struct domain *d, struct domain *f, unsigned long mfn)
-{
- return 0;
-}
-
-static int dummy_update_va_mapping (struct domain *d, struct domain *f,
- l1_pgentry_t pte)
-{
- return 0;
-}
-
-static int dummy_add_to_physmap (struct domain *d1, struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_remove_from_physmap (struct domain *d1, struct domain *d2)
-{
- return 0;
-}
-
-static int dummy_sendtrigger (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_bind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *bind)
-{
- return 0;
-}
-
-static int dummy_unbind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *bind)
-{
- return 0;
-}
-
-static int dummy_pin_mem_cacheattr (struct domain *d)
-{
- return 0;
-}
-
-static int dummy_ext_vcpucontext (struct domain *d, uint32_t cmd)
-{
- return 0;
-}
-
-static int dummy_vcpuextstate (struct domain *d, uint32_t cmd)
-{
- return 0;
-}
-
-static int dummy_ioport_permission (struct domain *d, uint32_t s, uint32_t e, uint8_t allow)
-{
- return 0;
-}
-
-static int dummy_ioport_mapping (struct domain *d, uint32_t s, uint32_t e, uint8_t allow)
-{
- return 0;
-}
-#endif
+#define XSM_DEFAULT(type, name) type dummy_ ## name
+#include <xsm/dummy.h>

struct xsm_operations dummy_xsm_ops;

diff --git a/xen/xsm/xsm_core.c b/xen/xsm/xsm_core.c
index 96c8669..c4c85c0 100644
--- a/xen/xsm/xsm_core.c
+++ b/xen/xsm/xsm_core.c
@@ -113,7 +113,7 @@ int unregister_xsm(struct xsm_operations *ops)

long do_xsm_op (XEN_GUEST_HANDLE(xsm_op_t) op)
{
- return __do_xsm_op(op);
+ return xsm___do_xsm_op(op);
}


--
1.7.11.4


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel