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

[Xen-devel] [PATCH 1/5] Remove XSM_DEFAULT macro



This fixes ctags so that it can find the default XSM hooks.

Signed-off-by: Daniel De Graaf <dgdegra@xxxxxxxxxxxxx>

---
 xen/include/xsm/dummy.h | 256 ++++++++++++++++++++++++------------------------
 xen/include/xsm/xsm.h   |   5 +-
 xen/xsm/dummy.c         |   5 +-
 3 files changed, 135 insertions(+), 131 deletions(-)

diff --git a/xen/include/xsm/dummy.h b/xen/include/xsm/dummy.h
index 040b463..fa78785 100644
--- a/xen/include/xsm/dummy.h
+++ b/xen/include/xsm/dummy.h
@@ -11,83 +11,83 @@
 #include <xen/sched.h>
 #include <xsm/xsm.h>
 
-static XSM_DEFAULT(void, security_domaininfo)(struct domain *d,
+static XSM_INLINE void xsm_security_domaininfo(struct domain *d,
                                     struct xen_domctl_getdomaininfo *info)
 {
     return;
 }
 
-static XSM_DEFAULT(int, setvcpucontext)(struct domain *d)
+static XSM_INLINE int xsm_setvcpucontext(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, pausedomain) (struct domain *d)
+static XSM_INLINE int xsm_pausedomain(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, unpausedomain) (struct domain *d)
+static XSM_INLINE int xsm_unpausedomain(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, resumedomain) (struct domain *d)
+static XSM_INLINE int xsm_resumedomain(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, domain_create)(struct domain *d, u32 ssidref)
+static XSM_INLINE int xsm_domain_create(struct domain *d, u32 ssidref)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, max_vcpus)(struct domain *d)
+static XSM_INLINE int xsm_max_vcpus(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, destroydomain) (struct domain *d)
+static XSM_INLINE int xsm_destroydomain(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, vcpuaffinity) (int cmd, struct domain *d)
+static XSM_INLINE int xsm_vcpuaffinity(int cmd, struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, scheduler) (struct domain *d)
+static XSM_INLINE int xsm_scheduler(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, getdomaininfo) (struct domain *d)
+static XSM_INLINE int xsm_getdomaininfo(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, getvcpucontext) (struct domain *d)
+static XSM_INLINE int xsm_getvcpucontext(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, getvcpuinfo) (struct domain *d)
+static XSM_INLINE int xsm_getvcpuinfo(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, domain_settime) (struct domain *d)
+static XSM_INLINE int xsm_domain_settime(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, set_target) (struct domain *d, struct domain *e)
+static XSM_INLINE int xsm_set_target(struct domain *d, struct domain *e)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, domctl)(struct domain *d, int cmd)
+static XSM_INLINE int xsm_domctl(struct domain *d, int cmd)
 {
     switch ( cmd )
     {
@@ -106,143 +106,143 @@ static XSM_DEFAULT(int, domctl)(struct domain *d, int 
cmd)
     return 0;
 }
 
-static XSM_DEFAULT(int, sysctl)(int cmd)
+static XSM_INLINE int xsm_sysctl(int cmd)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, set_virq_handler)(struct domain *d, uint32_t virq)
+static XSM_INLINE int xsm_set_virq_handler(struct domain *d, uint32_t virq)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, tbufcontrol) (void)
+static XSM_INLINE int xsm_tbufcontrol(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, readconsole) (uint32_t clear)
+static XSM_INLINE int xsm_readconsole(uint32_t clear)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, sched_id) (void)
+static XSM_INLINE int xsm_sched_id(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, setdomainmaxmem) (struct domain *d)
+static XSM_INLINE int xsm_setdomainmaxmem(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, setdomainhandle) (struct domain *d)
+static XSM_INLINE int xsm_setdomainhandle(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, setdebugging) (struct domain *d)
+static XSM_INLINE int xsm_setdebugging(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, perfcontrol) (void)
+static XSM_INLINE int xsm_perfcontrol(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, debug_keys) (void)
+static XSM_INLINE int xsm_debug_keys(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, getcpuinfo) (void)
+static XSM_INLINE int xsm_getcpuinfo(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, get_pmstat) (void)
+static XSM_INLINE int xsm_get_pmstat(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, setpminfo) (void)
+static XSM_INLINE int xsm_setpminfo(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, pm_op) (void)
+static XSM_INLINE int xsm_pm_op(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, do_mca) (void)
+static XSM_INLINE int xsm_do_mca(void)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, availheap) (void)
+static XSM_INLINE int xsm_availheap(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, alloc_security_domain) (struct domain *d)
+static XSM_INLINE int xsm_alloc_security_domain(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(void, free_security_domain) (struct domain *d)
+static XSM_INLINE void xsm_free_security_domain(struct domain *d)
 {
     return;
 }
 
-static XSM_DEFAULT(int, grant_mapref) (struct domain *d1, struct domain *d2,
+static XSM_INLINE int xsm_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)
+static XSM_INLINE int xsm_grant_unmapref(struct domain *d1, struct domain *d2)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, grant_setup) (struct domain *d1, struct domain *d2)
+static XSM_INLINE int xsm_grant_setup(struct domain *d1, struct domain *d2)
 {
     if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, grant_transfer) (struct domain *d1, struct domain *d2)
