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: Jan Beulich <jbeulich@suse.com>
Cc: Keir Fraser <keir@xen.org>
---
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@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_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@lists.xen.org
http://lists.xen.org/xen-devel