[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Xen-devel] [PATCH 01/22] xsm: Use the dummy XSM module if XSM is disabled



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@xxxxxxxxxxxxx>
Cc: Jan Beulich <jbeulich@xxxxxxxx>
Cc: Keir Fraser <keir@xxxxxxx>
---
 xen/common/domctl.c     |   2 -
 xen/include/xsm/dummy.h | 613 ++++++++++++++++++++++++++++++++++++++++++++++++
 xen/include/xsm/xsm.h   | 291 +++++++++++------------
 xen/xsm/dummy.c         | 607 +----------------------------------------------
 xen/xsm/flask/hooks.c   |   2 +-
 xen/xsm/xsm_core.c      |   2 +-
 6 files changed, 763 insertions(+), 754 deletions(-)
 create mode 100644 xen/include/xsm/dummy.h

diff --git a/xen/common/domctl.c b/xen/common/domctl.c
index ca789bb..05d9c55 100644
--- a/xen/common/domctl.c
+++ b/xen/common/domctl.c
@@ -279,10 +279,8 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) 
u_domctl)
         }
         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..075572f
--- /dev/null
+++ b/xen/include/xsm/dummy.h
@@ -0,0 +1,613 @@
+/*
+ *  Default XSM hooks - IS_PRIV and IS_PRIV_FOR checks
+ *
+ *  Author: Daniel De Graaf <dgdegra@xxxxxxxxxxxxx>
+ *
+ *  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_INLINE void xsm_security_domaininfo(struct domain *d,
+                                    struct xen_domctl_getdomaininfo *info)
+{
+    return;
+}
+
+static XSM_INLINE int xsm_setvcpucontext(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_pausedomain(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_unpausedomain(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_resumedomain(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_domain_create(struct domain *d, u32 ssidref)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_max_vcpus(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_destroydomain(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_vcpuaffinity(int cmd, struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_scheduler(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_getdomaininfo(struct domain *d)
+{
+    if ( !IS_PRIV(current->domain) )
+        return -EPERM;
+    return 0;
+}
+
+static XSM_INLINE int xsm_getvcpucontext(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_getvcpuinfo(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_domain_settime(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_set_target(struct domain *d, struct domain *e)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_domctl(struct domain *d, int cmd)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_set_virq_handler(struct domain *d, uint32_t virq)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_tbufcontrol(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_readconsole(uint32_t clear)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_sched_id(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_setdomainmaxmem(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_setdomainhandle(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_setdebugging(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_perfcontrol(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_debug_keys(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_getcpuinfo(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_get_pmstat(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_setpminfo(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_pm_op(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_do_mca(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_availheap(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_alloc_security_domain(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE void xsm_free_security_domain(struct domain *d)
+{
+    return;
+}
+
+static XSM_INLINE int xsm_grant_mapref(struct domain *d1, struct domain *d2,
+                                                                uint32_t flags)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_grant_unmapref(struct domain *d1, struct domain *d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_grant_setup(struct domain *d1, struct domain *d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_grant_transfer(struct domain *d1, struct domain *d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_grant_copy(struct domain *d1, struct domain *d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_grant_query_size(struct domain *d1, struct domain 
*d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_memory_adjust_reservation(struct domain *d1,
+                                                            struct domain *d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_memory_stat_reservation(struct domain *d1, struct 
domain *d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_console_io(struct domain *d, int cmd)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_profile(struct domain *d, int op)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_kexec(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_schedop_shutdown(struct domain *d1, struct domain 
*d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_memory_pin_page(struct domain *d1, struct domain *d2,
+                                          struct page_info *page)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_evtchn_unbound(struct domain *d, struct evtchn *chn,
+                                         domid_t id2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_evtchn_interdomain(struct domain *d1, struct evtchn
+                                *chan1, struct domain *d2, struct evtchn 
*chan2)
+{
+    return 0;
+}
+
+static XSM_INLINE void xsm_evtchn_close_post(struct evtchn *chn)
+{
+    return;
+}
+
+static XSM_INLINE int xsm_evtchn_send(struct domain *d, struct evtchn *chn)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_evtchn_status(struct domain *d, struct evtchn *chn)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_evtchn_reset(struct domain *d1, struct domain *d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_alloc_security_evtchn(struct evtchn *chn)
+{
+    return 0;
+}
+
+static XSM_INLINE void xsm_free_security_evtchn(struct evtchn *chn)
+{
+    return;
+}
+
+static XSM_INLINE char *xsm_show_security_evtchn(struct domain *d, const 
struct evtchn *chn)
+{
+    return NULL;
+}
+
+static XSM_INLINE int xsm_get_pod_target(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_set_pod_target(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_get_device_group(uint32_t machine_bdf)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_test_assign_device(uint32_t machine_bdf)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_assign_device(struct domain *d, uint32_t machine_bdf)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_deassign_device(struct domain *d, uint32_t 
machine_bdf)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_resource_plug_core(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_resource_unplug_core(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_resource_plug_pci(uint32_t machine_bdf)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_resource_unplug_pci(uint32_t machine_bdf)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_resource_setup_pci(uint32_t machine_bdf)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_resource_setup_gsi(int gsi)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_resource_setup_misc(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_page_offline(uint32_t cmd)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_lockprof(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_cpupool_op(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_sched_op(void)
+{
+    return 0;
+}
+
+static XSM_INLINE long xsm_do_xsm_op(XEN_GUEST_HANDLE_PARAM(xsm_op_t) op)
+{
+    return -ENOSYS;
+}
+
+static XSM_INLINE char *xsm_show_irq_sid(int irq)
+{
+    return NULL;
+}
+
+static XSM_INLINE int xsm_map_domain_pirq(struct domain *d, int irq, void 
*data)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_irq_permission(struct domain *d, int pirq, uint8_t 
allow)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_iomem_permission(struct domain *d, uint64_t s, 
uint64_t e, uint8_t allow)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_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_INLINE int xsm_shadow_control(struct domain *d, uint32_t op)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_getpageframeinfo(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_getmemlist(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_hypercall_init(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_hvmcontext(struct domain *d, uint32_t cmd)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_address_size(struct domain *d, uint32_t cmd)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_machine_address_size(struct domain *d, uint32_t cmd)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_hvm_param(struct domain *d, unsigned long op)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_hvm_set_pci_intx_level(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_hvm_set_isa_irq_level(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_hvm_set_pci_link_route(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_hvm_inject_msi(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_mem_event(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_mem_sharing(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_apic(struct domain *d, int cmd)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_xen_settime(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_memtype(uint32_t access)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_microcode(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_physinfo(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_platform_quirk(uint32_t quirk)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_firmware_info(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_efi_call(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_acpi_sleep(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_change_freq(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_getidletime(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_machine_memory_map(void)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_domain_memory_map(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_mmu_normal_update(struct domain *d, struct domain *t,
+                                            struct domain *f, intpte_t fpte)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_mmu_machphys_update(struct domain *d, struct domain 
*f,
+                                              unsigned long mfn)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_update_va_mapping(struct domain *d, struct domain 
*f, 
+                                                            l1_pgentry_t pte)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_add_to_physmap(struct domain *d1, struct domain *d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_remove_from_physmap(struct domain *d1, struct domain 
*d2)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_sendtrigger(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_bind_pt_irq(struct domain *d, struct 
xen_domctl_bind_pt_irq *bind)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_unbind_pt_irq(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_pin_mem_cacheattr(struct domain *d)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_ext_vcpucontext(struct domain *d, uint32_t cmd)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_vcpuextstate(struct domain *d, uint32_t cmd)
+{
+    return 0;
+}
+
+static XSM_INLINE int xsm_ioport_permission(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 a949c1e..73169fe 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
@@ -139,7 +133,7 @@ struct xsm_operations {
     int (*cpupool_op)(void);
     int (*sched_op)(void);
 
-    long (*__do_xsm_op) (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op);
+    long (*do_xsm_op) (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op);
 
 #ifdef CONFIG_X86
     int (*shadow_control) (struct domain *d, uint32_t op);
@@ -184,629 +178,630 @@ struct xsm_operations {
 #endif
 };
 
-#endif
-
 extern struct xsm_operations *xsm_ops;
 
+#ifndef XSM_NO_WRAPPERS
+
 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_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_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_PARAM(xsm_op_t) op)
+static inline long xsm_do_xsm_op (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op)
 {
-#ifdef XSM_ENABLE
-    return xsm_ops->__do_xsm_op(op);
-#else
-    return -ENOSYS;
-#endif
+    return xsm_ops->do_xsm_op(op);
 }
 
-#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)
 {
-    return xsm_call(unbind_pt_irq(d));
+    return xsm_ops->unbind_pt_irq(d);
 }
 
 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);
 }
 #endif /* CONFIG_X86 */