+static XSM_INLINE int xsm_grant_transfer(struct domain *d1, struct domain *d2)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, grant_copy) (struct domain *d1, struct domain *d2)
+static XSM_INLINE int xsm_grant_copy(struct domain *d1, struct domain *d2)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, grant_query_size) (struct domain *d1, struct domain 
*d2)
+static XSM_INLINE int xsm_grant_query_size(struct domain *d1, struct domain 
*d2)
 {
     if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, memory_exchange) (struct domain *d)
+static XSM_INLINE int xsm_memory_exchange(struct domain *d)
 {
     if ( d != current->domain && !IS_PRIV_FOR(current->domain, d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, memory_adjust_reservation) (struct domain *d1,
+static XSM_INLINE int xsm_memory_adjust_reservation(struct domain *d1,
                                                             struct domain *d2)
 {
     if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) )
@@ -250,14 +250,14 @@ static XSM_DEFAULT(int, memory_adjust_reservation) 
(struct domain *d1,
     return 0;
 }
 
-static XSM_DEFAULT(int, memory_stat_reservation) (struct domain *d1, struct 
domain *d2)
+static XSM_INLINE int xsm_memory_stat_reservation(struct domain *d1, struct 
domain *d2)
 {
     if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, console_io) (struct domain *d, int cmd)
+static XSM_INLINE int xsm_console_io(struct domain *d, int cmd)
 {
 #ifndef VERBOSE
     if ( !IS_PRIV(current->domain) )
@@ -266,32 +266,32 @@ static XSM_DEFAULT(int, console_io) (struct domain *d, 
int cmd)
     return 0;
 }
 
-static XSM_DEFAULT(int, profile) (struct domain *d, int op)
+static XSM_INLINE int xsm_profile(struct domain *d, int op)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, kexec) (void)
+static XSM_INLINE int xsm_kexec(void)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, schedop_shutdown) (struct domain *d1, struct domain 
*d2)
+static XSM_INLINE int xsm_schedop_shutdown(struct domain *d1, struct domain 
*d2)
 {
     if ( !IS_PRIV_FOR(d1, d2) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, memory_pin_page) (struct domain *d1, struct domain *d2,
+static XSM_INLINE int xsm_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,
+static XSM_INLINE int xsm_evtchn_unbound(struct domain *d, struct evtchn *chn,
                                          domid_t id2)
 {
     if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) )
@@ -299,200 +299,200 @@ static XSM_DEFAULT(int, evtchn_unbound) (struct domain 
*d, struct evtchn *chn,
     return 0;
 }
 
-static XSM_DEFAULT(int, evtchn_interdomain) (struct domain *d1, struct evtchn
+static XSM_INLINE int xsm_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)
+static XSM_INLINE void xsm_evtchn_close_post(struct evtchn *chn)
 {
     return;
 }
 
-static XSM_DEFAULT(int, evtchn_send) (struct domain *d, struct evtchn *chn)
+static XSM_INLINE int xsm_evtchn_send(struct domain *d, struct evtchn *chn)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, evtchn_status) (struct domain *d, struct evtchn *chn)
+static XSM_INLINE int xsm_evtchn_status(struct domain *d, struct evtchn *chn)
 {
     if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, evtchn_reset) (struct domain *d1, struct domain *d2)
+static XSM_INLINE int xsm_evtchn_reset(struct domain *d1, struct domain *d2)
 {
     if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, alloc_security_evtchn) (struct evtchn *chn)
+static XSM_INLINE int xsm_alloc_security_evtchn(struct evtchn *chn)
 {
     return 0;
 }
 
-static XSM_DEFAULT(void, free_security_evtchn) (struct evtchn *chn)
+static XSM_INLINE void xsm_free_security_evtchn(struct evtchn *chn)
 {
     return;
 }
 
-static XSM_DEFAULT(char *, show_security_evtchn) (struct domain *d, const 
struct evtchn *chn)
+static XSM_INLINE char * xsm_show_security_evtchn(struct domain *d, const 
struct evtchn *chn)
 {
     return NULL;
 }
 
-static XSM_DEFAULT(int, get_pod_target)(struct domain *d)
+static XSM_INLINE int xsm_get_pod_target(struct domain *d)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, set_pod_target)(struct domain *d)
+static XSM_INLINE int xsm_set_pod_target(struct domain *d)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, get_device_group) (uint32_t machine_bdf)
+static XSM_INLINE int xsm_get_device_group(uint32_t machine_bdf)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, test_assign_device) (uint32_t machine_bdf)
+static XSM_INLINE int xsm_test_assign_device(uint32_t machine_bdf)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, assign_device) (struct domain *d, uint32_t machine_bdf)
+static XSM_INLINE int xsm_assign_device(struct domain *d, uint32_t machine_bdf)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, deassign_device) (struct domain *d, uint32_t 
machine_bdf)
+static XSM_INLINE int xsm_deassign_device(struct domain *d, uint32_t 
machine_bdf)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, resource_plug_core) (void)
+static XSM_INLINE int xsm_resource_plug_core(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, resource_unplug_core) (void)
+static XSM_INLINE int xsm_resource_unplug_core(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, resource_plug_pci) (uint32_t machine_bdf)
+static XSM_INLINE int xsm_resource_plug_pci(uint32_t machine_bdf)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, resource_unplug_pci) (uint32_t machine_bdf)
+static XSM_INLINE int xsm_resource_unplug_pci(uint32_t machine_bdf)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, resource_setup_pci) (uint32_t machine_bdf)
+static XSM_INLINE int xsm_resource_setup_pci(uint32_t machine_bdf)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, resource_setup_gsi) (int gsi)
+static XSM_INLINE int xsm_resource_setup_gsi(int gsi)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, resource_setup_misc) (void)
+static XSM_INLINE int xsm_resource_setup_misc(void)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, page_offline) (uint32_t cmd)
+static XSM_INLINE int xsm_page_offline(uint32_t cmd)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, lockprof) (void)
+static XSM_INLINE int xsm_lockprof(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, cpupool_op) (void)
+static XSM_INLINE int xsm_cpupool_op(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, sched_op) (void)
+static XSM_INLINE int xsm_sched_op(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, tmem_op) (void)
+static XSM_INLINE int xsm_tmem_op(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, tmem_control) (void)
+static XSM_INLINE int xsm_tmem_control(void)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(long, do_xsm_op)(XEN_GUEST_HANDLE_PARAM(xsm_op_t) op)
+static XSM_INLINE long xsm_do_xsm_op(XEN_GUEST_HANDLE_PARAM(xsm_op_t) op)
 {
     return -ENOSYS;
 }
 
-static XSM_DEFAULT(char *, show_irq_sid) (int irq)
+static XSM_INLINE char * xsm_show_irq_sid(int irq)
 {
     return NULL;
 }
 