+#endif /* XSM_NO_WRAPPERS */
+
+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_INLINE inline
+#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 b726eaf..a2ce733 100644
--- a/xen/xsm/dummy.c
+++ b/xen/xsm/dummy.c
@@ -10,606 +10,9 @@
  *  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_PARAM(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_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_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)
-{
-    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;
-}
-#endif
+#define XSM_NO_WRAPPERS
+#define XSM_INLINE /* */
+#include <xsm/dummy.h>
 
 struct xsm_operations dummy_xsm_ops;
 
@@ -617,7 +20,7 @@ struct xsm_operations dummy_xsm_ops;
     do {                                                               \
         if ( !ops->function )                                          \
         {                                                              \
-            ops->function = dummy_##function;                          \
+            ops->function = xsm_##function;                            \
             if (ops != &dummy_xsm_ops)                                 \
                 dprintk(XENLOG_DEBUG, "Had to override the " #function \
                     " security operation with the dummy one.\n");      \
@@ -715,7 +118,7 @@ void xsm_fixup_ops (struct xsm_operations *ops)
     set_to_dummy_if_null(ops, cpupool_op);
     set_to_dummy_if_null(ops, sched_op);
 
-    set_to_dummy_if_null(ops, __do_xsm_op);
+    set_to_dummy_if_null(ops, do_xsm_op);
 
 #ifdef CONFIG_X86
     set_to_dummy_if_null(ops, shadow_control);
diff --git a/xen/xsm/flask/hooks.c b/xen/xsm/flask/hooks.c
index 782e28c..ead5958 100644
--- a/xen/xsm/flask/hooks.c
+++ b/xen/xsm/flask/hooks.c
@@ -1550,7 +1550,7 @@ static struct xsm_operations flask_ops = {
     .cpupool_op = flask_cpupool_op,
     .sched_op = flask_sched_op,
 
-    .__do_xsm_op = do_flask_op,
+    .do_xsm_op = do_flask_op,
 
 #ifdef CONFIG_X86
     .shadow_control = flask_shadow_control,
diff --git a/xen/xsm/xsm_core.c b/xen/xsm/xsm_core.c
index 46287cb..ca28f91 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_PARAM(xsm_op_t) op)
 {
-    return __do_xsm_op(op);
+    return xsm_do_xsm_op(op);
 }
 
 
-- 
1.7.11.7


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


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.