-static XSM_DEFAULT(int, map_domain_pirq) (struct domain *d, int irq, void 
*data)
+static XSM_INLINE int xsm_map_domain_pirq(struct domain *d, int irq, void 
*data)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, unmap_domain_pirq) (struct domain *d, int irq)
+static XSM_INLINE int xsm_unmap_domain_pirq(struct domain *d, int irq)
 {
     if ( !IS_PRIV_FOR(current->domain, d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, irq_permission) (struct domain *d, int pirq, uint8_t 
allow)
+static XSM_INLINE int xsm_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)
+static XSM_INLINE int xsm_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)
+static XSM_INLINE int xsm_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,
+static XSM_INLINE int xsm_pci_config_permission(struct domain *d, uint32_t 
machine_bdf,
                                         uint16_t start, uint16_t end,
                                         uint8_t access)
 {
@@ -500,188 +500,188 @@ static XSM_DEFAULT(int, pci_config_permission) (struct 
domain *d, uint32_t machi
 }
 
 #ifdef CONFIG_X86
-static XSM_DEFAULT(int, shadow_control) (struct domain *d, uint32_t op)
+static XSM_INLINE int xsm_shadow_control(struct domain *d, uint32_t op)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, getpageframeinfo) (struct domain *d)
+static XSM_INLINE int xsm_getpageframeinfo(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, getmemlist) (struct domain *d)
+static XSM_INLINE int xsm_getmemlist(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, hypercall_init) (struct domain *d)
+static XSM_INLINE int xsm_hypercall_init(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, hvmcontext) (struct domain *d, uint32_t cmd)
+static XSM_INLINE int xsm_hvmcontext(struct domain *d, uint32_t cmd)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, address_size) (struct domain *d, uint32_t cmd)
+static XSM_INLINE int xsm_address_size(struct domain *d, uint32_t cmd)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, machine_address_size) (struct domain *d, uint32_t cmd)
+static XSM_INLINE int xsm_machine_address_size(struct domain *d, uint32_t cmd)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, hvm_param) (struct domain *d, unsigned long op)
+static XSM_INLINE int xsm_hvm_param(struct domain *d, unsigned long op)
 {
     if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, hvm_set_pci_intx_level) (struct domain *d)
+static XSM_INLINE int xsm_hvm_set_pci_intx_level(struct domain *d)
 {
     if ( !IS_PRIV_FOR(current->domain, d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, hvm_set_isa_irq_level) (struct domain *d)
+static XSM_INLINE int xsm_hvm_set_isa_irq_level(struct domain *d)
 {
     if ( !IS_PRIV_FOR(current->domain, d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, hvm_set_pci_link_route) (struct domain *d)
+static XSM_INLINE int xsm_hvm_set_pci_link_route(struct domain *d)
 {
     if ( !IS_PRIV_FOR(current->domain, d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, hvm_inject_msi) (struct domain *d)
+static XSM_INLINE int xsm_hvm_inject_msi(struct domain *d)
 {
     if ( !IS_PRIV_FOR(current->domain, d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, mem_event_setup) (struct domain *d)
+static XSM_INLINE int xsm_mem_event_setup(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, mem_event_control) (struct domain *d, int mode, int op)
+static XSM_INLINE int xsm_mem_event_control(struct domain *d, int mode, int op)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, mem_event_op) (struct domain *d, int op)
+static XSM_INLINE int xsm_mem_event_op(struct domain *d, int op)
 {
     if ( !IS_PRIV_FOR(current->domain, d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, mem_sharing) (struct domain *d)
+static XSM_INLINE int xsm_mem_sharing(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, mem_sharing_op) (struct domain *d, struct domain *cd, 
int op)
+static XSM_INLINE int xsm_mem_sharing_op(struct domain *d, struct domain *cd, 
int op)
 {
     if ( !IS_PRIV_FOR(current->domain, cd) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, apic) (struct domain *d, int cmd)
+static XSM_INLINE int xsm_apic(struct domain *d, int cmd)
 {
     if ( !IS_PRIV(d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, xen_settime) (void)
+static XSM_INLINE int xsm_xen_settime(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, memtype) (uint32_t access)
+static XSM_INLINE int xsm_memtype(uint32_t access)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, microcode) (void)
+static XSM_INLINE int xsm_microcode(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, physinfo) (void)
+static XSM_INLINE int xsm_physinfo(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, platform_quirk) (uint32_t quirk)
+static XSM_INLINE int xsm_platform_quirk(uint32_t quirk)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, platform_op) (uint32_t op)
+static XSM_INLINE int xsm_platform_op(uint32_t op)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, firmware_info) (void)
+static XSM_INLINE int xsm_firmware_info(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, efi_call) (void)
+static XSM_INLINE int xsm_efi_call(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, acpi_sleep) (void)
+static XSM_INLINE int xsm_acpi_sleep(void)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, change_freq) (void)
+static XSM_INLINE int xsm_change_freq(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, getidletime) (void)
+static XSM_INLINE int xsm_getidletime(void)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, machine_memory_map) (void)
+static XSM_INLINE int xsm_machine_memory_map(void)
 {
     if ( !IS_PRIV(current->domain) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, domain_memory_map) (struct domain *d)
+static XSM_INLINE int xsm_domain_memory_map(struct domain *d)
 {
     if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, mmu_update) (struct domain *d, struct domain *t,
+static XSM_INLINE int xsm_mmu_update(struct domain *d, struct domain *t,
                                      struct domain *f, uint32_t flags)
 {
     if ( t && d != t && !IS_PRIV_FOR(d, t) )
@@ -691,14 +691,14 @@ static XSM_DEFAULT(int, mmu_update) (struct domain *d, 
struct domain *t,
     return 0;
 }
 
-static XSM_DEFAULT(int, mmuext_op) (struct domain *d, struct domain *f)
+static XSM_INLINE int xsm_mmuext_op(struct domain *d, struct domain *f)
 {
     if ( d != f && !IS_PRIV_FOR(d, f) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, update_va_mapping) (struct domain *d, struct domain 
*f, 
+static XSM_INLINE int xsm_update_va_mapping(struct domain *d, struct domain 
*f, 
                                                             l1_pgentry_t pte)
 {
     if ( d != f && !IS_PRIV_FOR(d, f) )
@@ -706,56 +706,56 @@ static XSM_DEFAULT(int, update_va_mapping) (struct domain 
*d, struct domain *f,
     return 0;
 }
 
-static XSM_DEFAULT(int, add_to_physmap) (struct domain *d1, struct domain *d2)
+static XSM_INLINE int xsm_add_to_physmap(struct domain *d1, struct domain *d2)
 {
     if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, remove_from_physmap) (struct domain *d1, struct domain 
*d2)
+static XSM_INLINE int xsm_remove_from_physmap(struct domain *d1, struct domain 
*d2)
 {
     if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) )
         return -EPERM;
     return 0;
 }
 
-static XSM_DEFAULT(int, sendtrigger) (struct domain *d)
+static XSM_INLINE int xsm_sendtrigger(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, bind_pt_irq) (struct domain *d, struct 
xen_domctl_bind_pt_irq *bind)
+static XSM_INLINE int xsm_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)
+static XSM_INLINE int xsm_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)
+static XSM_INLINE int xsm_pin_mem_cacheattr(struct domain *d)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, ext_vcpucontext) (struct domain *d, uint32_t cmd)
+static XSM_INLINE int xsm_ext_vcpucontext(struct domain *d, uint32_t cmd)
 {
     return 0;
 }
 
-static XSM_DEFAULT(int, vcpuextstate) (struct domain *d, uint32_t cmd)
+static XSM_INLINE int xsm_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)
+static XSM_INLINE int xsm_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)
+static XSM_INLINE int xsm_ioport_mapping(struct domain *d, uint32_t s, 
uint32_t e, uint8_t allow)
 {
     return 0;
 }
diff --git a/xen/include/xsm/xsm.h b/xen/include/xsm/xsm.h
index 748f5ff..b2f33d6 100644
--- a/xen/include/xsm/xsm.h
+++ b/xen/include/xsm/xsm.h
@@ -195,6 +195,8 @@ struct xsm_operations {
 
 extern struct xsm_operations *xsm_ops;
 
+#ifndef XSM_NO_WRAPPERS
+
 static inline void xsm_security_domaininfo (struct domain *d,
                                         struct xen_domctl_getdomaininfo *info)
 {
@@ -846,6 +848,7 @@ static inline int xsm_ioport_mapping (struct domain *d, 
uint32_t s, uint32_t e,
     return xsm_ops->ioport_mapping(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 *));
@@ -860,7 +863,7 @@ extern void xsm_fixup_ops(struct xsm_operations *ops);
 
 #else /* XSM_ENABLE */
 
-#define XSM_DEFAULT(type, name) inline type xsm_ ## name
+#define XSM_INLINE inline
 #include <xsm/dummy.h>
 
 static inline int xsm_init (unsigned long *module_map,
diff --git a/xen/xsm/dummy.c b/xen/xsm/dummy.c
index 6e113fb..3e6e5df 100644
--- a/xen/xsm/dummy.c
+++ b/xen/xsm/dummy.c
@@ -10,7 +10,8 @@
  *  as published by the Free Software Foundation.
  */
 
-#define XSM_DEFAULT(type, name) type dummy_ ## name
+#define XSM_NO_WRAPPERS
+#define XSM_INLINE /* */
 #include <xsm/dummy.h>
 
 struct xsm_operations dummy_xsm_ops;
@@ -19,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");      \
-- 
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®.