From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tim Deegan Subject: Re: [RFC PATCH V2 5/8] xen/mem_event: Rename mem_event to vm_event Date: Thu, 22 Jan 2015 15:52:53 +0100 Message-ID: <20150122145253.GH97314@deinos.phlegethon.org> References: <1421594281-27658-1-git-send-email-tamas.lengyel@zentific.com> <1421594281-27658-6-git-send-email-tamas.lengyel@zentific.com> Mime-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Return-path: Content-Disposition: inline In-Reply-To: <1421594281-27658-6-git-send-email-tamas.lengyel@zentific.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org To: Tamas K Lengyel Cc: kevin.tian@intel.com, wei.liu2@citrix.com, ian.campbell@citrix.com, stefano.stabellini@eu.citrix.com, jun.nakajima@intel.com, eddie.dong@intel.com, ian.jackson@eu.citrix.com, xen-devel@lists.xen.org, andres@lagarcavilla.org, jbeulich@suse.com, rshriram@cs.ubc.ca, keir@xen.org, dgdegra@tycho.nsa.gov, yanghy@cn.fujitsu.com List-Id: xen-devel@lists.xenproject.org At 16:17 +0100 on 18 Jan (1421594278), Tamas K Lengyel wrote: > The mem_event system has originally been used to deliver memory event > related information to helper programs located in a domain. However, > the usage of this sub-system have since been expanded to include non-memory > related events as well, such as register changes, debugging and singlestepping. > Therefore, renaming the system "vm_event" more accurately describes the actual > usage of the subsystem. > > In this patch I also clear up the ambiguities that resulted from the interchanged > mem_event and mem_access terminology. > > Signed-off-by: Tamas K Lengyel This patch is pretty much unreviewable in that it is both renames and edits files, but I'm OK with the general intent. I see Andrew's already suggested some git runes to handle the rename better. Cheers, Tim. > --- > tools/libxc/Makefile | 2 +- > tools/libxc/xc_mem_access.c | 10 +- > tools/libxc/xc_mem_event.c | 162 -------- > tools/libxc/xc_mem_paging.c | 12 +- > tools/libxc/xc_memshr.c | 12 +- > tools/libxc/xc_private.h | 6 +- > tools/libxc/xc_vm_event.c | 162 ++++++++ > tools/tests/xen-access/xen-access.c | 104 ++--- > tools/xenpaging/pagein.c | 2 +- > tools/xenpaging/xenpaging.c | 118 +++--- > tools/xenpaging/xenpaging.h | 8 +- > xen/arch/x86/domain.c | 2 +- > xen/arch/x86/domctl.c | 4 +- > xen/arch/x86/hvm/emulate.c | 4 +- > xen/arch/x86/hvm/hvm.c | 44 +-- > xen/arch/x86/hvm/vmx/vmcs.c | 4 +- > xen/arch/x86/mm/hap/nested_ept.c | 4 +- > xen/arch/x86/mm/hap/nested_hap.c | 4 +- > xen/arch/x86/mm/mem_paging.c | 4 +- > xen/arch/x86/mm/mem_sharing.c | 28 +- > xen/arch/x86/mm/p2m-pod.c | 4 +- > xen/arch/x86/mm/p2m-pt.c | 4 +- > xen/arch/x86/mm/p2m.c | 94 ++--- > xen/arch/x86/x86_64/compat/mm.c | 6 +- > xen/arch/x86/x86_64/mm.c | 7 +- > xen/common/Makefile | 2 +- > xen/common/domain.c | 12 +- > xen/common/domctl.c | 6 +- > xen/common/mem_access.c | 24 +- > xen/common/mem_event.c | 742 ------------------------------------ > xen/common/vm_event.c | 742 ++++++++++++++++++++++++++++++++++++ > xen/drivers/passthrough/pci.c | 2 +- > xen/include/Makefile | 2 +- > xen/include/asm-arm/p2m.h | 6 +- > xen/include/asm-x86/domain.h | 4 +- > xen/include/asm-x86/hvm/emulate.h | 2 +- > xen/include/asm-x86/p2m.h | 16 +- > xen/include/public/domctl.h | 42 +- > xen/include/public/mem_event.h | 197 ---------- > xen/include/public/vm_event.h | 197 ++++++++++ > xen/include/xen/mem_access.h | 4 +- > xen/include/xen/mem_event.h | 143 ------- > xen/include/xen/p2m-common.h | 4 +- > xen/include/xen/sched.h | 26 +- > xen/include/xen/vm_event.h | 143 +++++++ > xen/include/xsm/dummy.h | 4 +- > xen/include/xsm/xsm.h | 12 +- > xen/xsm/dummy.c | 4 +- > xen/xsm/flask/hooks.c | 16 +- > xen/xsm/flask/policy/access_vectors | 2 +- > 50 files changed, 1580 insertions(+), 1585 deletions(-) > delete mode 100644 tools/libxc/xc_mem_event.c > create mode 100644 tools/libxc/xc_vm_event.c > delete mode 100644 xen/common/mem_event.c > create mode 100644 xen/common/vm_event.c > delete mode 100644 xen/include/public/mem_event.h > create mode 100644 xen/include/public/vm_event.h > delete mode 100644 xen/include/xen/mem_event.h > create mode 100644 xen/include/xen/vm_event.h > > diff --git a/tools/libxc/Makefile b/tools/libxc/Makefile > index bd2ca6c..6ef17ec 100644 > --- a/tools/libxc/Makefile > +++ b/tools/libxc/Makefile > @@ -26,7 +26,7 @@ CTRL_SRCS-y += xc_pm.c > CTRL_SRCS-y += xc_cpu_hotplug.c > CTRL_SRCS-y += xc_resume.c > CTRL_SRCS-y += xc_tmem.c > -CTRL_SRCS-y += xc_mem_event.c > +CTRL_SRCS-y += xc_vm_event.c > CTRL_SRCS-y += xc_mem_paging.c > CTRL_SRCS-y += xc_mem_access.c > CTRL_SRCS-y += xc_memshr.c > diff --git a/tools/libxc/xc_mem_access.c b/tools/libxc/xc_mem_access.c > index 1c979ed..80f4e2d 100644 > --- a/tools/libxc/xc_mem_access.c > +++ b/tools/libxc/xc_mem_access.c > @@ -26,22 +26,22 @@ > > void *xc_mem_access_enable(xc_interface *xch, domid_t domain_id, uint32_t *port) > { > - return xc_mem_event_enable(xch, domain_id, HVM_PARAM_MONITOR_RING_PFN, > + return xc_vm_event_enable(xch, domain_id, HVM_PARAM_MONITOR_RING_PFN, > port, 0); > } > > void *xc_mem_access_enable_introspection(xc_interface *xch, domid_t domain_id, > uint32_t *port) > { > - return xc_mem_event_enable(xch, domain_id, HVM_PARAM_MONITOR_RING_PFN, > + return xc_vm_event_enable(xch, domain_id, HVM_PARAM_MONITOR_RING_PFN, > port, 1); > } > > int xc_mem_access_disable(xc_interface *xch, domid_t domain_id) > { > - return xc_mem_event_control(xch, domain_id, > - XEN_DOMCTL_MEM_EVENT_OP_MONITOR_DISABLE, > - XEN_DOMCTL_MEM_EVENT_OP_MONITOR, > + return xc_vm_event_control(xch, domain_id, > + XEN_DOMCTL_VM_EVENT_OP_MONITOR_DISABLE, > + XEN_DOMCTL_VM_EVENT_OP_MONITOR, > NULL); > } > > diff --git a/tools/libxc/xc_mem_event.c b/tools/libxc/xc_mem_event.c > deleted file mode 100644 > index a5e0948..0000000 > --- a/tools/libxc/xc_mem_event.c > +++ /dev/null > @@ -1,162 +0,0 @@ > -/****************************************************************************** > - * > - * xc_mem_event.c > - * > - * Interface to low-level memory event functionality. > - * > - * Copyright (c) 2009 Citrix Systems, Inc. (Patrick Colp) > - * > - * This library is free software; you can redistribute it and/or > - * modify it under the terms of the GNU Lesser General Public > - * License as published by the Free Software Foundation; either > - * version 2.1 of the License, or (at your option) any later version. > - * > - * This library is distributed in the hope that it will be useful, > - * but WITHOUT ANY WARRANTY; without even the implied warranty of > - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > - * Lesser General Public License for more details. > - * > - * You should have received a copy of the GNU Lesser General Public > - * License along with this library; if not, write to the Free Software > - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA > - */ > - > -#include "xc_private.h" > - > -int xc_mem_event_control(xc_interface *xch, domid_t domain_id, unsigned int op, > - unsigned int mode, uint32_t *port) > -{ > - DECLARE_DOMCTL; > - int rc; > - > - domctl.cmd = XEN_DOMCTL_mem_event_op; > - domctl.domain = domain_id; > - domctl.u.mem_event_op.op = op; > - domctl.u.mem_event_op.mode = mode; > - > - rc = do_domctl(xch, &domctl); > - if ( !rc && port ) > - *port = domctl.u.mem_event_op.port; > - return rc; > -} > - > -void *xc_mem_event_enable(xc_interface *xch, domid_t domain_id, int param, > - uint32_t *port, int enable_introspection) > -{ > - void *ring_page = NULL; > - uint64_t pfn; > - xen_pfn_t ring_pfn, mmap_pfn; > - unsigned int op, mode; > - int rc1, rc2, saved_errno; > - > - if ( !port ) > - { > - errno = EINVAL; > - return NULL; > - } > - > - /* Pause the domain for ring page setup */ > - rc1 = xc_domain_pause(xch, domain_id); > - if ( rc1 != 0 ) > - { > - PERROR("Unable to pause domain\n"); > - return NULL; > - } > - > - /* Get the pfn of the ring page */ > - rc1 = xc_hvm_param_get(xch, domain_id, param, &pfn); > - if ( rc1 != 0 ) > - { > - PERROR("Failed to get pfn of ring page\n"); > - goto out; > - } > - > - ring_pfn = pfn; > - mmap_pfn = pfn; > - ring_page = xc_map_foreign_batch(xch, domain_id, PROT_READ | PROT_WRITE, > - &mmap_pfn, 1); > - if ( mmap_pfn & XEN_DOMCTL_PFINFO_XTAB ) > - { > - /* Map failed, populate ring page */ > - rc1 = xc_domain_populate_physmap_exact(xch, domain_id, 1, 0, 0, > - &ring_pfn); > - if ( rc1 != 0 ) > - { > - PERROR("Failed to populate ring pfn\n"); > - goto out; > - } > - > - mmap_pfn = ring_pfn; > - ring_page = xc_map_foreign_batch(xch, domain_id, PROT_READ | PROT_WRITE, > - &mmap_pfn, 1); > - if ( mmap_pfn & XEN_DOMCTL_PFINFO_XTAB ) > - { > - PERROR("Could not map the ring page\n"); > - goto out; > - } > - } > - > - switch ( param ) > - { > - case HVM_PARAM_PAGING_RING_PFN: > - op = XEN_DOMCTL_MEM_EVENT_OP_PAGING_ENABLE; > - mode = XEN_DOMCTL_MEM_EVENT_OP_PAGING; > - break; > - > - case HVM_PARAM_MONITOR_RING_PFN: > - if ( enable_introspection ) > - op = XEN_DOMCTL_MEM_EVENT_OP_MONITOR_ENABLE_INTROSPECTION; > - else > - op = XEN_DOMCTL_MEM_EVENT_OP_MONITOR_ENABLE; > - mode = XEN_DOMCTL_MEM_EVENT_OP_MONITOR; > - break; > - > - case HVM_PARAM_SHARING_RING_PFN: > - op = XEN_DOMCTL_MEM_EVENT_OP_SHARING_ENABLE; > - mode = XEN_DOMCTL_MEM_EVENT_OP_SHARING; > - break; > - > - /* > - * This is for the outside chance that the HVM_PARAM is valid but is invalid > - * as far as mem_event goes. > - */ > - default: > - errno = EINVAL; > - rc1 = -1; > - goto out; > - } > - > - rc1 = xc_mem_event_control(xch, domain_id, op, mode, port); > - if ( rc1 != 0 ) > - { > - PERROR("Failed to enable mem_event\n"); > - goto out; > - } > - > - /* Remove the ring_pfn from the guest's physmap */ > - rc1 = xc_domain_decrease_reservation_exact(xch, domain_id, 1, 0, &ring_pfn); > - if ( rc1 != 0 ) > - PERROR("Failed to remove ring page from guest physmap"); > - > - out: > - saved_errno = errno; > - > - rc2 = xc_domain_unpause(xch, domain_id); > - if ( rc1 != 0 || rc2 != 0 ) > - { > - if ( rc2 != 0 ) > - { > - if ( rc1 == 0 ) > - saved_errno = errno; > - PERROR("Unable to unpause domain"); > - } > - > - if ( ring_page ) > - munmap(ring_page, XC_PAGE_SIZE); > - ring_page = NULL; > - > - errno = saved_errno; > - } > - > - return ring_page; > -} > diff --git a/tools/libxc/xc_mem_paging.c b/tools/libxc/xc_mem_paging.c > index bf3173d..8408b07 100644 > --- a/tools/libxc/xc_mem_paging.c > +++ b/tools/libxc/xc_mem_paging.c > @@ -47,17 +47,17 @@ int xc_mem_paging_enable(xc_interface *xch, domid_t domain_id, > return -1; > } > > - return xc_mem_event_control(xch, domain_id, > - XEN_DOMCTL_MEM_EVENT_OP_PAGING_ENABLE, > - XEN_DOMCTL_MEM_EVENT_OP_PAGING, > + return xc_vm_event_control(xch, domain_id, > + XEN_DOMCTL_VM_EVENT_OP_PAGING_ENABLE, > + XEN_DOMCTL_VM_EVENT_OP_PAGING, > port); > } > > int xc_mem_paging_disable(xc_interface *xch, domid_t domain_id) > { > - return xc_mem_event_control(xch, domain_id, > - XEN_DOMCTL_MEM_EVENT_OP_PAGING_DISABLE, > - XEN_DOMCTL_MEM_EVENT_OP_PAGING, > + return xc_vm_event_control(xch, domain_id, > + XEN_DOMCTL_VM_EVENT_OP_PAGING_DISABLE, > + XEN_DOMCTL_VM_EVENT_OP_PAGING, > NULL); > } > > diff --git a/tools/libxc/xc_memshr.c b/tools/libxc/xc_memshr.c > index d6a9539..fafa073 100644 > --- a/tools/libxc/xc_memshr.c > +++ b/tools/libxc/xc_memshr.c > @@ -52,18 +52,18 @@ int xc_memshr_ring_enable(xc_interface *xch, > return -1; > } > > - return xc_mem_event_control(xch, domid, > - XEN_DOMCTL_MEM_EVENT_OP_SHARING_ENABLE, > - XEN_DOMCTL_MEM_EVENT_OP_SHARING, > + return xc_vm_event_control(xch, domid, > + XEN_DOMCTL_VM_EVENT_OP_SHARING_ENABLE, > + XEN_DOMCTL_VM_EVENT_OP_SHARING, > port); > } > > int xc_memshr_ring_disable(xc_interface *xch, > domid_t domid) > { > - return xc_mem_event_control(xch, domid, > - XEN_DOMCTL_MEM_EVENT_OP_SHARING_DISABLE, > - XEN_DOMCTL_MEM_EVENT_OP_SHARING, > + return xc_vm_event_control(xch, domid, > + XEN_DOMCTL_VM_EVENT_OP_SHARING_DISABLE, > + XEN_DOMCTL_VM_EVENT_OP_SHARING, > NULL); > } > > diff --git a/tools/libxc/xc_private.h b/tools/libxc/xc_private.h > index f1f601c..a539300 100644 > --- a/tools/libxc/xc_private.h > +++ b/tools/libxc/xc_private.h > @@ -421,15 +421,15 @@ int xc_ffs64(uint64_t x); > #define DOMPRINTF_CALLED(xch) xc_dom_printf((xch), "%s: called", __FUNCTION__) > > /** > - * mem_event operations. Internal use only. > + * vm_event operations. Internal use only. > */ > -int xc_mem_event_control(xc_interface *xch, domid_t domain_id, unsigned int op, > +int xc_vm_event_control(xc_interface *xch, domid_t domain_id, unsigned int op, > unsigned int mode, uint32_t *port); > /* > * Enables mem_event and returns the mapped ring page indicated by param. > * param can be HVM_PARAM_PAGING/ACCESS/SHARING_RING_PFN > */ > -void *xc_mem_event_enable(xc_interface *xch, domid_t domain_id, int param, > +void *xc_vm_event_enable(xc_interface *xch, domid_t domain_id, int param, > uint32_t *port, int enable_introspection); > > #endif /* __XC_PRIVATE_H__ */ > diff --git a/tools/libxc/xc_vm_event.c b/tools/libxc/xc_vm_event.c > new file mode 100644 > index 0000000..39d794d > --- /dev/null > +++ b/tools/libxc/xc_vm_event.c > @@ -0,0 +1,162 @@ > +/****************************************************************************** > + * > + * xc_vm_event.c > + * > + * Interface to low-level VM event functionality. > + * > + * Copyright (c) 2009 Citrix Systems, Inc. (Patrick Colp) > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2.1 of the License, or (at your option) any later version. > + * > + * This library is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with this library; if not, write to the Free Software > + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA > + */ > + > +#include "xc_private.h" > + > +int xc_vm_event_control(xc_interface *xch, domid_t domain_id, unsigned int op, > + unsigned int mode, uint32_t *port) > +{ > + DECLARE_DOMCTL; > + int rc; > + > + domctl.cmd = XEN_DOMCTL_vm_event_op; > + domctl.domain = domain_id; > + domctl.u.vm_event_op.op = op; > + domctl.u.vm_event_op.mode = mode; > + > + rc = do_domctl(xch, &domctl); > + if ( !rc && port ) > + *port = domctl.u.vm_event_op.port; > + return rc; > +} > + > +void *xc_vm_event_enable(xc_interface *xch, domid_t domain_id, int param, > + uint32_t *port, int enable_introspection) > +{ > + void *ring_page = NULL; > + uint64_t pfn; > + xen_pfn_t ring_pfn, mmap_pfn; > + unsigned int op, mode; > + int rc1, rc2, saved_errno; > + > + if ( !port ) > + { > + errno = EINVAL; > + return NULL; > + } > + > + /* Pause the domain for ring page setup */ > + rc1 = xc_domain_pause(xch, domain_id); > + if ( rc1 != 0 ) > + { > + PERROR("Unable to pause domain\n"); > + return NULL; > + } > + > + /* Get the pfn of the ring page */ > + rc1 = xc_hvm_param_get(xch, domain_id, param, &pfn); > + if ( rc1 != 0 ) > + { > + PERROR("Failed to get pfn of ring page\n"); > + goto out; > + } > + > + ring_pfn = pfn; > + mmap_pfn = pfn; > + ring_page = xc_map_foreign_batch(xch, domain_id, PROT_READ | PROT_WRITE, > + &mmap_pfn, 1); > + if ( mmap_pfn & XEN_DOMCTL_PFINFO_XTAB ) > + { > + /* Map failed, populate ring page */ > + rc1 = xc_domain_populate_physmap_exact(xch, domain_id, 1, 0, 0, > + &ring_pfn); > + if ( rc1 != 0 ) > + { > + PERROR("Failed to populate ring pfn\n"); > + goto out; > + } > + > + mmap_pfn = ring_pfn; > + ring_page = xc_map_foreign_batch(xch, domain_id, PROT_READ | PROT_WRITE, > + &mmap_pfn, 1); > + if ( mmap_pfn & XEN_DOMCTL_PFINFO_XTAB ) > + { > + PERROR("Could not map the ring page\n"); > + goto out; > + } > + } > + > + switch ( param ) > + { > + case HVM_PARAM_PAGING_RING_PFN: > + op = XEN_DOMCTL_VM_EVENT_OP_PAGING_ENABLE; > + mode = XEN_DOMCTL_VM_EVENT_OP_PAGING; > + break; > + > + case HVM_PARAM_MONITOR_RING_PFN: > + if ( enable_introspection ) > + op = XEN_DOMCTL_VM_EVENT_OP_MONITOR_ENABLE_INTROSPECTION; > + else > + op = XEN_DOMCTL_VM_EVENT_OP_MONITOR_ENABLE; > + mode = XEN_DOMCTL_VM_EVENT_OP_MONITOR; > + break; > + > + case HVM_PARAM_SHARING_RING_PFN: > + op = XEN_DOMCTL_VM_EVENT_OP_SHARING_ENABLE; > + mode = XEN_DOMCTL_VM_EVENT_OP_SHARING; > + break; > + > + /* > + * This is for the outside chance that the HVM_PARAM is valid but is invalid > + * as far as vm_event goes. > + */ > + default: > + errno = EINVAL; > + rc1 = -1; > + goto out; > + } > + > + rc1 = xc_vm_event_control(xch, domain_id, op, mode, port); > + if ( rc1 != 0 ) > + { > + PERROR("Failed to enable vm_event\n"); > + goto out; > + } > + > + /* Remove the ring_pfn from the guest's physmap */ > + rc1 = xc_domain_decrease_reservation_exact(xch, domain_id, 1, 0, &ring_pfn); > + if ( rc1 != 0 ) > + PERROR("Failed to remove ring page from guest physmap"); > + > + out: > + saved_errno = errno; > + > + rc2 = xc_domain_unpause(xch, domain_id); > + if ( rc1 != 0 || rc2 != 0 ) > + { > + if ( rc2 != 0 ) > + { > + if ( rc1 == 0 ) > + saved_errno = errno; > + PERROR("Unable to unpause domain"); > + } > + > + if ( ring_page ) > + munmap(ring_page, XC_PAGE_SIZE); > + ring_page = NULL; > + > + errno = saved_errno; > + } > + > + return ring_page; > +} > diff --git a/tools/tests/xen-access/xen-access.c b/tools/tests/xen-access/xen-access.c > index 9d53fb3..3538323 100644 > --- a/tools/tests/xen-access/xen-access.c > +++ b/tools/tests/xen-access/xen-access.c > @@ -39,7 +39,7 @@ > #include > > #include > -#include > +#include > > #define DPRINTF(a, b...) fprintf(stderr, a, ## b) > #define ERROR(a, b...) fprintf(stderr, a "\n", ## b) > @@ -91,26 +91,26 @@ static inline int spin_trylock(spinlock_t *lock) > return !test_and_set_bit(1, lock); > } > > -#define mem_event_ring_lock_init(_m) spin_lock_init(&(_m)->ring_lock) > -#define mem_event_ring_lock(_m) spin_lock(&(_m)->ring_lock) > -#define mem_event_ring_unlock(_m) spin_unlock(&(_m)->ring_lock) > +#define vm_event_ring_lock_init(_m) spin_lock_init(&(_m)->ring_lock) > +#define vm_event_ring_lock(_m) spin_lock(&(_m)->ring_lock) > +#define vm_event_ring_unlock(_m) spin_unlock(&(_m)->ring_lock) > > -typedef struct mem_event { > +typedef struct vm_event { > domid_t domain_id; > xc_evtchn *xce_handle; > int port; > - mem_event_back_ring_t back_ring; > + vm_event_back_ring_t back_ring; > uint32_t evtchn_port; > void *ring_page; > spinlock_t ring_lock; > -} mem_event_t; > +} vm_event_t; > > typedef struct xenaccess { > xc_interface *xc_handle; > > xc_domaininfo_t *domain_info; > > - mem_event_t mem_event; > + vm_event_t vm_event; > } xenaccess_t; > > static int interrupted; > @@ -170,13 +170,13 @@ int xenaccess_teardown(xc_interface *xch, xenaccess_t *xenaccess) > return 0; > > /* Tear down domain xenaccess in Xen */ > - if ( xenaccess->mem_event.ring_page ) > - munmap(xenaccess->mem_event.ring_page, XC_PAGE_SIZE); > + if ( xenaccess->vm_event.ring_page ) > + munmap(xenaccess->vm_event.ring_page, XC_PAGE_SIZE); > > if ( mem_access_enable ) > { > rc = xc_mem_access_disable(xenaccess->xc_handle, > - xenaccess->mem_event.domain_id); > + xenaccess->vm_event.domain_id); > if ( rc != 0 ) > { > ERROR("Error tearing down domain xenaccess in xen"); > @@ -186,8 +186,8 @@ int xenaccess_teardown(xc_interface *xch, xenaccess_t *xenaccess) > /* Unbind VIRQ */ > if ( evtchn_bind ) > { > - rc = xc_evtchn_unbind(xenaccess->mem_event.xce_handle, > - xenaccess->mem_event.port); > + rc = xc_evtchn_unbind(xenaccess->vm_event.xce_handle, > + xenaccess->vm_event.port); > if ( rc != 0 ) > { > ERROR("Error unbinding event port"); > @@ -197,7 +197,7 @@ int xenaccess_teardown(xc_interface *xch, xenaccess_t *xenaccess) > /* Close event channel */ > if ( evtchn_open ) > { > - rc = xc_evtchn_close(xenaccess->mem_event.xce_handle); > + rc = xc_evtchn_close(xenaccess->vm_event.xce_handle); > if ( rc != 0 ) > { > ERROR("Error closing event channel"); > @@ -239,17 +239,17 @@ xenaccess_t *xenaccess_init(xc_interface **xch_r, domid_t domain_id) > xenaccess->xc_handle = xch; > > /* Set domain id */ > - xenaccess->mem_event.domain_id = domain_id; > + xenaccess->vm_event.domain_id = domain_id; > > /* Initialise lock */ > - mem_event_ring_lock_init(&xenaccess->mem_event); > + vm_event_ring_lock_init(&xenaccess->vm_event); > > /* Enable mem_access */ > - xenaccess->mem_event.ring_page = > + xenaccess->vm_event.ring_page = > xc_mem_access_enable(xenaccess->xc_handle, > - xenaccess->mem_event.domain_id, > - &xenaccess->mem_event.evtchn_port); > - if ( xenaccess->mem_event.ring_page == NULL ) > + xenaccess->vm_event.domain_id, > + &xenaccess->vm_event.evtchn_port); > + if ( xenaccess->vm_event.ring_page == NULL ) > { > switch ( errno ) { > case EBUSY: > @@ -267,8 +267,8 @@ xenaccess_t *xenaccess_init(xc_interface **xch_r, domid_t domain_id) > mem_access_enable = 1; > > /* Open event channel */ > - xenaccess->mem_event.xce_handle = xc_evtchn_open(NULL, 0); > - if ( xenaccess->mem_event.xce_handle == NULL ) > + xenaccess->vm_event.xce_handle = xc_evtchn_open(NULL, 0); > + if ( xenaccess->vm_event.xce_handle == NULL ) > { > ERROR("Failed to open event channel"); > goto err; > @@ -276,21 +276,21 @@ xenaccess_t *xenaccess_init(xc_interface **xch_r, domid_t domain_id) > evtchn_open = 1; > > /* Bind event notification */ > - rc = xc_evtchn_bind_interdomain(xenaccess->mem_event.xce_handle, > - xenaccess->mem_event.domain_id, > - xenaccess->mem_event.evtchn_port); > + rc = xc_evtchn_bind_interdomain(xenaccess->vm_event.xce_handle, > + xenaccess->vm_event.domain_id, > + xenaccess->vm_event.evtchn_port); > if ( rc < 0 ) > { > ERROR("Failed to bind event channel"); > goto err; > } > evtchn_bind = 1; > - xenaccess->mem_event.port = rc; > + xenaccess->vm_event.port = rc; > > /* Initialise ring */ > - SHARED_RING_INIT((mem_event_sring_t *)xenaccess->mem_event.ring_page); > - BACK_RING_INIT(&xenaccess->mem_event.back_ring, > - (mem_event_sring_t *)xenaccess->mem_event.ring_page, > + SHARED_RING_INIT((vm_event_sring_t *)xenaccess->vm_event.ring_page); > + BACK_RING_INIT(&xenaccess->vm_event.back_ring, > + (vm_event_sring_t *)xenaccess->vm_event.ring_page, > XC_PAGE_SIZE); > > /* Get domaininfo */ > @@ -320,14 +320,14 @@ xenaccess_t *xenaccess_init(xc_interface **xch_r, domid_t domain_id) > return NULL; > } > > -int get_request(mem_event_t *mem_event, mem_event_request_t *req) > +int get_request(vm_event_t *vm_event, vm_event_request_t *req) > { > - mem_event_back_ring_t *back_ring; > + vm_event_back_ring_t *back_ring; > RING_IDX req_cons; > > - mem_event_ring_lock(mem_event); > + vm_event_ring_lock(vm_event); > > - back_ring = &mem_event->back_ring; > + back_ring = &vm_event->back_ring; > req_cons = back_ring->req_cons; > > /* Copy request */ > @@ -338,19 +338,19 @@ int get_request(mem_event_t *mem_event, mem_event_request_t *req) > back_ring->req_cons = req_cons; > back_ring->sring->req_event = req_cons + 1; > > - mem_event_ring_unlock(mem_event); > + vm_event_ring_unlock(vm_event); > > return 0; > } > > -static int put_response(mem_event_t *mem_event, mem_event_response_t *rsp) > +static int put_response(vm_event_t *vm_event, vm_event_response_t *rsp) > { > - mem_event_back_ring_t *back_ring; > + vm_event_back_ring_t *back_ring; > RING_IDX rsp_prod; > > - mem_event_ring_lock(mem_event); > + vm_event_ring_lock(vm_event); > > - back_ring = &mem_event->back_ring; > + back_ring = &vm_event->back_ring; > rsp_prod = back_ring->rsp_prod_pvt; > > /* Copy response */ > @@ -361,24 +361,24 @@ static int put_response(mem_event_t *mem_event, mem_event_response_t *rsp) > back_ring->rsp_prod_pvt = rsp_prod; > RING_PUSH_RESPONSES(back_ring); > > - mem_event_ring_unlock(mem_event); > + vm_event_ring_unlock(vm_event); > > return 0; > } > > -static int xenaccess_resume_page(xenaccess_t *paging, mem_event_response_t *rsp) > +static int xenaccess_resume_page(xenaccess_t *paging, vm_event_response_t *rsp) > { > int ret; > > /* Put the page info on the ring */ > - ret = put_response(&paging->mem_event, rsp); > + ret = put_response(&paging->vm_event, rsp); > if ( ret != 0 ) > goto out; > > /* Tell Xen page is ready */ > - ret = xc_mem_access_resume(paging->xc_handle, paging->mem_event.domain_id); > - ret = xc_evtchn_notify(paging->mem_event.xce_handle, > - paging->mem_event.port); > + ret = xc_mem_access_resume(paging->xc_handle, paging->vm_event.domain_id); > + ret = xc_evtchn_notify(paging->vm_event.xce_handle, > + paging->vm_event.port); > > out: > return ret; > @@ -400,8 +400,8 @@ int main(int argc, char *argv[]) > struct sigaction act; > domid_t domain_id; > xenaccess_t *xenaccess; > - mem_event_request_t req; > - mem_event_response_t rsp; > + vm_event_request_t req; > + vm_event_response_t rsp; > int rc = -1; > int rc1; > xc_interface *xch; > @@ -507,7 +507,7 @@ int main(int argc, char *argv[]) > rc = xc_hvm_param_set(xch, domain_id, HVM_PARAM_MEMORY_EVENT_INT3, HVMPME_mode_disabled); > if ( rc < 0 ) > { > - ERROR("Error %d setting int3 mem_event\n", rc); > + ERROR("Error %d setting int3 vm_event\n", rc); > goto exit; > } > > @@ -527,7 +527,7 @@ int main(int argc, char *argv[]) > shutting_down = 1; > } > > - rc = xc_wait_for_event_or_timeout(xch, xenaccess->mem_event.xce_handle, 100); > + rc = xc_wait_for_event_or_timeout(xch, xenaccess->vm_event.xce_handle, 100); > if ( rc < -1 ) > { > ERROR("Error getting event"); > @@ -539,11 +539,11 @@ int main(int argc, char *argv[]) > DPRINTF("Got event from Xen\n"); > } > > - while ( RING_HAS_UNCONSUMED_REQUESTS(&xenaccess->mem_event.back_ring) ) > + while ( RING_HAS_UNCONSUMED_REQUESTS(&xenaccess->vm_event.back_ring) ) > { > xenmem_access_t access; > > - rc = get_request(&xenaccess->mem_event, &req); > + rc = get_request(&xenaccess->vm_event, &req); > if ( rc != 0 ) > { > ERROR("Error getting request"); > @@ -556,7 +556,7 @@ int main(int argc, char *argv[]) > rsp.flags = req.flags; > > switch (req.reason) { > - case MEM_EVENT_REASON_MEM_ACCESS_VIOLATION: > + case VM_EVENT_REASON_MEM_ACCESS_VIOLATION: > rc = xc_get_mem_access(xch, domain_id, req.mem_access_event.gfn, &access); > if (rc < 0) > { > @@ -594,7 +594,7 @@ int main(int argc, char *argv[]) > > rsp.mem_access_event.gfn = req.mem_access_event.gfn; > break; > - case MEM_EVENT_REASON_INT3: > + case VM_EVENT_REASON_INT3: > printf("INT3: rip=%016"PRIx64", gfn=%"PRIx64" (vcpu %d)\n", > req.int3_event.gla, > req.int3_event.gfn, > diff --git a/tools/xenpaging/pagein.c b/tools/xenpaging/pagein.c > index b3bcef7..7cb0f33 100644 > --- a/tools/xenpaging/pagein.c > +++ b/tools/xenpaging/pagein.c > @@ -63,7 +63,7 @@ void page_in_trigger(void) > > void create_page_in_thread(struct xenpaging *paging) > { > - page_in_args.dom = paging->mem_event.domain_id; > + page_in_args.dom = paging->vm_event.domain_id; > page_in_args.pagein_queue = paging->pagein_queue; > page_in_args.xch = paging->xc_handle; > if (pthread_create(&page_in_thread, NULL, page_in, &page_in_args) == 0) > diff --git a/tools/xenpaging/xenpaging.c b/tools/xenpaging/xenpaging.c > index 148b3e7..3031d1e 100644 > --- a/tools/xenpaging/xenpaging.c > +++ b/tools/xenpaging/xenpaging.c > @@ -63,7 +63,7 @@ static void close_handler(int sig) > static void xenpaging_mem_paging_flush_ioemu_cache(struct xenpaging *paging) > { > struct xs_handle *xsh = paging->xs_handle; > - domid_t domain_id = paging->mem_event.domain_id; > + domid_t domain_id = paging->vm_event.domain_id; > char path[80]; > > sprintf(path, "/local/domain/0/device-model/%u/command", domain_id); > @@ -74,7 +74,7 @@ static void xenpaging_mem_paging_flush_ioemu_cache(struct xenpaging *paging) > static int xenpaging_wait_for_event_or_timeout(struct xenpaging *paging) > { > xc_interface *xch = paging->xc_handle; > - xc_evtchn *xce = paging->mem_event.xce_handle; > + xc_evtchn *xce = paging->vm_event.xce_handle; > char **vec, *val; > unsigned int num; > struct pollfd fd[2]; > @@ -111,7 +111,7 @@ static int xenpaging_wait_for_event_or_timeout(struct xenpaging *paging) > if ( strcmp(vec[XS_WATCH_TOKEN], watch_token) == 0 ) > { > /* If our guest disappeared, set interrupt flag and fall through */ > - if ( xs_is_domain_introduced(paging->xs_handle, paging->mem_event.domain_id) == false ) > + if ( xs_is_domain_introduced(paging->xs_handle, paging->vm_event.domain_id) == false ) > { > xs_unwatch(paging->xs_handle, "@releaseDomain", watch_token); > interrupted = SIGQUIT; > @@ -171,7 +171,7 @@ static int xenpaging_get_tot_pages(struct xenpaging *paging) > xc_domaininfo_t domain_info; > int rc; > > - rc = xc_domain_getinfolist(xch, paging->mem_event.domain_id, 1, &domain_info); > + rc = xc_domain_getinfolist(xch, paging->vm_event.domain_id, 1, &domain_info); > if ( rc != 1 ) > { > PERROR("Error getting domain info"); > @@ -231,7 +231,7 @@ static int xenpaging_getopts(struct xenpaging *paging, int argc, char *argv[]) > { > switch(ch) { > case 'd': > - paging->mem_event.domain_id = atoi(optarg); > + paging->vm_event.domain_id = atoi(optarg); > break; > case 'f': > filename = strdup(optarg); > @@ -264,7 +264,7 @@ static int xenpaging_getopts(struct xenpaging *paging, int argc, char *argv[]) > } > > /* Set domain id */ > - if ( !paging->mem_event.domain_id ) > + if ( !paging->vm_event.domain_id ) > { > printf("Numerical missing!\n"); > return 1; > @@ -312,7 +312,7 @@ static struct xenpaging *xenpaging_init(int argc, char *argv[]) > } > > /* write domain ID to watch so we can ignore other domain shutdowns */ > - snprintf(watch_token, sizeof(watch_token), "%u", paging->mem_event.domain_id); > + snprintf(watch_token, sizeof(watch_token), "%u", paging->vm_event.domain_id); > if ( xs_watch(paging->xs_handle, "@releaseDomain", watch_token) == false ) > { > PERROR("Could not bind to shutdown watch\n"); > @@ -320,7 +320,7 @@ static struct xenpaging *xenpaging_init(int argc, char *argv[]) > } > > /* Watch xenpagings working target */ > - dom_path = xs_get_domain_path(paging->xs_handle, paging->mem_event.domain_id); > + dom_path = xs_get_domain_path(paging->xs_handle, paging->vm_event.domain_id); > if ( !dom_path ) > { > PERROR("Could not find domain path\n"); > @@ -339,17 +339,17 @@ static struct xenpaging *xenpaging_init(int argc, char *argv[]) > } > > /* Map the ring page */ > - xc_get_hvm_param(xch, paging->mem_event.domain_id, > + xc_get_hvm_param(xch, paging->vm_event.domain_id, > HVM_PARAM_PAGING_RING_PFN, &ring_pfn); > mmap_pfn = ring_pfn; > - paging->mem_event.ring_page = > - xc_map_foreign_batch(xch, paging->mem_event.domain_id, > + paging->vm_event.ring_page = > + xc_map_foreign_batch(xch, paging->vm_event.domain_id, > PROT_READ | PROT_WRITE, &mmap_pfn, 1); > if ( mmap_pfn & XEN_DOMCTL_PFINFO_XTAB ) > { > /* Map failed, populate ring page */ > rc = xc_domain_populate_physmap_exact(paging->xc_handle, > - paging->mem_event.domain_id, > + paging->vm_event.domain_id, > 1, 0, 0, &ring_pfn); > if ( rc != 0 ) > { > @@ -358,8 +358,8 @@ static struct xenpaging *xenpaging_init(int argc, char *argv[]) > } > > mmap_pfn = ring_pfn; > - paging->mem_event.ring_page = > - xc_map_foreign_batch(xch, paging->mem_event.domain_id, > + paging->vm_event.ring_page = > + xc_map_foreign_batch(xch, paging->vm_event.domain_id, > PROT_READ | PROT_WRITE, &mmap_pfn, 1); > if ( mmap_pfn & XEN_DOMCTL_PFINFO_XTAB ) > { > @@ -369,8 +369,8 @@ static struct xenpaging *xenpaging_init(int argc, char *argv[]) > } > > /* Initialise Xen */ > - rc = xc_mem_paging_enable(xch, paging->mem_event.domain_id, > - &paging->mem_event.evtchn_port); > + rc = xc_mem_paging_enable(xch, paging->vm_event.domain_id, > + &paging->vm_event.evtchn_port); > if ( rc != 0 ) > { > switch ( errno ) { > @@ -394,40 +394,40 @@ static struct xenpaging *xenpaging_init(int argc, char *argv[]) > } > > /* Open event channel */ > - paging->mem_event.xce_handle = xc_evtchn_open(NULL, 0); > - if ( paging->mem_event.xce_handle == NULL ) > + paging->vm_event.xce_handle = xc_evtchn_open(NULL, 0); > + if ( paging->vm_event.xce_handle == NULL ) > { > PERROR("Failed to open event channel"); > goto err; > } > > /* Bind event notification */ > - rc = xc_evtchn_bind_interdomain(paging->mem_event.xce_handle, > - paging->mem_event.domain_id, > - paging->mem_event.evtchn_port); > + rc = xc_evtchn_bind_interdomain(paging->vm_event.xce_handle, > + paging->vm_event.domain_id, > + paging->vm_event.evtchn_port); > if ( rc < 0 ) > { > PERROR("Failed to bind event channel"); > goto err; > } > > - paging->mem_event.port = rc; > + paging->vm_event.port = rc; > > /* Initialise ring */ > - SHARED_RING_INIT((mem_event_sring_t *)paging->mem_event.ring_page); > - BACK_RING_INIT(&paging->mem_event.back_ring, > - (mem_event_sring_t *)paging->mem_event.ring_page, > + SHARED_RING_INIT((vm_event_sring_t *)paging->vm_event.ring_page); > + BACK_RING_INIT(&paging->vm_event.back_ring, > + (vm_event_sring_t *)paging->vm_event.ring_page, > PAGE_SIZE); > > /* Now that the ring is set, remove it from the guest's physmap */ > if ( xc_domain_decrease_reservation_exact(xch, > - paging->mem_event.domain_id, 1, 0, &ring_pfn) ) > + paging->vm_event.domain_id, 1, 0, &ring_pfn) ) > PERROR("Failed to remove ring from guest physmap"); > > /* Get max_pages from guest if not provided via cmdline */ > if ( !paging->max_pages ) > { > - rc = xc_domain_getinfolist(xch, paging->mem_event.domain_id, 1, > + rc = xc_domain_getinfolist(xch, paging->vm_event.domain_id, 1, > &domain_info); > if ( rc != 1 ) > { > @@ -497,9 +497,9 @@ static struct xenpaging *xenpaging_init(int argc, char *argv[]) > free(paging->paging_buffer); > } > > - if ( paging->mem_event.ring_page ) > + if ( paging->vm_event.ring_page ) > { > - munmap(paging->mem_event.ring_page, PAGE_SIZE); > + munmap(paging->vm_event.ring_page, PAGE_SIZE); > } > > free(dom_path); > @@ -524,28 +524,28 @@ static void xenpaging_teardown(struct xenpaging *paging) > > paging->xc_handle = NULL; > /* Tear down domain paging in Xen */ > - munmap(paging->mem_event.ring_page, PAGE_SIZE); > - rc = xc_mem_paging_disable(xch, paging->mem_event.domain_id); > + munmap(paging->vm_event.ring_page, PAGE_SIZE); > + rc = xc_mem_paging_disable(xch, paging->vm_event.domain_id); > if ( rc != 0 ) > { > PERROR("Error tearing down domain paging in xen"); > } > > /* Unbind VIRQ */ > - rc = xc_evtchn_unbind(paging->mem_event.xce_handle, paging->mem_event.port); > + rc = xc_evtchn_unbind(paging->vm_event.xce_handle, paging->vm_event.port); > if ( rc != 0 ) > { > PERROR("Error unbinding event port"); > } > - paging->mem_event.port = -1; > + paging->vm_event.port = -1; > > /* Close event channel */ > - rc = xc_evtchn_close(paging->mem_event.xce_handle); > + rc = xc_evtchn_close(paging->vm_event.xce_handle); > if ( rc != 0 ) > { > PERROR("Error closing event channel"); > } > - paging->mem_event.xce_handle = NULL; > + paging->vm_event.xce_handle = NULL; > > /* Close connection to xenstore */ > xs_close(paging->xs_handle); > @@ -558,12 +558,12 @@ static void xenpaging_teardown(struct xenpaging *paging) > } > } > > -static void get_request(struct mem_event *mem_event, mem_event_request_t *req) > +static void get_request(struct vm_event *vm_event, vm_event_request_t *req) > { > - mem_event_back_ring_t *back_ring; > + vm_event_back_ring_t *back_ring; > RING_IDX req_cons; > > - back_ring = &mem_event->back_ring; > + back_ring = &vm_event->back_ring; > req_cons = back_ring->req_cons; > > /* Copy request */ > @@ -575,12 +575,12 @@ static void get_request(struct mem_event *mem_event, mem_event_request_t *req) > back_ring->sring->req_event = req_cons + 1; > } > > -static void put_response(struct mem_event *mem_event, mem_event_response_t *rsp) > +static void put_response(struct vm_event *vm_event, vm_event_response_t *rsp) > { > - mem_event_back_ring_t *back_ring; > + vm_event_back_ring_t *back_ring; > RING_IDX rsp_prod; > > - back_ring = &mem_event->back_ring; > + back_ring = &vm_event->back_ring; > rsp_prod = back_ring->rsp_prod_pvt; > > /* Copy response */ > @@ -607,7 +607,7 @@ static int xenpaging_evict_page(struct xenpaging *paging, unsigned long gfn, int > DECLARE_DOMCTL; > > /* Nominate page */ > - ret = xc_mem_paging_nominate(xch, paging->mem_event.domain_id, gfn); > + ret = xc_mem_paging_nominate(xch, paging->vm_event.domain_id, gfn); > if ( ret < 0 ) > { > /* unpageable gfn is indicated by EBUSY */ > @@ -619,7 +619,7 @@ static int xenpaging_evict_page(struct xenpaging *paging, unsigned long gfn, int > } > > /* Map page */ > - page = xc_map_foreign_pages(xch, paging->mem_event.domain_id, PROT_READ, &victim, 1); > + page = xc_map_foreign_pages(xch, paging->vm_event.domain_id, PROT_READ, &victim, 1); > if ( page == NULL ) > { > PERROR("Error mapping page %lx", gfn); > @@ -641,7 +641,7 @@ static int xenpaging_evict_page(struct xenpaging *paging, unsigned long gfn, int > munmap(page, PAGE_SIZE); > > /* Tell Xen to evict page */ > - ret = xc_mem_paging_evict(xch, paging->mem_event.domain_id, gfn); > + ret = xc_mem_paging_evict(xch, paging->vm_event.domain_id, gfn); > if ( ret < 0 ) > { > /* A gfn in use is indicated by EBUSY */ > @@ -671,10 +671,10 @@ static int xenpaging_evict_page(struct xenpaging *paging, unsigned long gfn, int > return ret; > } > > -static int xenpaging_resume_page(struct xenpaging *paging, mem_event_response_t *rsp, int notify_policy) > +static int xenpaging_resume_page(struct xenpaging *paging, vm_event_response_t *rsp, int notify_policy) > { > /* Put the page info on the ring */ > - put_response(&paging->mem_event, rsp); > + put_response(&paging->vm_event, rsp); > > /* Notify policy of page being paged in */ > if ( notify_policy ) > @@ -693,7 +693,7 @@ static int xenpaging_resume_page(struct xenpaging *paging, mem_event_response_t > } > > /* Tell Xen page is ready */ > - return xc_evtchn_notify(paging->mem_event.xce_handle, paging->mem_event.port); > + return xc_evtchn_notify(paging->vm_event.xce_handle, paging->vm_event.port); > } > > static int xenpaging_populate_page(struct xenpaging *paging, unsigned long gfn, int i) > @@ -715,7 +715,7 @@ static int xenpaging_populate_page(struct xenpaging *paging, unsigned long gfn, > do > { > /* Tell Xen to allocate a page for the domain */ > - ret = xc_mem_paging_load(xch, paging->mem_event.domain_id, gfn, paging->paging_buffer); > + ret = xc_mem_paging_load(xch, paging->vm_event.domain_id, gfn, paging->paging_buffer); > if ( ret < 0 ) > { > if ( errno == ENOMEM ) > @@ -857,8 +857,8 @@ int main(int argc, char *argv[]) > { > struct sigaction act; > struct xenpaging *paging; > - mem_event_request_t req; > - mem_event_response_t rsp; > + vm_event_request_t req; > + vm_event_response_t rsp; > int num, prev_num = 0; > int slot; > int tot_pages; > @@ -874,7 +874,7 @@ int main(int argc, char *argv[]) > } > xch = paging->xc_handle; > > - DPRINTF("starting %s for domain_id %u with pagefile %s\n", argv[0], paging->mem_event.domain_id, filename); > + DPRINTF("starting %s for domain_id %u with pagefile %s\n", argv[0], paging->vm_event.domain_id, filename); > > /* ensure that if we get a signal, we'll do cleanup, then exit */ > act.sa_handler = close_handler; > @@ -903,12 +903,12 @@ int main(int argc, char *argv[]) > DPRINTF("Got event from Xen\n"); > } > > - while ( RING_HAS_UNCONSUMED_REQUESTS(&paging->mem_event.back_ring) ) > + while ( RING_HAS_UNCONSUMED_REQUESTS(&paging->vm_event.back_ring) ) > { > /* Indicate possible error */ > rc = 1; > > - get_request(&paging->mem_event, &req); > + get_request(&paging->vm_event, &req); > > if ( req.mem_paging_event.gfn > paging->max_pages ) > { > @@ -929,7 +929,7 @@ int main(int argc, char *argv[]) > goto out; > } > > - if ( req.flags & MEM_EVENT_FLAG_DROP_PAGE ) > + if ( req.flags & VM_EVENT_FLAG_DROP_PAGE ) > { > DPRINTF("drop_page ^ gfn %"PRIx64" pageslot %d\n", req.mem_paging_event.gfn, slot); > /* Notify policy of page being dropped */ > @@ -966,13 +966,13 @@ int main(int argc, char *argv[]) > { > DPRINTF("page %s populated (domain = %d; vcpu = %d;" > " gfn = %"PRIx64"; paused = %d; evict_fail = %d)\n", > - req.flags & MEM_EVENT_FLAG_EVICT_FAIL ? "not" : "already", > - paging->mem_event.domain_id, req.vcpu_id, req.mem_paging_event.gfn, > - !!(req.flags & MEM_EVENT_FLAG_VCPU_PAUSED) , > - !!(req.flags & MEM_EVENT_FLAG_EVICT_FAIL) ); > + req.flags & VM_EVENT_FLAG_EVICT_FAIL ? "not" : "already", > + paging->vm_event.domain_id, req.vcpu_id, req.mem_paging_event.gfn, > + !!(req.flags & VM_EVENT_FLAG_VCPU_PAUSED) , > + !!(req.flags & VM_EVENT_FLAG_EVICT_FAIL) ); > > /* Tell Xen to resume the vcpu */ > - if (( req.flags & MEM_EVENT_FLAG_VCPU_PAUSED ) || ( req.flags & MEM_EVENT_FLAG_EVICT_FAIL )) > + if (( req.flags & VM_EVENT_FLAG_VCPU_PAUSED ) || ( req.flags & VM_EVENT_FLAG_EVICT_FAIL )) > { > /* Prepare the response */ > rsp.mem_paging_event.gfn = req.mem_paging_event.gfn; > diff --git a/tools/xenpaging/xenpaging.h b/tools/xenpaging/xenpaging.h > index 877db2f..25d511d 100644 > --- a/tools/xenpaging/xenpaging.h > +++ b/tools/xenpaging/xenpaging.h > @@ -27,15 +27,15 @@ > > #include > #include > -#include > +#include > > #define XENPAGING_PAGEIN_QUEUE_SIZE 64 > > -struct mem_event { > +struct vm_event { > domid_t domain_id; > xc_evtchn *xce_handle; > int port; > - mem_event_back_ring_t back_ring; > + vm_event_back_ring_t back_ring; > uint32_t evtchn_port; > void *ring_page; > }; > @@ -51,7 +51,7 @@ struct xenpaging { > > void *paging_buffer; > > - struct mem_event mem_event; > + struct vm_event vm_event; > int fd; > /* number of pages for which data structures were allocated */ > int max_pages; > diff --git a/xen/arch/x86/domain.c b/xen/arch/x86/domain.c > index 11c7d9f..16855dc 100644 > --- a/xen/arch/x86/domain.c > +++ b/xen/arch/x86/domain.c > @@ -432,7 +432,7 @@ int vcpu_initialise(struct vcpu *v) > v->arch.flags = TF_kernel_mode; > > /* By default, do not emulate */ > - v->arch.mem_event.emulate_flags = 0; > + v->arch.vm_event.emulate_flags = 0; > > rc = mapcache_vcpu_init(v); > if ( rc ) > diff --git a/xen/arch/x86/domctl.c b/xen/arch/x86/domctl.c > index 82365a4..3951ed3 100644 > --- a/xen/arch/x86/domctl.c > +++ b/xen/arch/x86/domctl.c > @@ -30,8 +30,8 @@ > #include /* for arch_do_domctl */ > #include > #include > -#include > -#include > +#include > +#include > #include > #include > #include > diff --git a/xen/arch/x86/hvm/emulate.c b/xen/arch/x86/hvm/emulate.c > index 14c1847..218f6aa 100644 > --- a/xen/arch/x86/hvm/emulate.c > +++ b/xen/arch/x86/hvm/emulate.c > @@ -1401,7 +1401,7 @@ int hvm_emulate_one_no_write( > return _hvm_emulate_one(hvmemul_ctxt, &hvm_emulate_ops_no_write); > } > > -void hvm_mem_event_emulate_one(bool_t nowrite, unsigned int trapnr, > +void hvm_mem_access_emulate_one(bool_t nowrite, unsigned int trapnr, > unsigned int errcode) > { > struct hvm_emulate_ctxt ctx = {{ 0 }}; > @@ -1418,7 +1418,7 @@ void hvm_mem_event_emulate_one(bool_t nowrite, unsigned int trapnr, > { > case X86EMUL_RETRY: > /* > - * This function is called when handling an EPT-related mem_event > + * This function is called when handling an EPT-related vm_event > * reply. As such, nothing else needs to be done here, since simply > * returning makes the current instruction cause a page fault again, > * consistent with X86EMUL_RETRY. > diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c > index 1968865..48ef545 100644 > --- a/xen/arch/x86/hvm/hvm.c > +++ b/xen/arch/x86/hvm/hvm.c > @@ -35,7 +35,7 @@ > #include > #include > #include > -#include > +#include > #include > #include > #include > @@ -66,7 +66,7 @@ > #include > #include > #include > -#include > +#include > #include > > bool_t __read_mostly hvm_enabled; > @@ -2717,7 +2717,7 @@ int hvm_hap_nested_page_fault(paddr_t gpa, unsigned long gla, > struct p2m_domain *p2m; > int rc, fall_through = 0, paged = 0; > int sharing_enomem = 0; > - mem_event_request_t *req_ptr = NULL; > + vm_event_request_t *req_ptr = NULL; > > /* On Nested Virtualization, walk the guest page table. > * If this succeeds, all is fine. > @@ -2787,7 +2787,7 @@ int hvm_hap_nested_page_fault(paddr_t gpa, unsigned long gla, > { > bool_t violation; > > - /* If the access is against the permissions, then send to mem_event */ > + /* If the access is against the permissions, then send to vm_event */ > switch (p2ma) > { > case p2m_access_n: > @@ -6171,7 +6171,7 @@ int hvm_debug_op(struct vcpu *v, int32_t op) > return rc; > } > > -static void hvm_event_fill_regs(mem_event_request_t *req) > +static void hvm_event_fill_regs(vm_event_request_t *req) > { > const struct cpu_user_regs *regs = guest_cpu_user_regs(); > const struct vcpu *curr = current; > @@ -6203,7 +6203,7 @@ static void hvm_event_fill_regs(mem_event_request_t *req) > req->regs.x86.cr4 = curr->arch.hvm_vcpu.guest_cr[4]; > } > > -static int hvm_event_traps(long parameters, mem_event_request_t *req) > +static int hvm_event_traps(long parameters, vm_event_request_t *req) > { > int rc; > struct vcpu *v = current; > @@ -6212,7 +6212,7 @@ static int hvm_event_traps(long parameters, mem_event_request_t *req) > if ( !(parameters & HVMPME_MODE_MASK) ) > return 0; > > - rc = mem_event_claim_slot(d, &d->mem_event->monitor); > + rc = vm_event_claim_slot(d, &d->vm_event->monitor); > if ( rc == -ENOSYS ) > { > /* If there was no ring to handle the event, then > @@ -6224,20 +6224,20 @@ static int hvm_event_traps(long parameters, mem_event_request_t *req) > > if ( (parameters & HVMPME_MODE_MASK) == HVMPME_mode_sync ) > { > - req->flags |= MEM_EVENT_FLAG_VCPU_PAUSED; > - mem_event_vcpu_pause(v); > + req->flags |= VM_EVENT_FLAG_VCPU_PAUSED; > + vm_event_vcpu_pause(v); > } > > hvm_event_fill_regs(req); > - mem_event_put_request(d, &d->mem_event->monitor, req); > + vm_event_put_request(d, &d->vm_event->monitor, req); > > return 1; > } > > void hvm_event_cr0(unsigned long value, unsigned long old) > { > - mem_event_request_t req = { > - .reason = MEM_EVENT_REASON_CR0, > + vm_event_request_t req = { > + .reason = VM_EVENT_REASON_CR0, > .vcpu_id = current->vcpu_id, > .cr_event.new_value = value, > .cr_event.old_value = old > @@ -6254,8 +6254,8 @@ void hvm_event_cr0(unsigned long value, unsigned long old) > > void hvm_event_cr3(unsigned long value, unsigned long old) > { > - mem_event_request_t req = { > - .reason = MEM_EVENT_REASON_CR3, > + vm_event_request_t req = { > + .reason = VM_EVENT_REASON_CR3, > .vcpu_id = current->vcpu_id, > .cr_event.new_value = value, > .cr_event.old_value = old > @@ -6272,8 +6272,8 @@ void hvm_event_cr3(unsigned long value, unsigned long old) > > void hvm_event_cr4(unsigned long value, unsigned long old) > { > - mem_event_request_t req = { > - .reason = MEM_EVENT_REASON_CR4, > + vm_event_request_t req = { > + .reason = VM_EVENT_REASON_CR4, > .vcpu_id = current->vcpu_id, > .cr_event.new_value = value, > .cr_event.old_value = old > @@ -6290,8 +6290,8 @@ void hvm_event_cr4(unsigned long value, unsigned long old) > > void hvm_event_msr(unsigned long msr, unsigned long value) > { > - mem_event_request_t req = { > - .reason = MEM_EVENT_REASON_MSR, > + vm_event_request_t req = { > + .reason = VM_EVENT_REASON_MSR, > .vcpu_id = current->vcpu_id, > .msr_event.msr = msr, > .msr_event.new_value = value, > @@ -6305,8 +6305,8 @@ void hvm_event_msr(unsigned long msr, unsigned long value) > int hvm_event_int3(unsigned long gla) > { > uint32_t pfec = PFEC_page_present; > - mem_event_request_t req = { > - .reason = MEM_EVENT_REASON_INT3, > + vm_event_request_t req = { > + .reason = VM_EVENT_REASON_INT3, > .vcpu_id = current->vcpu_id, > .int3_event.gla = gla, > .int3_event.gfn = paging_gva_to_gfn(current, gla, &pfec) > @@ -6320,8 +6320,8 @@ int hvm_event_int3(unsigned long gla) > int hvm_event_single_step(unsigned long gla) > { > uint32_t pfec = PFEC_page_present; > - mem_event_request_t req = { > - .reason = MEM_EVENT_REASON_SINGLESTEP, > + vm_event_request_t req = { > + .reason = VM_EVENT_REASON_SINGLESTEP, > .vcpu_id = current->vcpu_id, > .singlestep_event.gla = gla, > .singlestep_event.gfn = paging_gva_to_gfn(current, gla, &pfec) > diff --git a/xen/arch/x86/hvm/vmx/vmcs.c b/xen/arch/x86/hvm/vmx/vmcs.c > index e553fb0..0f2b2e6 100644 > --- a/xen/arch/x86/hvm/vmx/vmcs.c > +++ b/xen/arch/x86/hvm/vmx/vmcs.c > @@ -25,7 +25,7 @@ > #include > #include > #include > -#include > +#include > #include > #include > #include > @@ -715,7 +715,7 @@ void vmx_disable_intercept_for_msr(struct vcpu *v, u32 msr, int type) > return; > > if ( unlikely(d->arch.hvm_domain.introspection_enabled) && > - mem_event_check_ring(&d->mem_event->monitor) ) > + vm_event_check_ring(&d->vm_event->monitor) ) > { > unsigned int i; > > diff --git a/xen/arch/x86/mm/hap/nested_ept.c b/xen/arch/x86/mm/hap/nested_ept.c > index cbbc4e9..40adac3 100644 > --- a/xen/arch/x86/mm/hap/nested_ept.c > +++ b/xen/arch/x86/mm/hap/nested_ept.c > @@ -17,9 +17,9 @@ > * this program; if not, write to the Free Software Foundation, Inc., 59 Temple > * Place - Suite 330, Boston, MA 02111-1307 USA. > */ > -#include > +#include > #include > -#include > +#include > #include > #include > #include > diff --git a/xen/arch/x86/mm/hap/nested_hap.c b/xen/arch/x86/mm/hap/nested_hap.c > index 9c1ec11..cb28943 100644 > --- a/xen/arch/x86/mm/hap/nested_hap.c > +++ b/xen/arch/x86/mm/hap/nested_hap.c > @@ -19,9 +19,9 @@ > * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > */ > > -#include > +#include > #include > -#include > +#include > #include > #include > #include > diff --git a/xen/arch/x86/mm/mem_paging.c b/xen/arch/x86/mm/mem_paging.c > index f28e65b..aaa72a9 100644 > --- a/xen/arch/x86/mm/mem_paging.c > +++ b/xen/arch/x86/mm/mem_paging.c > @@ -22,12 +22,12 @@ > > > #include > -#include > +#include > > > int mem_paging_memop(struct domain *d, xen_mem_paging_op_t *mpc) > { > - if ( unlikely(!d->mem_event->paging.ring_page) ) > + if ( unlikely(!d->vm_event->paging.ring_page) ) > return -ENODEV; > > switch( mpc->op ) > diff --git a/xen/arch/x86/mm/mem_sharing.c b/xen/arch/x86/mm/mem_sharing.c > index c15edcc..b17a0a9 100644 > --- a/xen/arch/x86/mm/mem_sharing.c > +++ b/xen/arch/x86/mm/mem_sharing.c > @@ -28,7 +28,7 @@ > #include > #include > #include > -#include > +#include > #include > #include > #include > @@ -559,25 +559,25 @@ int mem_sharing_notify_enomem(struct domain *d, unsigned long gfn, > { > struct vcpu *v = current; > int rc; > - mem_event_request_t req = { > - .reason = MEM_EVENT_REASON_MEM_SHARING, > + vm_event_request_t req = { > + .reason = VM_EVENT_REASON_MEM_SHARING, > .mem_sharing_event.gfn = gfn > }; > > - if ( (rc = __mem_event_claim_slot(d, > - &d->mem_event->share, allow_sleep)) < 0 ) > + if ( (rc = __vm_event_claim_slot(d, > + &d->vm_event->share, allow_sleep)) < 0 ) > return rc; > > if ( v->domain == d ) > { > - req.flags = MEM_EVENT_FLAG_VCPU_PAUSED; > - mem_event_vcpu_pause(v); > + req.flags = VM_EVENT_FLAG_VCPU_PAUSED; > + vm_event_vcpu_pause(v); > } > > req.mem_sharing_event.p2mt = p2m_ram_shared; > req.vcpu_id = v->vcpu_id; > > - mem_event_put_request(d, &d->mem_event->share, &req); > + vm_event_put_request(d, &d->vm_event->share, &req); > > return 0; > } > @@ -594,14 +594,14 @@ unsigned int mem_sharing_get_nr_shared_mfns(void) > > int mem_sharing_sharing_resume(struct domain *d) > { > - mem_event_response_t rsp; > + vm_event_response_t rsp; > > /* Get all requests off the ring */ > - while ( mem_event_get_response(d, &d->mem_event->share, &rsp) ) > + while ( vm_event_get_response(d, &d->vm_event->share, &rsp) ) > { > struct vcpu *v; > > - if ( rsp.flags & MEM_EVENT_FLAG_DUMMY ) > + if ( rsp.flags & VM_EVENT_FLAG_DUMMY ) > continue; > > /* Validate the vcpu_id in the response. */ > @@ -611,8 +611,8 @@ int mem_sharing_sharing_resume(struct domain *d) > v = d->vcpu[rsp.vcpu_id]; > > /* Unpause domain/vcpu */ > - if ( rsp.flags & MEM_EVENT_FLAG_VCPU_PAUSED ) > - mem_event_vcpu_unpause(v); > + if ( rsp.flags & VM_EVENT_FLAG_VCPU_PAUSED ) > + vm_event_vcpu_unpause(v); > } > > return 0; > @@ -1139,7 +1139,7 @@ err_out: > > /* A note on the rationale for unshare error handling: > * 1. Unshare can only fail with ENOMEM. Any other error conditions BUG_ON()'s > - * 2. We notify a potential dom0 helper through a mem_event ring. But we > + * 2. We notify a potential dom0 helper through a vm_event ring. But we > * allow the notification to not go to sleep. If the event ring is full > * of ENOMEM warnings, then it's on the ball. > * 3. We cannot go to sleep until the unshare is resolved, because we might > diff --git a/xen/arch/x86/mm/p2m-pod.c b/xen/arch/x86/mm/p2m-pod.c > index 43f507c..0679f00 100644 > --- a/xen/arch/x86/mm/p2m-pod.c > +++ b/xen/arch/x86/mm/p2m-pod.c > @@ -21,9 +21,9 @@ > */ > > #include > -#include > +#include > #include > -#include > +#include > #include > #include > #include > diff --git a/xen/arch/x86/mm/p2m-pt.c b/xen/arch/x86/mm/p2m-pt.c > index e48b63a..654384a 100644 > --- a/xen/arch/x86/mm/p2m-pt.c > +++ b/xen/arch/x86/mm/p2m-pt.c > @@ -26,10 +26,10 @@ > */ > > #include > -#include > +#include > #include > #include > -#include > +#include > #include > #include > #include > diff --git a/xen/arch/x86/mm/p2m.c b/xen/arch/x86/mm/p2m.c > index b42322a..7544667 100644 > --- a/xen/arch/x86/mm/p2m.c > +++ b/xen/arch/x86/mm/p2m.c > @@ -25,9 +25,9 @@ > */ > > #include > -#include > +#include > #include > -#include > +#include > #include > #include > #include > @@ -1077,8 +1077,8 @@ int p2m_mem_paging_evict(struct domain *d, unsigned long gfn) > void p2m_mem_paging_drop_page(struct domain *d, unsigned long gfn, > p2m_type_t p2mt) > { > - mem_event_request_t req = { > - .reason = MEM_EVENT_REASON_MEM_PAGING, > + vm_event_request_t req = { > + .reason = VM_EVENT_REASON_MEM_PAGING, > .mem_paging_event.gfn = gfn > }; > > @@ -1086,21 +1086,21 @@ void p2m_mem_paging_drop_page(struct domain *d, unsigned long gfn, > * correctness of the guest execution at this point. If this is the only > * page that happens to be paged-out, we'll be okay.. but it's likely the > * guest will crash shortly anyways. */ > - int rc = mem_event_claim_slot(d, &d->mem_event->paging); > + int rc = vm_event_claim_slot(d, &d->vm_event->paging); > if ( rc < 0 ) > return; > > /* Send release notification to pager */ > - req.flags = MEM_EVENT_FLAG_DROP_PAGE; > + req.flags = VM_EVENT_FLAG_DROP_PAGE; > > /* Update stats unless the page hasn't yet been evicted */ > if ( p2mt != p2m_ram_paging_out ) > atomic_dec(&d->paged_pages); > else > /* Evict will fail now, tag this request for pager */ > - req.flags |= MEM_EVENT_FLAG_EVICT_FAIL; > + req.flags |= VM_EVENT_FLAG_EVICT_FAIL; > > - mem_event_put_request(d, &d->mem_event->paging, &req); > + vm_event_put_request(d, &d->vm_event->paging, &req); > } > > /** > @@ -1127,8 +1127,8 @@ void p2m_mem_paging_drop_page(struct domain *d, unsigned long gfn, > void p2m_mem_paging_populate(struct domain *d, unsigned long gfn) > { > struct vcpu *v = current; > - mem_event_request_t req = { > - .reason = MEM_EVENT_REASON_MEM_PAGING, > + vm_event_request_t req = { > + .reason = VM_EVENT_REASON_MEM_PAGING, > .mem_paging_event.gfn = gfn > }; > p2m_type_t p2mt; > @@ -1137,7 +1137,7 @@ void p2m_mem_paging_populate(struct domain *d, unsigned long gfn) > struct p2m_domain *p2m = p2m_get_hostp2m(d); > > /* We're paging. There should be a ring */ > - int rc = mem_event_claim_slot(d, &d->mem_event->paging); > + int rc = vm_event_claim_slot(d, &d->vm_event->paging); > if ( rc == -ENOSYS ) > { > gdprintk(XENLOG_ERR, "Domain %hu paging gfn %lx yet no ring " > @@ -1159,7 +1159,7 @@ void p2m_mem_paging_populate(struct domain *d, unsigned long gfn) > { > /* Evict will fail now, tag this request for pager */ > if ( p2mt == p2m_ram_paging_out ) > - req.flags |= MEM_EVENT_FLAG_EVICT_FAIL; > + req.flags |= VM_EVENT_FLAG_EVICT_FAIL; > > p2m_set_entry(p2m, gfn, mfn, PAGE_ORDER_4K, p2m_ram_paging_in, a); > } > @@ -1168,14 +1168,14 @@ void p2m_mem_paging_populate(struct domain *d, unsigned long gfn) > /* Pause domain if request came from guest and gfn has paging type */ > if ( p2m_is_paging(p2mt) && v->domain == d ) > { > - mem_event_vcpu_pause(v); > - req.flags |= MEM_EVENT_FLAG_VCPU_PAUSED; > + vm_event_vcpu_pause(v); > + req.flags |= VM_EVENT_FLAG_VCPU_PAUSED; > } > /* No need to inform pager if the gfn is not in the page-out path */ > else if ( p2mt != p2m_ram_paging_out && p2mt != p2m_ram_paged ) > { > /* gfn is already on its way back and vcpu is not paused */ > - mem_event_cancel_slot(d, &d->mem_event->paging); > + vm_event_cancel_slot(d, &d->vm_event->paging); > return; > } > > @@ -1183,7 +1183,7 @@ void p2m_mem_paging_populate(struct domain *d, unsigned long gfn) > req.mem_paging_event.p2mt = p2mt; > req.vcpu_id = v->vcpu_id; > > - mem_event_put_request(d, &d->mem_event->paging, &req); > + vm_event_put_request(d, &d->vm_event->paging, &req); > } > > /** > @@ -1292,17 +1292,17 @@ int p2m_mem_paging_prep(struct domain *d, unsigned long gfn, uint64_t buffer) > void p2m_mem_paging_resume(struct domain *d) > { > struct p2m_domain *p2m = p2m_get_hostp2m(d); > - mem_event_response_t rsp; > + vm_event_response_t rsp; > p2m_type_t p2mt; > p2m_access_t a; > mfn_t mfn; > > /* Pull all responses off the ring */ > - while( mem_event_get_response(d, &d->mem_event->paging, &rsp) ) > + while( vm_event_get_response(d, &d->vm_event->paging, &rsp) ) > { > struct vcpu *v; > > - if ( rsp.flags & MEM_EVENT_FLAG_DUMMY ) > + if ( rsp.flags & VM_EVENT_FLAG_DUMMY ) > continue; > > /* Validate the vcpu_id in the response. */ > @@ -1312,7 +1312,7 @@ void p2m_mem_paging_resume(struct domain *d) > v = d->vcpu[rsp.vcpu_id]; > > /* Fix p2m entry if the page was not dropped */ > - if ( !(rsp.flags & MEM_EVENT_FLAG_DROP_PAGE) ) > + if ( !(rsp.flags & VM_EVENT_FLAG_DROP_PAGE) ) > { > gfn_lock(p2m, rsp.gfn, 0); > mfn = p2m->get_entry(p2m, rsp.mem_access_event.gfn, &p2mt, &a, 0, NULL); > @@ -1328,12 +1328,12 @@ void p2m_mem_paging_resume(struct domain *d) > gfn_unlock(p2m, rsp.gfn, 0); > } > /* Unpause domain */ > - if ( rsp.flags & MEM_EVENT_FLAG_VCPU_PAUSED ) > - mem_event_vcpu_unpause(v); > + if ( rsp.flags & VM_EVENT_FLAG_VCPU_PAUSED ) > + vm_event_vcpu_unpause(v); > } > } > > -static void p2m_mem_event_fill_regs(mem_event_request_t *req) > +static void p2m_vm_event_fill_regs(vm_event_request_t *req) > { > const struct cpu_user_regs *regs = guest_cpu_user_regs(); > struct segment_register seg; > @@ -1388,10 +1388,10 @@ static void p2m_mem_event_fill_regs(mem_event_request_t *req) > req->regs.x86.cs_arbytes = seg.attr.bytes; > } > > -void p2m_mem_event_emulate_check(struct vcpu *v, const mem_event_response_t *rsp) > +void p2m_mem_access_emulate_check(struct vcpu *v, const vm_event_response_t *rsp) > { > /* Mark vcpu for skipping one instruction upon rescheduling. */ > - if ( rsp->flags & MEM_EVENT_FLAG_EMULATE ) > + if ( rsp->flags & VM_EVENT_FLAG_EMULATE ) > { > xenmem_access_t access; > bool_t violation = 1; > @@ -1438,7 +1438,7 @@ void p2m_mem_event_emulate_check(struct vcpu *v, const mem_event_response_t *rsp > } > } > > - v->arch.mem_event.emulate_flags = violation ? rsp->flags : 0; > + v->arch.vm_event.emulate_flags = violation ? rsp->flags : 0; > } > } > > @@ -1453,7 +1453,7 @@ void p2m_setup_introspection(struct domain *d) > > bool_t p2m_mem_access_check(paddr_t gpa, unsigned long gla, > struct npfec npfec, > - mem_event_request_t **req_ptr) > + vm_event_request_t **req_ptr) > { > struct vcpu *v = current; > unsigned long gfn = gpa >> PAGE_SHIFT; > @@ -1462,7 +1462,7 @@ bool_t p2m_mem_access_check(paddr_t gpa, unsigned long gla, > mfn_t mfn; > p2m_type_t p2mt; > p2m_access_t p2ma; > - mem_event_request_t *req; > + vm_event_request_t *req; > int rc; > unsigned long eip = guest_cpu_user_regs()->eip; > > @@ -1489,13 +1489,13 @@ bool_t p2m_mem_access_check(paddr_t gpa, unsigned long gla, > gfn_unlock(p2m, gfn, 0); > > /* Otherwise, check if there is a memory event listener, and send the message along */ > - if ( !mem_event_check_ring(&d->mem_event->monitor) || !req_ptr ) > + if ( !vm_event_check_ring(&d->vm_event->monitor) || !req_ptr ) > { > /* No listener */ > if ( p2m->access_required ) > { > gdprintk(XENLOG_INFO, "Memory access permissions failure, " > - "no mem_event listener VCPU %d, dom %d\n", > + "no vm_event listener VCPU %d, dom %d\n", > v->vcpu_id, d->domain_id); > domain_crash(v->domain); > return 0; > @@ -1518,40 +1518,40 @@ bool_t p2m_mem_access_check(paddr_t gpa, unsigned long gla, > } > } > > - /* The previous mem_event reply does not match the current state. */ > - if ( v->arch.mem_event.gpa != gpa || v->arch.mem_event.eip != eip ) > + /* The previous vm_event reply does not match the current state. */ > + if ( v->arch.vm_event.gpa != gpa || v->arch.vm_event.eip != eip ) > { > - /* Don't emulate the current instruction, send a new mem_event. */ > - v->arch.mem_event.emulate_flags = 0; > + /* Don't emulate the current instruction, send a new vm_event. */ > + v->arch.vm_event.emulate_flags = 0; > > /* > * Make sure to mark the current state to match it again against > - * the new mem_event about to be sent. > + * the new vm_event about to be sent. > */ > - v->arch.mem_event.gpa = gpa; > - v->arch.mem_event.eip = eip; > + v->arch.vm_event.gpa = gpa; > + v->arch.vm_event.eip = eip; > } > > - if ( v->arch.mem_event.emulate_flags ) > + if ( v->arch.vm_event.emulate_flags ) > { > - hvm_mem_event_emulate_one((v->arch.mem_event.emulate_flags & > - MEM_EVENT_FLAG_EMULATE_NOWRITE) != 0, > - TRAP_invalid_op, HVM_DELIVER_NO_ERROR_CODE); > + hvm_mem_access_emulate_one((v->arch.vm_event.emulate_flags & > + VM_EVENT_FLAG_EMULATE_NOWRITE) != 0, > + TRAP_invalid_op, HVM_DELIVER_NO_ERROR_CODE); > > - v->arch.mem_event.emulate_flags = 0; > + v->arch.vm_event.emulate_flags = 0; > return 1; > } > > *req_ptr = NULL; > - req = xzalloc(mem_event_request_t); > + req = xzalloc(vm_event_request_t); > if ( req ) > { > *req_ptr = req; > - req->reason = MEM_EVENT_REASON_MEM_ACCESS_VIOLATION; > + req->reason = VM_EVENT_REASON_MEM_ACCESS_VIOLATION; > > /* Pause the current VCPU */ > if ( p2ma != p2m_access_n2rwx ) > - req->flags |= MEM_EVENT_FLAG_VCPU_PAUSED; > + req->flags |= VM_EVENT_FLAG_VCPU_PAUSED; > > /* Send request to mem event */ > req->mem_access_event.gfn = gfn; > @@ -1567,12 +1567,12 @@ bool_t p2m_mem_access_check(paddr_t gpa, unsigned long gla, > req->mem_access_event.access_x = npfec.insn_fetch; > req->vcpu_id = v->vcpu_id; > > - p2m_mem_event_fill_regs(req); > + p2m_vm_event_fill_regs(req); > } > > /* Pause the current VCPU */ > if ( p2ma != p2m_access_n2rwx ) > - mem_event_vcpu_pause(v); > + vm_event_vcpu_pause(v); > > /* VCPU may be paused, return whether we promoted automatically */ > return (p2ma == p2m_access_n2rwx); > diff --git a/xen/arch/x86/x86_64/compat/mm.c b/xen/arch/x86/x86_64/compat/mm.c > index c8ea85a..959ccf5 100644 > --- a/xen/arch/x86/x86_64/compat/mm.c > +++ b/xen/arch/x86/x86_64/compat/mm.c > @@ -1,5 +1,5 @@ > #include > -#include > +#include > #include > #include > #include > @@ -191,7 +191,7 @@ int compat_arch_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) > xen_mem_paging_op_t mpo; > if ( copy_from_guest(&mpo, arg, 1) ) > return -EFAULT; > - rc = do_mem_event_op(cmd, mpo.domain, &mpo); > + rc = do_vm_event_op(cmd, mpo.domain, &mpo); > if ( !rc && __copy_to_guest(arg, &mpo, 1) ) > return -EFAULT; > break; > @@ -204,7 +204,7 @@ int compat_arch_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) > return -EFAULT; > if ( mso.op == XENMEM_sharing_op_audit ) > return mem_sharing_audit(); > - rc = do_mem_event_op(cmd, mso.domain, &mso); > + rc = do_vm_event_op(cmd, mso.domain, &mso); > if ( !rc && __copy_to_guest(arg, &mso, 1) ) > return -EFAULT; > break; > diff --git a/xen/arch/x86/x86_64/mm.c b/xen/arch/x86/x86_64/mm.c > index 2fa1f67..47c8578 100644 > --- a/xen/arch/x86/x86_64/mm.c > +++ b/xen/arch/x86/x86_64/mm.c > @@ -26,7 +26,7 @@ > #include > #include > #include > -#include > +#include > #include > #include > #include > @@ -988,7 +988,8 @@ long subarch_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) > xen_mem_paging_op_t mpo; > if ( copy_from_guest(&mpo, arg, 1) ) > return -EFAULT; > - rc = do_mem_event_op(cmd, mpo.domain, &mpo); > + > + rc = do_vm_event_op(cmd, mpo.domain, &mpo); > if ( !rc && __copy_to_guest(arg, &mpo, 1) ) > return -EFAULT; > break; > @@ -1001,7 +1002,7 @@ long subarch_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) > return -EFAULT; > if ( mso.op == XENMEM_sharing_op_audit ) > return mem_sharing_audit(); > - rc = do_mem_event_op(cmd, mso.domain, &mso); > + rc = do_vm_event_op(cmd, mso.domain, &mso); > if ( !rc && __copy_to_guest(arg, &mso, 1) ) > return -EFAULT; > break; > diff --git a/xen/common/Makefile b/xen/common/Makefile > index 8391246..f1b73a3 100644 > --- a/xen/common/Makefile > +++ b/xen/common/Makefile > @@ -54,7 +54,7 @@ obj-y += rbtree.o > obj-y += lzo.o > obj-$(HAS_PDX) += pdx.o > obj-$(HAS_MEM_ACCESS) += mem_access.o > -obj-$(HAS_MEM_ACCESS) += mem_event.o > +obj-$(HAS_MEM_ACCESS) += vm_event.o > > obj-bin-$(CONFIG_X86) += $(foreach n,decompress bunzip2 unxz unlzma unlzo unlz4 earlycpio,$(n).init.o) > > diff --git a/xen/common/domain.c b/xen/common/domain.c > index 336e9ea..d739614 100644 > --- a/xen/common/domain.c > +++ b/xen/common/domain.c > @@ -15,7 +15,7 @@ > #include > #include > #include > -#include > +#include > #include > #include > #include > @@ -344,8 +344,8 @@ struct domain *domain_create( > poolid = 0; > > err = -ENOMEM; > - d->mem_event = xzalloc(struct mem_event_per_domain); > - if ( !d->mem_event ) > + d->vm_event = xzalloc(struct vm_event_per_domain); > + if ( !d->vm_event ) > goto fail; > > d->pbuf = xzalloc_array(char, DOMAIN_PBUF_SIZE); > @@ -387,7 +387,7 @@ struct domain *domain_create( > if ( hardware_domain == d ) > hardware_domain = old_hwdom; > atomic_set(&d->refcnt, DOMAIN_DESTROYED); > - xfree(d->mem_event); > + xfree(d->vm_event); > xfree(d->pbuf); > if ( init_status & INIT_arch ) > arch_domain_destroy(d); > @@ -629,7 +629,7 @@ int domain_kill(struct domain *d) > d->is_dying = DOMDYING_dead; > /* Mem event cleanup has to go here because the rings > * have to be put before we call put_domain. */ > - mem_event_cleanup(d); > + vm_event_cleanup(d); > put_domain(d); > send_global_virq(VIRQ_DOM_EXC); > /* fallthrough */ > @@ -808,7 +808,7 @@ static void complete_domain_destroy(struct rcu_head *head) > free_xenoprof_pages(d); > #endif > > - xfree(d->mem_event); > + xfree(d->vm_event); > xfree(d->pbuf); > > for ( i = d->max_vcpus - 1; i >= 0; i-- ) > diff --git a/xen/common/domctl.c b/xen/common/domctl.c > index f15dcfe..e6d8310 100644 > --- a/xen/common/domctl.c > +++ b/xen/common/domctl.c > @@ -24,7 +24,7 @@ > #include > #include > #include > -#include > +#include > #include > #include > #include > @@ -1113,8 +1113,8 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) > } > break; > > - case XEN_DOMCTL_mem_event_op: > - ret = mem_event_domctl(d, &op->u.mem_event_op, > + case XEN_DOMCTL_vm_event_op: > + ret = vm_event_domctl(d, &op->u.vm_event_op, > guest_handle_cast(u_domctl, void)); > copyback = 1; > break; > diff --git a/xen/common/mem_access.c b/xen/common/mem_access.c > index f01ccfd..b8d3d49 100644 > --- a/xen/common/mem_access.c > +++ b/xen/common/mem_access.c > @@ -24,21 +24,21 @@ > #include > #include > #include > -#include > +#include > #include > #include > #include > > void mem_access_resume(struct domain *d) > { > - mem_event_response_t rsp; > + vm_event_response_t rsp; > > /* Pull all responses off the ring. */ > - while ( mem_event_get_response(d, &d->mem_event->monitor, &rsp) ) > + while ( vm_event_get_response(d, &d->vm_event->monitor, &rsp) ) > { > struct vcpu *v; > > - if ( rsp.flags & MEM_EVENT_FLAG_DUMMY ) > + if ( rsp.flags & VM_EVENT_FLAG_DUMMY ) > continue; > > /* Validate the vcpu_id in the response. */ > @@ -47,11 +47,11 @@ void mem_access_resume(struct domain *d) > > v = d->vcpu[rsp.vcpu_id]; > > - p2m_mem_event_emulate_check(v, &rsp); > + p2m_mem_access_emulate_check(v, &rsp); > > /* Unpause domain. */ > - if ( rsp.flags & MEM_EVENT_FLAG_VCPU_PAUSED ) > - mem_event_vcpu_unpause(v); > + if ( rsp.flags & VM_EVENT_FLAG_VCPU_PAUSED ) > + vm_event_vcpu_unpause(v); > } > } > > @@ -74,12 +74,12 @@ int mem_access_memop(unsigned long cmd, > if ( !p2m_mem_access_sanity_check(d) ) > goto out; > > - rc = xsm_mem_event_op(XSM_DM_PRIV, d, XENMEM_access_op); > + rc = xsm_vm_event_op(XSM_DM_PRIV, d, XENMEM_access_op); > if ( rc ) > goto out; > > rc = -ENODEV; > - if ( unlikely(!d->mem_event->monitor.ring_page) ) > + if ( unlikely(!d->vm_event->monitor.ring_page) ) > goto out; > > switch ( mao.op ) > @@ -144,13 +144,13 @@ int mem_access_memop(unsigned long cmd, > return rc; > } > > -int mem_access_send_req(struct domain *d, mem_event_request_t *req) > +int mem_access_send_req(struct domain *d, vm_event_request_t *req) > { > - int rc = mem_event_claim_slot(d, &d->mem_event->monitor); > + int rc = vm_event_claim_slot(d, &d->vm_event->monitor); > if ( rc < 0 ) > return rc; > > - mem_event_put_request(d, &d->mem_event->monitor, req); > + vm_event_put_request(d, &d->vm_event->monitor, req); > > return 0; > } > diff --git a/xen/common/mem_event.c b/xen/common/mem_event.c > deleted file mode 100644 > index b99e7d5..0000000 > --- a/xen/common/mem_event.c > +++ /dev/null > @@ -1,742 +0,0 @@ > -/****************************************************************************** > - * mem_event.c > - * > - * Memory event support. > - * > - * Copyright (c) 2009 Citrix Systems, Inc. (Patrick Colp) > - * > - * This program is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published by > - * the Free Software Foundation; either version 2 of the License, or > - * (at your option) any later version. > - * > - * This program is distributed in the hope that it will be useful, > - * but WITHOUT ANY WARRANTY; without even the implied warranty of > - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > - * GNU General Public License for more details. > - * > - * You should have received a copy of the GNU General Public License > - * along with this program; if not, write to the Free Software > - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > - */ > - > - > -#include > -#include > -#include > -#include > -#include > -#include > - > -#ifdef HAS_MEM_PAGING > -#include > -#endif > - > -#ifdef HAS_MEM_SHARING > -#include > -#endif > - > -#include > - > -/* for public/io/ring.h macros */ > -#define xen_mb() mb() > -#define xen_rmb() rmb() > -#define xen_wmb() wmb() > - > -#define mem_event_ring_lock_init(_med) spin_lock_init(&(_med)->ring_lock) > -#define mem_event_ring_lock(_med) spin_lock(&(_med)->ring_lock) > -#define mem_event_ring_unlock(_med) spin_unlock(&(_med)->ring_lock) > - > -static int mem_event_enable( > - struct domain *d, > - xen_domctl_mem_event_op_t *mec, > - struct mem_event_domain *med, > - int pause_flag, > - int param, > - xen_event_channel_notification_t notification_fn) > -{ > - int rc; > - unsigned long ring_gfn = d->arch.hvm_domain.params[param]; > - > - /* Only one helper at a time. If the helper crashed, > - * the ring is in an undefined state and so is the guest. > - */ > - if ( med->ring_page ) > - return -EBUSY; > - > - /* The parameter defaults to zero, and it should be > - * set to something */ > - if ( ring_gfn == 0 ) > - return -ENOSYS; > - > - mem_event_ring_lock_init(med); > - mem_event_ring_lock(med); > - > - rc = prepare_ring_for_helper(d, ring_gfn, &med->ring_pg_struct, > - &med->ring_page); > - if ( rc < 0 ) > - goto err; > - > - /* Set the number of currently blocked vCPUs to 0. */ > - med->blocked = 0; > - > - /* Allocate event channel */ > - rc = alloc_unbound_xen_event_channel(d->vcpu[0], > - current->domain->domain_id, > - notification_fn); > - if ( rc < 0 ) > - goto err; > - > - med->xen_port = mec->port = rc; > - > - /* Prepare ring buffer */ > - FRONT_RING_INIT(&med->front_ring, > - (mem_event_sring_t *)med->ring_page, > - PAGE_SIZE); > - > - /* Save the pause flag for this particular ring. */ > - med->pause_flag = pause_flag; > - > - /* Initialize the last-chance wait queue. */ > - init_waitqueue_head(&med->wq); > - > - mem_event_ring_unlock(med); > - return 0; > - > - err: > - destroy_ring_for_helper(&med->ring_page, > - med->ring_pg_struct); > - mem_event_ring_unlock(med); > - > - return rc; > -} > - > -static unsigned int mem_event_ring_available(struct mem_event_domain *med) > -{ > - int avail_req = RING_FREE_REQUESTS(&med->front_ring); > - avail_req -= med->target_producers; > - avail_req -= med->foreign_producers; > - > - BUG_ON(avail_req < 0); > - > - return avail_req; > -} > - > -/* > - * mem_event_wake_blocked() will wakeup vcpus waiting for room in the > - * ring. These vCPUs were paused on their way out after placing an event, > - * but need to be resumed where the ring is capable of processing at least > - * one event from them. > - */ > -static void mem_event_wake_blocked(struct domain *d, struct mem_event_domain *med) > -{ > - struct vcpu *v; > - int online = d->max_vcpus; > - unsigned int avail_req = mem_event_ring_available(med); > - > - if ( avail_req == 0 || med->blocked == 0 ) > - return; > - > - /* > - * We ensure that we only have vCPUs online if there are enough free slots > - * for their memory events to be processed. This will ensure that no > - * memory events are lost (due to the fact that certain types of events > - * cannot be replayed, we need to ensure that there is space in the ring > - * for when they are hit). > - * See comment below in mem_event_put_request(). > - */ > - for_each_vcpu ( d, v ) > - if ( test_bit(med->pause_flag, &v->pause_flags) ) > - online--; > - > - ASSERT(online == (d->max_vcpus - med->blocked)); > - > - /* We remember which vcpu last woke up to avoid scanning always linearly > - * from zero and starving higher-numbered vcpus under high load */ > - if ( d->vcpu ) > - { > - int i, j, k; > - > - for (i = med->last_vcpu_wake_up + 1, j = 0; j < d->max_vcpus; i++, j++) > - { > - k = i % d->max_vcpus; > - v = d->vcpu[k]; > - if ( !v ) > - continue; > - > - if ( !(med->blocked) || online >= avail_req ) > - break; > - > - if ( test_and_clear_bit(med->pause_flag, &v->pause_flags) ) > - { > - vcpu_unpause(v); > - online++; > - med->blocked--; > - med->last_vcpu_wake_up = k; > - } > - } > - } > -} > - > -/* > - * In the event that a vCPU attempted to place an event in the ring and > - * was unable to do so, it is queued on a wait queue. These are woken as > - * needed, and take precedence over the blocked vCPUs. > - */ > -static void mem_event_wake_queued(struct domain *d, struct mem_event_domain *med) > -{ > - unsigned int avail_req = mem_event_ring_available(med); > - > - if ( avail_req > 0 ) > - wake_up_nr(&med->wq, avail_req); > -} > - > -/* > - * mem_event_wake() will wakeup all vcpus waiting for the ring to > - * become available. If we have queued vCPUs, they get top priority. We > - * are guaranteed that they will go through code paths that will eventually > - * call mem_event_wake() again, ensuring that any blocked vCPUs will get > - * unpaused once all the queued vCPUs have made it through. > - */ > -void mem_event_wake(struct domain *d, struct mem_event_domain *med) > -{ > - if (!list_empty(&med->wq.list)) > - mem_event_wake_queued(d, med); > - else > - mem_event_wake_blocked(d, med); > -} > - > -static int mem_event_disable(struct domain *d, struct mem_event_domain *med) > -{ > - if ( med->ring_page ) > - { > - struct vcpu *v; > - > - mem_event_ring_lock(med); > - > - if ( !list_empty(&med->wq.list) ) > - { > - mem_event_ring_unlock(med); > - return -EBUSY; > - } > - > - /* Free domU's event channel and leave the other one unbound */ > - free_xen_event_channel(d->vcpu[0], med->xen_port); > - > - /* Unblock all vCPUs */ > - for_each_vcpu ( d, v ) > - { > - if ( test_and_clear_bit(med->pause_flag, &v->pause_flags) ) > - { > - vcpu_unpause(v); > - med->blocked--; > - } > - } > - > - destroy_ring_for_helper(&med->ring_page, > - med->ring_pg_struct); > - mem_event_ring_unlock(med); > - } > - > - return 0; > -} > - > -static inline void mem_event_release_slot(struct domain *d, > - struct mem_event_domain *med) > -{ > - /* Update the accounting */ > - if ( current->domain == d ) > - med->target_producers--; > - else > - med->foreign_producers--; > - > - /* Kick any waiters */ > - mem_event_wake(d, med); > -} > - > -/* > - * mem_event_mark_and_pause() tags vcpu and put it to sleep. > - * The vcpu will resume execution in mem_event_wake_waiters(). > - */ > -void mem_event_mark_and_pause(struct vcpu *v, struct mem_event_domain *med) > -{ > - if ( !test_and_set_bit(med->pause_flag, &v->pause_flags) ) > - { > - vcpu_pause_nosync(v); > - med->blocked++; > - } > -} > - > -/* > - * This must be preceded by a call to claim_slot(), and is guaranteed to > - * succeed. As a side-effect however, the vCPU may be paused if the ring is > - * overly full and its continued execution would cause stalling and excessive > - * waiting. The vCPU will be automatically unpaused when the ring clears. > - */ > -void mem_event_put_request(struct domain *d, > - struct mem_event_domain *med, > - mem_event_request_t *req) > -{ > - mem_event_front_ring_t *front_ring; > - int free_req; > - unsigned int avail_req; > - RING_IDX req_prod; > - > - if ( current->domain != d ) > - { > - req->flags |= MEM_EVENT_FLAG_FOREIGN; > -#ifndef NDEBUG > - if ( !(req->flags & MEM_EVENT_FLAG_VCPU_PAUSED) ) > - gdprintk(XENLOG_G_WARNING, "d%dv%d was not paused.\n", > - d->domain_id, req->vcpu_id); > -#endif > - } > - > - mem_event_ring_lock(med); > - > - /* Due to the reservations, this step must succeed. */ > - front_ring = &med->front_ring; > - free_req = RING_FREE_REQUESTS(front_ring); > - ASSERT(free_req > 0); > - > - /* Copy request */ > - req_prod = front_ring->req_prod_pvt; > - memcpy(RING_GET_REQUEST(front_ring, req_prod), req, sizeof(*req)); > - req_prod++; > - > - /* Update ring */ > - front_ring->req_prod_pvt = req_prod; > - RING_PUSH_REQUESTS(front_ring); > - > - /* We've actually *used* our reservation, so release the slot. */ > - mem_event_release_slot(d, med); > - > - /* Give this vCPU a black eye if necessary, on the way out. > - * See the comments above wake_blocked() for more information > - * on how this mechanism works to avoid waiting. */ > - avail_req = mem_event_ring_available(med); > - if( current->domain == d && avail_req < d->max_vcpus ) > - mem_event_mark_and_pause(current, med); > - > - mem_event_ring_unlock(med); > - > - notify_via_xen_event_channel(d, med->xen_port); > -} > - > -int mem_event_get_response(struct domain *d, struct mem_event_domain *med, mem_event_response_t *rsp) > -{ > - mem_event_front_ring_t *front_ring; > - RING_IDX rsp_cons; > - > - mem_event_ring_lock(med); > - > - front_ring = &med->front_ring; > - rsp_cons = front_ring->rsp_cons; > - > - if ( !RING_HAS_UNCONSUMED_RESPONSES(front_ring) ) > - { > - mem_event_ring_unlock(med); > - return 0; > - } > - > - /* Copy response */ > - memcpy(rsp, RING_GET_RESPONSE(front_ring, rsp_cons), sizeof(*rsp)); > - rsp_cons++; > - > - /* Update ring */ > - front_ring->rsp_cons = rsp_cons; > - front_ring->sring->rsp_event = rsp_cons + 1; > - > - /* Kick any waiters -- since we've just consumed an event, > - * there may be additional space available in the ring. */ > - mem_event_wake(d, med); > - > - mem_event_ring_unlock(med); > - > - return 1; > -} > - > -void mem_event_cancel_slot(struct domain *d, struct mem_event_domain *med) > -{ > - mem_event_ring_lock(med); > - mem_event_release_slot(d, med); > - mem_event_ring_unlock(med); > -} > - > -static int mem_event_grab_slot(struct mem_event_domain *med, int foreign) > -{ > - unsigned int avail_req; > - > - if ( !med->ring_page ) > - return -ENOSYS; > - > - mem_event_ring_lock(med); > - > - avail_req = mem_event_ring_available(med); > - if ( avail_req == 0 ) > - { > - mem_event_ring_unlock(med); > - return -EBUSY; > - } > - > - if ( !foreign ) > - med->target_producers++; > - else > - med->foreign_producers++; > - > - mem_event_ring_unlock(med); > - > - return 0; > -} > - > -/* Simple try_grab wrapper for use in the wait_event() macro. */ > -static int mem_event_wait_try_grab(struct mem_event_domain *med, int *rc) > -{ > - *rc = mem_event_grab_slot(med, 0); > - return *rc; > -} > - > -/* Call mem_event_grab_slot() until the ring doesn't exist, or is available. */ > -static int mem_event_wait_slot(struct mem_event_domain *med) > -{ > - int rc = -EBUSY; > - wait_event(med->wq, mem_event_wait_try_grab(med, &rc) != -EBUSY); > - return rc; > -} > - > -bool_t mem_event_check_ring(struct mem_event_domain *med) > -{ > - return (med->ring_page != NULL); > -} > - > -/* > - * Determines whether or not the current vCPU belongs to the target domain, > - * and calls the appropriate wait function. If it is a guest vCPU, then we > - * use mem_event_wait_slot() to reserve a slot. As long as there is a ring, > - * this function will always return 0 for a guest. For a non-guest, we check > - * for space and return -EBUSY if the ring is not available. > - * > - * Return codes: -ENOSYS: the ring is not yet configured > - * -EBUSY: the ring is busy > - * 0: a spot has been reserved > - * > - */ > -int __mem_event_claim_slot(struct domain *d, struct mem_event_domain *med, > - bool_t allow_sleep) > -{ > - if ( (current->domain == d) && allow_sleep ) > - return mem_event_wait_slot(med); > - else > - return mem_event_grab_slot(med, (current->domain != d)); > -} > - > -#ifdef HAS_MEM_PAGING > -/* Registered with Xen-bound event channel for incoming notifications. */ > -static void mem_paging_notification(struct vcpu *v, unsigned int port) > -{ > - if ( likely(v->domain->mem_event->paging.ring_page != NULL) ) > - p2m_mem_paging_resume(v->domain); > -} > -#endif > - > -#ifdef HAS_MEM_ACCESS > -/* Registered with Xen-bound event channel for incoming notifications. */ > -static void mem_access_notification(struct vcpu *v, unsigned int port) > -{ > - if ( likely(v->domain->mem_event->monitor.ring_page != NULL) ) > - mem_access_resume(v->domain); > -} > -#endif > - > -#ifdef HAS_MEM_SHARING > -/* Registered with Xen-bound event channel for incoming notifications. */ > -static void mem_sharing_notification(struct vcpu *v, unsigned int port) > -{ > - if ( likely(v->domain->mem_event->share.ring_page != NULL) ) > - mem_sharing_sharing_resume(v->domain); > -} > -#endif > - > -int do_mem_event_op(int op, uint32_t domain, void *arg) > -{ > - int ret; > - struct domain *d; > - > - ret = rcu_lock_live_remote_domain_by_id(domain, &d); > - if ( ret ) > - return ret; > - > - ret = xsm_mem_event_op(XSM_DM_PRIV, d, op); > - if ( ret ) > - goto out; > - > - switch (op) > - { > -#ifdef HAS_MEM_PAGING > - case XENMEM_paging_op: > - ret = mem_paging_memop(d, (xen_mem_paging_op_t *) arg); > - break; > -#endif > -#ifdef HAS_MEM_SHARING > - case XENMEM_sharing_op: > - ret = mem_sharing_memop(d, (xen_mem_sharing_op_t *) arg); > - break; > -#endif > - default: > - ret = -ENOSYS; > - } > - > - out: > - rcu_unlock_domain(d); > - return ret; > -} > - > -/* Clean up on domain destruction */ > -void mem_event_cleanup(struct domain *d) > -{ > -#ifdef HAS_MEM_PAGING > - if ( d->mem_event->paging.ring_page ) { > - /* Destroying the wait queue head means waking up all > - * queued vcpus. This will drain the list, allowing > - * the disable routine to complete. It will also drop > - * all domain refs the wait-queued vcpus are holding. > - * Finally, because this code path involves previously > - * pausing the domain (domain_kill), unpausing the > - * vcpus causes no harm. */ > - destroy_waitqueue_head(&d->mem_event->paging.wq); > - (void)mem_event_disable(d, &d->mem_event->paging); > - } > -#endif > -#ifdef HAS_MEM_ACCESS > - if ( d->mem_event->monitor.ring_page ) { > - destroy_waitqueue_head(&d->mem_event->monitor.wq); > - (void)mem_event_disable(d, &d->mem_event->monitor); > - } > -#endif > -#ifdef HAS_MEM_SHARING > - if ( d->mem_event->share.ring_page ) { > - destroy_waitqueue_head(&d->mem_event->share.wq); > - (void)mem_event_disable(d, &d->mem_event->share); > - } > -#endif > -} > - > -int mem_event_domctl(struct domain *d, xen_domctl_mem_event_op_t *mec, > - XEN_GUEST_HANDLE_PARAM(void) u_domctl) > -{ > - int rc; > - > - rc = xsm_mem_event_control(XSM_PRIV, d, mec->mode, mec->op); > - if ( rc ) > - return rc; > - > - if ( unlikely(d == current->domain) ) > - { > - gdprintk(XENLOG_INFO, "Tried to do a memory event op on itself.\n"); > - return -EINVAL; > - } > - > - if ( unlikely(d->is_dying) ) > - { > - gdprintk(XENLOG_INFO, "Ignoring memory event op on dying domain %u\n", > - d->domain_id); > - return 0; > - } > - > - if ( unlikely(d->vcpu == NULL) || unlikely(d->vcpu[0] == NULL) ) > - { > - gdprintk(XENLOG_INFO, > - "Memory event op on a domain (%u) with no vcpus\n", > - d->domain_id); > - return -EINVAL; > - } > - > - rc = -ENOSYS; > - > - switch ( mec->mode ) > - { > -#ifdef HAS_MEM_PAGING > - case XEN_DOMCTL_MEM_EVENT_OP_PAGING: > - { > - struct mem_event_domain *med = &d->mem_event->paging; > - rc = -EINVAL; > - > - switch( mec->op ) > - { > - case XEN_DOMCTL_MEM_EVENT_OP_PAGING_ENABLE: > - { > - struct p2m_domain *p2m = p2m_get_hostp2m(d); > - > - rc = -EOPNOTSUPP; > - /* pvh fixme: p2m_is_foreign types need addressing */ > - if ( is_pvh_vcpu(current) || is_pvh_domain(hardware_domain) ) > - break; > - > - rc = -ENODEV; > - /* Only HAP is supported */ > - if ( !hap_enabled(d) ) > - break; > - > - /* No paging if iommu is used */ > - rc = -EMLINK; > - if ( unlikely(need_iommu(d)) ) > - break; > - > - rc = -EXDEV; > - /* Disallow paging in a PoD guest */ > - if ( p2m->pod.entry_count ) > - break; > - > - rc = mem_event_enable(d, mec, med, _VPF_mem_paging, > - HVM_PARAM_PAGING_RING_PFN, > - mem_paging_notification); > - } > - break; > - > - case XEN_DOMCTL_MEM_EVENT_OP_PAGING_DISABLE: > - { > - if ( med->ring_page ) > - rc = mem_event_disable(d, med); > - } > - break; > - > - default: > - rc = -ENOSYS; > - break; > - } > - } > - break; > -#endif > - > -#ifdef HAS_MEM_ACCESS > - case XEN_DOMCTL_MEM_EVENT_OP_MONITOR: > - { > - struct mem_event_domain *med = &d->mem_event->monitor; > - rc = -EINVAL; > - > - switch( mec->op ) > - { > - case XEN_DOMCTL_MEM_EVENT_OP_MONITOR_ENABLE: > - case XEN_DOMCTL_MEM_EVENT_OP_MONITOR_ENABLE_INTROSPECTION: > - { > - rc = -ENODEV; > - if ( !p2m_mem_event_sanity_check(d) ) > - break; > - > - rc = mem_event_enable(d, mec, med, _VPF_mem_access, > - HVM_PARAM_MONITOR_RING_PFN, > - mem_access_notification); > - > - if ( mec->op == XEN_DOMCTL_MEM_EVENT_OP_MONITOR_ENABLE_INTROSPECTION > - && !rc ) > - p2m_setup_introspection(d); > - > - } > - break; > - > - case XEN_DOMCTL_MEM_EVENT_OP_MONITOR_DISABLE: > - { > - if ( med->ring_page ) > - { > - rc = mem_event_disable(d, med); > - d->arch.hvm_domain.introspection_enabled = 0; > - } > - } > - break; > - > - default: > - rc = -ENOSYS; > - break; > - } > - } > - break; > -#endif > - > -#ifdef HAS_MEM_SHARING > - case XEN_DOMCTL_MEM_EVENT_OP_SHARING: > - { > - struct mem_event_domain *med = &d->mem_event->share; > - rc = -EINVAL; > - > - switch( mec->op ) > - { > - case XEN_DOMCTL_MEM_EVENT_OP_SHARING_ENABLE: > - { > - rc = -EOPNOTSUPP; > - /* pvh fixme: p2m_is_foreign types need addressing */ > - if ( is_pvh_vcpu(current) || is_pvh_domain(hardware_domain) ) > - break; > - > - rc = -ENODEV; > - /* Only HAP is supported */ > - if ( !hap_enabled(d) ) > - break; > - > - rc = mem_event_enable(d, mec, med, _VPF_mem_sharing, > - HVM_PARAM_SHARING_RING_PFN, > - mem_sharing_notification); > - } > - break; > - > - case XEN_DOMCTL_MEM_EVENT_OP_SHARING_DISABLE: > - { > - if ( med->ring_page ) > - rc = mem_event_disable(d, med); > - } > - break; > - > - default: > - rc = -ENOSYS; > - break; > - } > - } > - break; > -#endif > - > - default: > - rc = -ENOSYS; > - } > - > - return rc; > -} > - > -void mem_event_vcpu_pause(struct vcpu *v) > -{ > - ASSERT(v == current); > - > - atomic_inc(&v->mem_event_pause_count); > - vcpu_pause_nosync(v); > -} > - > -void mem_event_vcpu_unpause(struct vcpu *v) > -{ > - int old, new, prev = v->mem_event_pause_count.counter; > - > - /* All unpause requests as a result of toolstack responses. Prevent > - * underflow of the vcpu pause count. */ > - do > - { > - old = prev; > - new = old - 1; > - > - if ( new < 0 ) > - { > - printk(XENLOG_G_WARNING > - "%pv mem_event: Too many unpause attempts\n", v); > - return; > - } > - > - prev = cmpxchg(&v->mem_event_pause_count.counter, old, new); > - } while ( prev != old ); > - > - vcpu_unpause(v); > -} > - > -/* > - * Local variables: > - * mode: C > - * c-file-style: "BSD" > - * c-basic-offset: 4 > - * indent-tabs-mode: nil > - * End: > - */ > diff --git a/xen/common/vm_event.c b/xen/common/vm_event.c > new file mode 100644 > index 0000000..f81eae4 > --- /dev/null > +++ b/xen/common/vm_event.c > @@ -0,0 +1,742 @@ > +/****************************************************************************** > + * vm_event.c > + * > + * VM event support. > + * > + * Copyright (c) 2009 Citrix Systems, Inc. (Patrick Colp) > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > + */ > + > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#ifdef HAS_MEM_PAGING > +#include > +#endif > + > +#ifdef HAS_MEM_SHARING > +#include > +#endif > + > +#include > + > +/* for public/io/ring.h macros */ > +#define xen_mb() mb() > +#define xen_rmb() rmb() > +#define xen_wmb() wmb() > + > +#define vm_event_ring_lock_init(_ved) spin_lock_init(&(_ved)->ring_lock) > +#define vm_event_ring_lock(_ved) spin_lock(&(_ved)->ring_lock) > +#define vm_event_ring_unlock(_ved) spin_unlock(&(_ved)->ring_lock) > + > +static int vm_event_enable( > + struct domain *d, > + xen_domctl_vm_event_op_t *vec, > + struct vm_event_domain *ved, > + int pause_flag, > + int param, > + xen_event_channel_notification_t notification_fn) > +{ > + int rc; > + unsigned long ring_gfn = d->arch.hvm_domain.params[param]; > + > + /* Only one helper at a time. If the helper crashed, > + * the ring is in an undefined state and so is the guest. > + */ > + if ( ved->ring_page ) > + return -EBUSY; > + > + /* The parameter defaults to zero, and it should be > + * set to something */ > + if ( ring_gfn == 0 ) > + return -ENOSYS; > + > + vm_event_ring_lock_init(ved); > + vm_event_ring_lock(ved); > + > + rc = prepare_ring_for_helper(d, ring_gfn, &ved->ring_pg_struct, > + &ved->ring_page); > + if ( rc < 0 ) > + goto err; > + > + /* Set the number of currently blocked vCPUs to 0. */ > + ved->blocked = 0; > + > + /* Allocate event channel */ > + rc = alloc_unbound_xen_event_channel(d->vcpu[0], > + current->domain->domain_id, > + notification_fn); > + if ( rc < 0 ) > + goto err; > + > + ved->xen_port = vec->port = rc; > + > + /* Prepare ring buffer */ > + FRONT_RING_INIT(&ved->front_ring, > + (vm_event_sring_t *)ved->ring_page, > + PAGE_SIZE); > + > + /* Save the pause flag for this particular ring. */ > + ved->pause_flag = pause_flag; > + > + /* Initialize the last-chance wait queue. */ > + init_waitqueue_head(&ved->wq); > + > + vm_event_ring_unlock(ved); > + return 0; > + > + err: > + destroy_ring_for_helper(&ved->ring_page, > + ved->ring_pg_struct); > + vm_event_ring_unlock(ved); > + > + return rc; > +} > + > +static unsigned int vm_event_ring_available(struct vm_event_domain *ved) > +{ > + int avail_req = RING_FREE_REQUESTS(&ved->front_ring); > + avail_req -= ved->target_producers; > + avail_req -= ved->foreign_producers; > + > + BUG_ON(avail_req < 0); > + > + return avail_req; > +} > + > +/* > + * vm_event_wake_blocked() will wakeup vcpus waiting for room in the > + * ring. These vCPUs were paused on their way out after placing an event, > + * but need to be resumed where the ring is capable of processing at least > + * one event from them. > + */ > +static void vm_event_wake_blocked(struct domain *d, struct vm_event_domain *ved) > +{ > + struct vcpu *v; > + int online = d->max_vcpus; > + unsigned int avail_req = vm_event_ring_available(ved); > + > + if ( avail_req == 0 || ved->blocked == 0 ) > + return; > + > + /* > + * We ensure that we only have vCPUs online if there are enough free slots > + * for their memory events to be processed. This will ensure that no > + * memory events are lost (due to the fact that certain types of events > + * cannot be replayed, we need to ensure that there is space in the ring > + * for when they are hit). > + * See comment below in vm_event_put_request(). > + */ > + for_each_vcpu ( d, v ) > + if ( test_bit(ved->pause_flag, &v->pause_flags) ) > + online--; > + > + ASSERT(online == (d->max_vcpus - ved->blocked)); > + > + /* We remember which vcpu last woke up to avoid scanning always linearly > + * from zero and starving higher-numbered vcpus under high load */ > + if ( d->vcpu ) > + { > + int i, j, k; > + > + for (i = ved->last_vcpu_wake_up + 1, j = 0; j < d->max_vcpus; i++, j++) > + { > + k = i % d->max_vcpus; > + v = d->vcpu[k]; > + if ( !v ) > + continue; > + > + if ( !(ved->blocked) || online >= avail_req ) > + break; > + > + if ( test_and_clear_bit(ved->pause_flag, &v->pause_flags) ) > + { > + vcpu_unpause(v); > + online++; > + ved->blocked--; > + ved->last_vcpu_wake_up = k; > + } > + } > + } > +} > + > +/* > + * In the event that a vCPU attempted to place an event in the ring and > + * was unable to do so, it is queued on a wait queue. These are woken as > + * needed, and take precedence over the blocked vCPUs. > + */ > +static void vm_event_wake_queued(struct domain *d, struct vm_event_domain *ved) > +{ > + unsigned int avail_req = vm_event_ring_available(ved); > + > + if ( avail_req > 0 ) > + wake_up_nr(&ved->wq, avail_req); > +} > + > +/* > + * vm_event_wake() will wakeup all vcpus waiting for the ring to > + * become available. If we have queued vCPUs, they get top priority. We > + * are guaranteed that they will go through code paths that will eventually > + * call vm_event_wake() again, ensuring that any blocked vCPUs will get > + * unpaused once all the queued vCPUs have made it through. > + */ > +void vm_event_wake(struct domain *d, struct vm_event_domain *ved) > +{ > + if (!list_empty(&ved->wq.list)) > + vm_event_wake_queued(d, ved); > + else > + vm_event_wake_blocked(d, ved); > +} > + > +static int vm_event_disable(struct domain *d, struct vm_event_domain *ved) > +{ > + if ( ved->ring_page ) > + { > + struct vcpu *v; > + > + vm_event_ring_lock(ved); > + > + if ( !list_empty(&ved->wq.list) ) > + { > + vm_event_ring_unlock(ved); > + return -EBUSY; > + } > + > + /* Free domU's event channel and leave the other one unbound */ > + free_xen_event_channel(d->vcpu[0], ved->xen_port); > + > + /* Unblock all vCPUs */ > + for_each_vcpu ( d, v ) > + { > + if ( test_and_clear_bit(ved->pause_flag, &v->pause_flags) ) > + { > + vcpu_unpause(v); > + ved->blocked--; > + } > + } > + > + destroy_ring_for_helper(&ved->ring_page, > + ved->ring_pg_struct); > + vm_event_ring_unlock(ved); > + } > + > + return 0; > +} > + > +static inline void vm_event_release_slot(struct domain *d, > + struct vm_event_domain *ved) > +{ > + /* Update the accounting */ > + if ( current->domain == d ) > + ved->target_producers--; > + else > + ved->foreign_producers--; > + > + /* Kick any waiters */ > + vm_event_wake(d, ved); > +} > + > +/* > + * vm_event_mark_and_pause() tags vcpu and put it to sleep. > + * The vcpu will resume execution in vm_event_wake_waiters(). > + */ > +void vm_event_mark_and_pause(struct vcpu *v, struct vm_event_domain *ved) > +{ > + if ( !test_and_set_bit(ved->pause_flag, &v->pause_flags) ) > + { > + vcpu_pause_nosync(v); > + ved->blocked++; > + } > +} > + > +/* > + * This must be preceded by a call to claim_slot(), and is guaranteed to > + * succeed. As a side-effect however, the vCPU may be paused if the ring is > + * overly full and its continued execution would cause stalling and excessive > + * waiting. The vCPU will be automatically unpaused when the ring clears. > + */ > +void vm_event_put_request(struct domain *d, > + struct vm_event_domain *ved, > + vm_event_request_t *req) > +{ > + vm_event_front_ring_t *front_ring; > + int free_req; > + unsigned int avail_req; > + RING_IDX req_prod; > + > + if ( current->domain != d ) > + { > + req->flags |= VM_EVENT_FLAG_FOREIGN; > +#ifndef NDEBUG > + if ( !(req->flags & VM_EVENT_FLAG_VCPU_PAUSED) ) > + gdprintk(XENLOG_G_WARNING, "d%dv%d was not paused.\n", > + d->domain_id, req->vcpu_id); > +#endif > + } > + > + vm_event_ring_lock(ved); > + > + /* Due to the reservations, this step must succeed. */ > + front_ring = &ved->front_ring; > + free_req = RING_FREE_REQUESTS(front_ring); > + ASSERT(free_req > 0); > + > + /* Copy request */ > + req_prod = front_ring->req_prod_pvt; > + memcpy(RING_GET_REQUEST(front_ring, req_prod), req, sizeof(*req)); > + req_prod++; > + > + /* Update ring */ > + front_ring->req_prod_pvt = req_prod; > + RING_PUSH_REQUESTS(front_ring); > + > + /* We've actually *used* our reservation, so release the slot. */ > + vm_event_release_slot(d, ved); > + > + /* Give this vCPU a black eye if necessary, on the way out. > + * See the comments above wake_blocked() for more information > + * on how this vechanism works to avoid waiting. */ > + avail_req = vm_event_ring_available(ved); > + if( current->domain == d && avail_req < d->max_vcpus ) > + vm_event_mark_and_pause(current, ved); > + > + vm_event_ring_unlock(ved); > + > + notify_via_xen_event_channel(d, ved->xen_port); > +} > + > +int vm_event_get_response(struct domain *d, struct vm_event_domain *ved, vm_event_response_t *rsp) > +{ > + vm_event_front_ring_t *front_ring; > + RING_IDX rsp_cons; > + > + vm_event_ring_lock(ved); > + > + front_ring = &ved->front_ring; > + rsp_cons = front_ring->rsp_cons; > + > + if ( !RING_HAS_UNCONSUMED_RESPONSES(front_ring) ) > + { > + vm_event_ring_unlock(ved); > + return 0; > + } > + > + /* Copy response */ > + memcpy(rsp, RING_GET_RESPONSE(front_ring, rsp_cons), sizeof(*rsp)); > + rsp_cons++; > + > + /* Update ring */ > + front_ring->rsp_cons = rsp_cons; > + front_ring->sring->rsp_event = rsp_cons + 1; > + > + /* Kick any waiters -- since we've just consumed an event, > + * there may be additional space available in the ring. */ > + vm_event_wake(d, ved); > + > + vm_event_ring_unlock(ved); > + > + return 1; > +} > + > +void vm_event_cancel_slot(struct domain *d, struct vm_event_domain *ved) > +{ > + vm_event_ring_lock(ved); > + vm_event_release_slot(d, ved); > + vm_event_ring_unlock(ved); > +} > + > +static int vm_event_grab_slot(struct vm_event_domain *ved, int foreign) > +{ > + unsigned int avail_req; > + > + if ( !ved->ring_page ) > + return -ENOSYS; > + > + vm_event_ring_lock(ved); > + > + avail_req = vm_event_ring_available(ved); > + if ( avail_req == 0 ) > + { > + vm_event_ring_unlock(ved); > + return -EBUSY; > + } > + > + if ( !foreign ) > + ved->target_producers++; > + else > + ved->foreign_producers++; > + > + vm_event_ring_unlock(ved); > + > + return 0; > +} > + > +/* Simple try_grab wrapper for use in the wait_event() macro. */ > +static int vm_event_wait_try_grab(struct vm_event_domain *ved, int *rc) > +{ > + *rc = vm_event_grab_slot(ved, 0); > + return *rc; > +} > + > +/* Call vm_event_grab_slot() until the ring doesn't exist, or is available. */ > +static int vm_event_wait_slot(struct vm_event_domain *ved) > +{ > + int rc = -EBUSY; > + wait_event(ved->wq, vm_event_wait_try_grab(ved, &rc) != -EBUSY); > + return rc; > +} > + > +bool_t vm_event_check_ring(struct vm_event_domain *ved) > +{ > + return (ved->ring_page != NULL); > +} > + > +/* > + * Determines whether or not the current vCPU belongs to the target domain, > + * and calls the appropriate wait function. If it is a guest vCPU, then we > + * use vm_event_wait_slot() to reserve a slot. As long as there is a ring, > + * this function will always return 0 for a guest. For a non-guest, we check > + * for space and return -EBUSY if the ring is not available. > + * > + * Return codes: -ENOSYS: the ring is not yet configured > + * -EBUSY: the ring is busy > + * 0: a spot has been reserved > + * > + */ > +int __vm_event_claim_slot(struct domain *d, struct vm_event_domain *ved, > + bool_t allow_sleep) > +{ > + if ( (current->domain == d) && allow_sleep ) > + return vm_event_wait_slot(ved); > + else > + return vm_event_grab_slot(ved, (current->domain != d)); > +} > + > +#ifdef HAS_MEM_PAGING > +/* Registered with Xen-bound event channel for incoming notifications. */ > +static void mem_paging_notification(struct vcpu *v, unsigned int port) > +{ > + if ( likely(v->domain->vm_event->paging.ring_page != NULL) ) > + p2m_mem_paging_resume(v->domain); > +} > +#endif > + > +#ifdef HAS_MEM_ACCESS > +/* Registered with Xen-bound event channel for incoming notifications. */ > +static void mem_access_notification(struct vcpu *v, unsigned int port) > +{ > + if ( likely(v->domain->vm_event->monitor.ring_page != NULL) ) > + mem_access_resume(v->domain); > +} > +#endif > + > +#ifdef HAS_MEM_SHARING > +/* Registered with Xen-bound event channel for incoming notifications. */ > +static void mem_sharing_notification(struct vcpu *v, unsigned int port) > +{ > + if ( likely(v->domain->vm_event->share.ring_page != NULL) ) > + mem_sharing_sharing_resume(v->domain); > +} > +#endif > + > +int do_vm_event_op(int op, uint32_t domain, void *arg) > +{ > + int ret; > + struct domain *d; > + > + ret = rcu_lock_live_remote_domain_by_id(domain, &d); > + if ( ret ) > + return ret; > + > + ret = xsm_vm_event_op(XSM_DM_PRIV, d, op); > + if ( ret ) > + goto out; > + > + switch (op) > + { > +#ifdef HAS_MEM_PAGING > + case XENMEM_paging_op: > + ret = mem_paging_memop(d, (xen_mem_paging_op_t *) arg); > + break; > +#endif > +#ifdef HAS_MEM_SHARING > + case XENMEM_sharing_op: > + ret = mem_sharing_memop(d, (xen_mem_sharing_op_t *) arg); > + break; > +#endif > + default: > + ret = -ENOSYS; > + } > + > + out: > + rcu_unlock_domain(d); > + return ret; > +} > + > +/* Clean up on domain destruction */ > +void vm_event_cleanup(struct domain *d) > +{ > +#ifdef HAS_MEM_PAGING > + if ( d->vm_event->paging.ring_page ) { > + /* Destroying the wait queue head means waking up all > + * queued vcpus. This will drain the list, allowing > + * the disable routine to complete. It will also drop > + * all domain refs the wait-queued vcpus are holding. > + * Finally, because this code path involves previously > + * pausing the domain (domain_kill), unpausing the > + * vcpus causes no harm. */ > + destroy_waitqueue_head(&d->vm_event->paging.wq); > + (void)vm_event_disable(d, &d->vm_event->paging); > + } > +#endif > +#ifdef HAS_MEM_ACCESS > + if ( d->vm_event->monitor.ring_page ) { > + destroy_waitqueue_head(&d->vm_event->monitor.wq); > + (void)vm_event_disable(d, &d->vm_event->monitor); > + } > +#endif > +#ifdef HAS_MEM_SHARING > + if ( d->vm_event->share.ring_page ) { > + destroy_waitqueue_head(&d->vm_event->share.wq); > + (void)vm_event_disable(d, &d->vm_event->share); > + } > +#endif > +} > + > +int vm_event_domctl(struct domain *d, xen_domctl_vm_event_op_t *vec, > + XEN_GUEST_HANDLE_PARAM(void) u_domctl) > +{ > + int rc; > + > + rc = xsm_vm_event_control(XSM_PRIV, d, vec->mode, vec->op); > + if ( rc ) > + return rc; > + > + if ( unlikely(d == current->domain) ) > + { > + gdprintk(XENLOG_INFO, "Tried to do a memory event op on itself.\n"); > + return -EINVAL; > + } > + > + if ( unlikely(d->is_dying) ) > + { > + gdprintk(XENLOG_INFO, "Ignoring memory event op on dying domain %u\n", > + d->domain_id); > + return 0; > + } > + > + if ( unlikely(d->vcpu == NULL) || unlikely(d->vcpu[0] == NULL) ) > + { > + gdprintk(XENLOG_INFO, > + "Memory event op on a domain (%u) with no vcpus\n", > + d->domain_id); > + return -EINVAL; > + } > + > + rc = -ENOSYS; > + > + switch ( vec->mode ) > + { > +#ifdef HAS_MEM_PAGING > + case XEN_DOMCTL_VM_EVENT_OP_PAGING: > + { > + struct vm_event_domain *ved = &d->vm_event->paging; > + rc = -EINVAL; > + > + switch( vec->op ) > + { > + case XEN_DOMCTL_VM_EVENT_OP_PAGING_ENABLE: > + { > + struct p2m_domain *p2m = p2m_get_hostp2m(d); > + > + rc = -EOPNOTSUPP; > + /* pvh fixme: p2m_is_foreign types need addressing */ > + if ( is_pvh_vcpu(current) || is_pvh_domain(hardware_domain) ) > + break; > + > + rc = -ENODEV; > + /* Only HAP is supported */ > + if ( !hap_enabled(d) ) > + break; > + > + /* No paging if iommu is used */ > + rc = -EMLINK; > + if ( unlikely(need_iommu(d)) ) > + break; > + > + rc = -EXDEV; > + /* Disallow paging in a PoD guest */ > + if ( p2m->pod.entry_count ) > + break; > + > + rc = vm_event_enable(d, vec, ved, _VPF_mem_paging, > + HVM_PARAM_PAGING_RING_PFN, > + mem_paging_notification); > + } > + break; > + > + case XEN_DOMCTL_VM_EVENT_OP_PAGING_DISABLE: > + { > + if ( ved->ring_page ) > + rc = vm_event_disable(d, ved); > + } > + break; > + > + default: > + rc = -ENOSYS; > + break; > + } > + } > + break; > +#endif > + > +#ifdef HAS_MEM_ACCESS > + case XEN_DOMCTL_VM_EVENT_OP_MONITOR: > + { > + struct vm_event_domain *ved = &d->vm_event->monitor; > + rc = -EINVAL; > + > + switch( vec->op ) > + { > + case XEN_DOMCTL_VM_EVENT_OP_MONITOR_ENABLE: > + case XEN_DOMCTL_VM_EVENT_OP_MONITOR_ENABLE_INTROSPECTION: > + { > + rc = -ENODEV; > + if ( !p2m_mem_access_sanity_check(d) ) > + break; > + > + rc = vm_event_enable(d, vec, ved, _VPF_mem_access, > + HVM_PARAM_MONITOR_RING_PFN, > + mem_access_notification); > + > + if ( vec->op == XEN_DOMCTL_VM_EVENT_OP_MONITOR_ENABLE_INTROSPECTION > + && !rc ) > + p2m_setup_introspection(d); > + > + } > + break; > + > + case XEN_DOMCTL_VM_EVENT_OP_MONITOR_DISABLE: > + { > + if ( ved->ring_page ) > + { > + rc = vm_event_disable(d, ved); > + d->arch.hvm_domain.introspection_enabled = 0; > + } > + } > + break; > + > + default: > + rc = -ENOSYS; > + break; > + } > + } > + break; > +#endif > + > +#ifdef HAS_MEM_SHARING > + case XEN_DOMCTL_VM_EVENT_OP_SHARING: > + { > + struct vm_event_domain *ved = &d->vm_event->share; > + rc = -EINVAL; > + > + switch( vec->op ) > + { > + case XEN_DOMCTL_VM_EVENT_OP_SHARING_ENABLE: > + { > + rc = -EOPNOTSUPP; > + /* pvh fixme: p2m_is_foreign types need addressing */ > + if ( is_pvh_vcpu(current) || is_pvh_domain(hardware_domain) ) > + break; > + > + rc = -ENODEV; > + /* Only HAP is supported */ > + if ( !hap_enabled(d) ) > + break; > + > + rc = vm_event_enable(d, vec, ved, _VPF_mem_sharing, > + HVM_PARAM_SHARING_RING_PFN, > + mem_sharing_notification); > + } > + break; > + > + case XEN_DOMCTL_VM_EVENT_OP_SHARING_DISABLE: > + { > + if ( ved->ring_page ) > + rc = vm_event_disable(d, ved); > + } > + break; > + > + default: > + rc = -ENOSYS; > + break; > + } > + } > + break; > +#endif > + > + default: > + rc = -ENOSYS; > + } > + > + return rc; > +} > + > +void vm_event_vcpu_pause(struct vcpu *v) > +{ > + ASSERT(v == current); > + > + atomic_inc(&v->vm_event_pause_count); > + vcpu_pause_nosync(v); > +} > + > +void vm_event_vcpu_unpause(struct vcpu *v) > +{ > + int old, new, prev = v->vm_event_pause_count.counter; > + > + /* All unpause requests as a result of toolstack responses. Prevent > + * underflow of the vcpu pause count. */ > + do > + { > + old = prev; > + new = old - 1; > + > + if ( new < 0 ) > + { > + printk(XENLOG_G_WARNING > + "%pv vm_event: Too many unpause attempts\n", v); > + return; > + } > + > + prev = cmpxchg(&v->vm_event_pause_count.counter, old, new); > + } while ( prev != old ); > + > + vcpu_unpause(v); > +} > + > +/* > + * Local variables: > + * mode: C > + * c-file-style: "BSD" > + * c-basic-offset: 4 > + * indent-tabs-mode: nil > + * End: > + */ > diff --git a/xen/drivers/passthrough/pci.c b/xen/drivers/passthrough/pci.c > index 78c6977..964384b 100644 > --- a/xen/drivers/passthrough/pci.c > +++ b/xen/drivers/passthrough/pci.c > @@ -1346,7 +1346,7 @@ static int assign_device(struct domain *d, u16 seg, u8 bus, u8 devfn) > * enabled for this domain */ > if ( unlikely(!need_iommu(d) && > (d->arch.hvm_domain.mem_sharing_enabled || > - d->mem_event->paging.ring_page || > + d->vm_event->paging.ring_page || > p2m_get_hostp2m(d)->global_logdirty)) ) > return -EXDEV; > > diff --git a/xen/include/Makefile b/xen/include/Makefile > index 530db83..537a1f5 100644 > --- a/xen/include/Makefile > +++ b/xen/include/Makefile > @@ -90,7 +90,7 @@ ifeq ($(XEN_TARGET_ARCH),$(XEN_COMPILE_ARCH)) > > all: headers.chk > > -headers.chk: $(filter-out public/arch-% public/%ctl.h public/mem_event.h public/xsm/% public/%hvm/save.h, $(wildcard public/*.h public/*/*.h) $(public-y)) Makefile > +headers.chk: $(filter-out public/arch-% public/%ctl.h public/vm_event.h public/xsm/% public/%hvm/save.h, $(wildcard public/*.h public/*/*.h) $(public-y)) Makefile > for i in $(filter %.h,$^); do $(CC) -ansi -include stdint.h -Wall -W -Werror -S -o /dev/null -x c $$i || exit 1; echo $$i; done >$@.new > mv $@.new $@ > > diff --git a/xen/include/asm-arm/p2m.h b/xen/include/asm-arm/p2m.h > index da36504..e1a72d5 100644 > --- a/xen/include/asm-arm/p2m.h > +++ b/xen/include/asm-arm/p2m.h > @@ -45,7 +45,7 @@ struct p2m_domain { > unsigned long shattered[4]; > } stats; > > - /* If true, and an access fault comes in and there is no mem_event listener, > + /* If true, and an access fault comes in and there is no vm_event listener, > * pause domain. Otherwise, remove access restrictions. */ > bool_t access_required; > }; > @@ -71,8 +71,8 @@ typedef enum { > } p2m_type_t; > > static inline > -void p2m_mem_event_emulate_check(struct vcpu *v, > - const mem_event_response_t *rsp) > +void p2m_mem_access_emulate_check(struct vcpu *v, > + const vm_event_response_t *rsp) > { > /* Not supported on ARM. */ > }; > diff --git a/xen/include/asm-x86/domain.h b/xen/include/asm-x86/domain.h > index 6a77a93..20ede1e 100644 > --- a/xen/include/asm-x86/domain.h > +++ b/xen/include/asm-x86/domain.h > @@ -478,13 +478,13 @@ struct arch_vcpu > > /* > * Should we emulate the next matching instruction on VCPU resume > - * after a mem_event? > + * after a vm_event? > */ > struct { > uint32_t emulate_flags; > unsigned long gpa; > unsigned long eip; > - } mem_event; > + } vm_event; > > } __cacheline_aligned; > > diff --git a/xen/include/asm-x86/hvm/emulate.h b/xen/include/asm-x86/hvm/emulate.h > index 5411302..b3971c8 100644 > --- a/xen/include/asm-x86/hvm/emulate.h > +++ b/xen/include/asm-x86/hvm/emulate.h > @@ -38,7 +38,7 @@ int hvm_emulate_one( > struct hvm_emulate_ctxt *hvmemul_ctxt); > int hvm_emulate_one_no_write( > struct hvm_emulate_ctxt *hvmemul_ctxt); > -void hvm_mem_event_emulate_one(bool_t nowrite, > +void hvm_mem_access_emulate_one(bool_t nowrite, > unsigned int trapnr, > unsigned int errcode); > void hvm_emulate_prepare( > diff --git a/xen/include/asm-x86/p2m.h b/xen/include/asm-x86/p2m.h > index 5f7fe71..2ee863b 100644 > --- a/xen/include/asm-x86/p2m.h > +++ b/xen/include/asm-x86/p2m.h > @@ -238,7 +238,7 @@ struct p2m_domain { > * retyped get this access type. See definition of p2m_access_t. */ > p2m_access_t default_access; > > - /* If true, and an access fault comes in and there is no mem_event listener, > + /* If true, and an access fault comes in and there is no vm_event listener, > * pause domain. Otherwise, remove access restrictions. */ > bool_t access_required; > > @@ -572,7 +572,7 @@ void p2m_mem_paging_resume(struct domain *d); > * locks -- caller must also xfree the request. */ > bool_t p2m_mem_access_check(paddr_t gpa, unsigned long gla, > struct npfec npfec, > - mem_event_request_t **req_ptr); > + vm_event_request_t **req_ptr); > > /* Set access type for a region of pfns. > * If start_pfn == -1ul, sets the default access type */ > @@ -586,22 +586,16 @@ int p2m_get_mem_access(struct domain *d, unsigned long pfn, > > /* Check for emulation and mark vcpu for skipping one instruction > * upon rescheduling if required. */ > -void p2m_mem_event_emulate_check(struct vcpu *v, > - const mem_event_response_t *rsp); > +void p2m_mem_access_emulate_check(struct vcpu *v, > + const vm_event_response_t *rsp); > > /* Enable arch specific introspection options (such as MSR interception). */ > void p2m_setup_introspection(struct domain *d); > > -/* Sanity check for mem_event hardware support */ > -static inline bool_t p2m_mem_event_sanity_check(struct domain *d) > -{ > - return hap_enabled(d) && cpu_has_vmx; > -} > - > /* Sanity check for mem_access hardware support */ > static inline bool_t p2m_mem_access_sanity_check(struct domain *d) > { > - return is_hvm_domain(d); > + return hap_enabled(d) && cpu_has_vmx && is_hvm_domain(d); > } > > /* > diff --git a/xen/include/public/domctl.h b/xen/include/public/domctl.h > index 0e3aaf1..1d4b241 100644 > --- a/xen/include/public/domctl.h > +++ b/xen/include/public/domctl.h > @@ -753,7 +753,7 @@ struct xen_domctl_gdbsx_domstatus { > * Memory event operations > */ > > -/* XEN_DOMCTL_mem_event_op */ > +/* XEN_DOMCTL_vm_event_op */ > > /* > * Domain memory paging > @@ -762,17 +762,17 @@ struct xen_domctl_gdbsx_domstatus { > * pager<->hypervisor interface. Use XENMEM_paging_op* > * to perform per-page operations. > * > - * The XEN_DOMCTL_MEM_EVENT_OP_PAGING_ENABLE domctl returns several > + * The XEN_DOMCTL_VM_EVENT_OP_PAGING_ENABLE domctl returns several > * non-standard error codes to indicate why paging could not be enabled: > * ENODEV - host lacks HAP support (EPT/NPT) or HAP is disabled in guest > * EMLINK - guest has iommu passthrough enabled > * EXDEV - guest has PoD enabled > * EBUSY - guest has or had paging enabled, ring buffer still active > */ > -#define XEN_DOMCTL_MEM_EVENT_OP_PAGING 1 > +#define XEN_DOMCTL_VM_EVENT_OP_PAGING 1 > > -#define XEN_DOMCTL_MEM_EVENT_OP_PAGING_ENABLE 0 > -#define XEN_DOMCTL_MEM_EVENT_OP_PAGING_DISABLE 1 > +#define XEN_DOMCTL_VM_EVENT_OP_PAGING_ENABLE 0 > +#define XEN_DOMCTL_VM_EVENT_OP_PAGING_DISABLE 1 > > /* > * Monitor permissions. > @@ -783,21 +783,21 @@ struct xen_domctl_gdbsx_domstatus { > * There are HVM hypercalls to set the per-page access permissions of every > * page in a domain. When one of these permissions--independent, read, > * write, and execute--is violated, the VCPU is paused and a memory event > - * is sent with what happened. (See public/mem_event.h) . > + * is sent with what happened. (See public/vm_event.h) . > * > * The memory event handler can then resume the VCPU and redo the access > * with a XENMEM_access_op_resume hypercall. > * > - * The XEN_DOMCTL_MEM_EVENT_OP_MONITOR_ENABLE domctl returns several > + * The XEN_DOMCTL_VM_EVENT_OP_MONITOR_ENABLE domctl returns several > * non-standard error codes to indicate why access could not be enabled: > * ENODEV - host lacks HAP support (EPT/NPT) or HAP is disabled in guest > * EBUSY - guest has or had access enabled, ring buffer still active > */ > -#define XEN_DOMCTL_MEM_EVENT_OP_MONITOR 2 > +#define XEN_DOMCTL_VM_EVENT_OP_MONITOR 2 > > -#define XEN_DOMCTL_MEM_EVENT_OP_MONITOR_ENABLE 0 > -#define XEN_DOMCTL_MEM_EVENT_OP_MONITOR_DISABLE 1 > -#define XEN_DOMCTL_MEM_EVENT_OP_MONITOR_ENABLE_INTROSPECTION 2 > +#define XEN_DOMCTL_VM_EVENT_OP_MONITOR_ENABLE 0 > +#define XEN_DOMCTL_VM_EVENT_OP_MONITOR_DISABLE 1 > +#define XEN_DOMCTL_VM_EVENT_OP_MONITOR_ENABLE_INTROSPECTION 2 > > /* > * Sharing ENOMEM helper. > @@ -812,21 +812,21 @@ struct xen_domctl_gdbsx_domstatus { > * Note that shring can be turned on (as per the domctl below) > * *without* this ring being setup. > */ > -#define XEN_DOMCTL_MEM_EVENT_OP_SHARING 3 > +#define XEN_DOMCTL_VM_EVENT_OP_SHARING 3 > > -#define XEN_DOMCTL_MEM_EVENT_OP_SHARING_ENABLE 0 > -#define XEN_DOMCTL_MEM_EVENT_OP_SHARING_DISABLE 1 > +#define XEN_DOMCTL_VM_EVENT_OP_SHARING_ENABLE 0 > +#define XEN_DOMCTL_VM_EVENT_OP_SHARING_DISABLE 1 > > /* Use for teardown/setup of helper<->hypervisor interface for paging, > * access and sharing.*/ > -struct xen_domctl_mem_event_op { > - uint32_t op; /* XEN_DOMCTL_MEM_EVENT_OP_*_* */ > - uint32_t mode; /* XEN_DOMCTL_MEM_EVENT_OP_* */ > +struct xen_domctl_vm_event_op { > + uint32_t op; /* XEN_DOMCTL_VM_EVENT_OP_*_* */ > + uint32_t mode; /* XEN_DOMCTL_VM_EVENT_OP_* */ > > uint32_t port; /* OUT: event channel for ring */ > }; > -typedef struct xen_domctl_mem_event_op xen_domctl_mem_event_op_t; > -DEFINE_XEN_GUEST_HANDLE(xen_domctl_mem_event_op_t); > +typedef struct xen_domctl_vm_event_op xen_domctl_vm_event_op_t; > +DEFINE_XEN_GUEST_HANDLE(xen_domctl_vm_event_op_t); > > /* > * Memory sharing operations > @@ -1049,7 +1049,7 @@ struct xen_domctl { > #define XEN_DOMCTL_suppress_spurious_page_faults 53 > #define XEN_DOMCTL_debug_op 54 > #define XEN_DOMCTL_gethvmcontext_partial 55 > -#define XEN_DOMCTL_mem_event_op 56 > +#define XEN_DOMCTL_vm_event_op 56 > #define XEN_DOMCTL_mem_sharing_op 57 > #define XEN_DOMCTL_disable_migrate 58 > #define XEN_DOMCTL_gettscinfo 59 > @@ -1117,7 +1117,7 @@ struct xen_domctl { > struct xen_domctl_set_target set_target; > struct xen_domctl_subscribe subscribe; > struct xen_domctl_debug_op debug_op; > - struct xen_domctl_mem_event_op mem_event_op; > + struct xen_domctl_vm_event_op vm_event_op; > struct xen_domctl_mem_sharing_op mem_sharing_op; > #if defined(__i386__) || defined(__x86_64__) > struct xen_domctl_cpuid cpuid; > diff --git a/xen/include/public/mem_event.h b/xen/include/public/mem_event.h > deleted file mode 100644 > index dbcc48b..0000000 > --- a/xen/include/public/mem_event.h > +++ /dev/null > @@ -1,197 +0,0 @@ > -/****************************************************************************** > - * mem_event.h > - * > - * Memory event common structures. > - * > - * Copyright (c) 2009 by Citrix Systems, Inc. (Patrick Colp) > - * > - * Permission is hereby granted, free of charge, to any person obtaining a copy > - * of this software and associated documentation files (the "Software"), to > - * deal in the Software without restriction, including without limitation the > - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or > - * sell copies of the Software, and to permit persons to whom the Software is > - * furnished to do so, subject to the following conditions: > - * > - * The above copyright notice and this permission notice shall be included in > - * all copies or substantial portions of the Software. > - * > - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR > - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, > - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE > - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER > - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING > - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER > - * DEALINGS IN THE SOFTWARE. > - */ > - > -#ifndef _XEN_PUBLIC_MEM_EVENT_H > -#define _XEN_PUBLIC_MEM_EVENT_H > - > -#if !defined(__XEN__) && !defined(__XEN_TOOLS__) > -#error "vm event operations are intended for use only by Xen or node control tools" > -#endif > - > -#include "xen.h" > -#include "io/ring.h" > - > -#define MEM_EVENT_INTERFACE_VERSION 0x00000001 > - > -/* Memory event flags */ > -#define MEM_EVENT_FLAG_VCPU_PAUSED (1 << 0) > -#define MEM_EVENT_FLAG_DROP_PAGE (1 << 1) > -#define MEM_EVENT_FLAG_EVICT_FAIL (1 << 2) > -#define MEM_EVENT_FLAG_FOREIGN (1 << 3) > -#define MEM_EVENT_FLAG_DUMMY (1 << 4) > -/* > - * Emulate the fault-causing instruction (if set in the event response flags). > - * This will allow the guest to continue execution without lifting the page > - * access restrictions. > - */ > -#define MEM_EVENT_FLAG_EMULATE (1 << 5) > -/* > - * Same as MEM_EVENT_FLAG_EMULATE, but with write operations or operations > - * potentially having side effects (like memory mapped or port I/O) disabled. > - */ > -#define MEM_EVENT_FLAG_EMULATE_NOWRITE (1 << 6) > - > -/* Reasons for the vm event request */ > -/* Default case */ > -#define MEM_EVENT_REASON_UNKNOWN 0 > -/* Memory access violation */ > -#define MEM_EVENT_REASON_MEM_ACCESS_VIOLATION 1 > -/* Memory sharing event */ > -#define MEM_EVENT_REASON_MEM_SHARING 2 > -/* Memory paging event */ > -#define MEM_EVENT_REASON_MEM_PAGING 3 > -/* CR0 was updated */ > -#define MEM_EVENT_REASON_CR0 4 > -/* CR3 was updated */ > -#define MEM_EVENT_REASON_CR3 5 > -/* CR4 was updated */ > -#define MEM_EVENT_REASON_CR4 6 > -/* Debug operation executed (int3) */ > -#define MEM_EVENT_REASON_INT3 7 > -/* Single-step (MTF) */ > -#define MEM_EVENT_REASON_SINGLESTEP 8 > -/* An MSR was updated. Does NOT honour HVMPME_onchangeonly */ > -#define MEM_EVENT_REASON_MSR 9 > - > -/* Using a custom struct (not hvm_hw_cpu) so as to not fill > - * the mem_event ring buffer too quickly. */ > -struct mem_event_regs_x86 { > - uint64_t rax; > - uint64_t rcx; > - uint64_t rdx; > - uint64_t rbx; > - uint64_t rsp; > - uint64_t rbp; > - uint64_t rsi; > - uint64_t rdi; > - uint64_t r8; > - uint64_t r9; > - uint64_t r10; > - uint64_t r11; > - uint64_t r12; > - uint64_t r13; > - uint64_t r14; > - uint64_t r15; > - uint64_t rflags; > - uint64_t dr7; > - uint64_t rip; > - uint64_t cr0; > - uint64_t cr2; > - uint64_t cr3; > - uint64_t cr4; > - uint64_t sysenter_cs; > - uint64_t sysenter_esp; > - uint64_t sysenter_eip; > - uint64_t msr_efer; > - uint64_t msr_star; > - uint64_t msr_lstar; > - uint64_t fs_base; > - uint64_t gs_base; > - uint32_t cs_arbytes; > - uint32_t _pad; > -}; > - > -struct mem_event_regs { > - union { > - struct mem_event_regs_x86 x86; > - }; > -}; > - > -struct mem_event_mem_access_data { > - uint64_t gfn; > - uint64_t offset; > - uint64_t gla; /* if gla_valid */ > - uint16_t access_r:1; > - uint16_t access_w:1; > - uint16_t access_x:1; > - uint16_t gla_valid:1; > - uint16_t fault_with_gla:1; > - uint16_t fault_in_gpt:1; > - uint16_t available:10; > -}; > - > -struct mem_event_cr_data { > - uint64_t new_value; > - uint64_t old_value; > -}; > - > -struct mem_event_int3_data { > - uint64_t gfn; > - uint64_t gla; > -}; > - > -struct mem_event_singlestep_data { > - uint64_t gfn; > - uint64_t gla; > -}; > - > -struct mem_event_msr_data { > - uint64_t msr; > - uint64_t old_value; > - uint64_t new_value; > -}; > - > -struct mem_event_paging_data { > - uint64_t gfn; > - uint32_t p2mt; > -}; > - > -struct mem_event_sharing_data { > - uint64_t gfn; > - uint32_t p2mt; > -}; > - > -typedef struct mem_event_st { > - uint32_t flags; > - uint32_t vcpu_id; > - uint32_t reason; > - > - union { > - struct mem_event_paging_data mem_paging_event; > - struct mem_event_sharing_data mem_sharing_event; > - struct mem_event_mem_access_data mem_access_event; > - struct mem_event_cr_data cr_event; > - struct mem_event_int3_data int3_event; > - struct mem_event_singlestep_data singlestep_event; > - struct mem_event_msr_data msr_event; > - }; > - > - struct mem_event_regs regs; > -} mem_event_request_t, mem_event_response_t; > - > -DEFINE_RING_TYPES(mem_event, mem_event_request_t, mem_event_response_t); > - > -#endif > - > -/* > - * Local variables: > - * mode: C > - * c-file-style: "BSD" > - * c-basic-offset: 4 > - * tab-width: 4 > - * indent-tabs-mode: nil > - * End: > - */ > diff --git a/xen/include/public/vm_event.h b/xen/include/public/vm_event.h > new file mode 100644 > index 0000000..287c3fc > --- /dev/null > +++ b/xen/include/public/vm_event.h > @@ -0,0 +1,197 @@ > +/****************************************************************************** > + * vm_event.h > + * > + * VM event common structures. > + * > + * Copyright (c) 2009 by Citrix Systems, Inc. (Patrick Colp) > + * > + * Permission is hereby granted, free of charge, to any person obtaining a copy > + * of this software and associated documentation files (the "Software"), to > + * deal in the Software without restriction, including without limitation the > + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or > + * sell copies of the Software, and to permit persons to whom the Software is > + * furnished to do so, subject to the following conditions: > + * > + * The above copyright notice and this permission notice shall be included in > + * all copies or substantial portions of the Software. > + * > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR > + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, > + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE > + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER > + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING > + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER > + * DEALINGS IN THE SOFTWARE. > + */ > + > +#ifndef _XEN_PUBLIC_VM_EVENT_H > +#define _XEN_PUBLIC_VM_EVENT_H > + > +#if !defined(__XEN__) && !defined(__XEN_TOOLS__) > +#error "vm event operations are intended for use only by Xen or node control tools" > +#endif > + > +#include "xen.h" > +#include "io/ring.h" > + > +#define MEM_EVENT_INTERFACE_VERSION 0x00000001 > + > +/* Memory event flags */ > +#define VM_EVENT_FLAG_VCPU_PAUSED (1 << 0) > +#define VM_EVENT_FLAG_DROP_PAGE (1 << 1) > +#define VM_EVENT_FLAG_EVICT_FAIL (1 << 2) > +#define VM_EVENT_FLAG_FOREIGN (1 << 3) > +#define VM_EVENT_FLAG_DUMMY (1 << 4) > +/* > + * Emulate the fault-causing instruction (if set in the event response flags). > + * This will allow the guest to continue execution without lifting the page > + * access restrictions. > + */ > +#define VM_EVENT_FLAG_EMULATE (1 << 5) > +/* > + * Same as VM_EVENT_FLAG_EMULATE, but with write operations or operations > + * potentially having side effects (like memory mapped or port I/O) disabled. > + */ > +#define VM_EVENT_FLAG_EMULATE_NOWRITE (1 << 6) > + > +/* Reasons for the vm event request */ > +/* Default case */ > +#define VM_EVENT_REASON_UNKNOWN 0 > +/* Memory access violation */ > +#define VM_EVENT_REASON_MEM_ACCESS_VIOLATION 1 > +/* Memory sharing event */ > +#define VM_EVENT_REASON_MEM_SHARING 2 > +/* Memory paging event */ > +#define VM_EVENT_REASON_MEM_PAGING 3 > +/* CR0 was updated */ > +#define VM_EVENT_REASON_CR0 4 > +/* CR3 was updated */ > +#define VM_EVENT_REASON_CR3 5 > +/* CR4 was updated */ > +#define VM_EVENT_REASON_CR4 6 > +/* Debug operation executed (int3) */ > +#define VM_EVENT_REASON_INT3 7 > +/* Single-step (MTF) */ > +#define VM_EVENT_REASON_SINGLESTEP 8 > +/* An MSR was updated. Does NOT honour HVMPME_onchangeonly */ > +#define VM_EVENT_REASON_MSR 9 > + > +/* Using a custom struct (not hvm_hw_cpu) so as to not fill > + * the vm_event ring buffer too quickly. */ > +struct vm_event_regs_x86 { > + uint64_t rax; > + uint64_t rcx; > + uint64_t rdx; > + uint64_t rbx; > + uint64_t rsp; > + uint64_t rbp; > + uint64_t rsi; > + uint64_t rdi; > + uint64_t r8; > + uint64_t r9; > + uint64_t r10; > + uint64_t r11; > + uint64_t r12; > + uint64_t r13; > + uint64_t r14; > + uint64_t r15; > + uint64_t rflags; > + uint64_t dr7; > + uint64_t rip; > + uint64_t cr0; > + uint64_t cr2; > + uint64_t cr3; > + uint64_t cr4; > + uint64_t sysenter_cs; > + uint64_t sysenter_esp; > + uint64_t sysenter_eip; > + uint64_t msr_efer; > + uint64_t msr_star; > + uint64_t msr_lstar; > + uint64_t fs_base; > + uint64_t gs_base; > + uint32_t cs_arbytes; > + uint32_t _pad; > +}; > + > +struct vm_event_regs { > + union { > + struct vm_event_regs_x86 x86; > + }; > +}; > + > +struct vm_event_mem_access_data { > + uint64_t gfn; > + uint64_t offset; > + uint64_t gla; /* if gla_valid */ > + uint16_t access_r:1; > + uint16_t access_w:1; > + uint16_t access_x:1; > + uint16_t gla_valid:1; > + uint16_t fault_with_gla:1; > + uint16_t fault_in_gpt:1; > + uint16_t available:10; > +}; > + > +struct vm_event_cr_data { > + uint64_t new_value; > + uint64_t old_value; > +}; > + > +struct vm_event_int3_data { > + uint64_t gfn; > + uint64_t gla; > +}; > + > +struct vm_event_singlestep_data { > + uint64_t gfn; > + uint64_t gla; > +}; > + > +struct vm_event_msr_data { > + uint64_t msr; > + uint64_t old_value; > + uint64_t new_value; > +}; > + > +struct vm_event_paging_data { > + uint64_t gfn; > + uint32_t p2mt; > +}; > + > +struct vm_event_sharing_data { > + uint64_t gfn; > + uint32_t p2mt; > +}; > + > +typedef struct vm_event_st { > + uint32_t flags; > + uint32_t vcpu_id; > + uint32_t reason; > + > + union { > + struct vm_event_paging_data mem_paging_event; > + struct vm_event_sharing_data mem_sharing_event; > + struct vm_event_mem_access_data mem_access_event; > + struct vm_event_cr_data cr_event; > + struct vm_event_int3_data int3_event; > + struct vm_event_singlestep_data singlestep_event; > + struct vm_event_msr_data msr_event; > + }; > + > + struct vm_event_regs regs; > +} vm_event_request_t, vm_event_response_t; > + > +DEFINE_RING_TYPES(vm_event, vm_event_request_t, vm_event_response_t); > + > +#endif > + > +/* > + * Local variables: > + * mode: C > + * c-file-style: "BSD" > + * c-basic-offset: 4 > + * tab-width: 4 > + * indent-tabs-mode: nil > + * End: > + */ > diff --git a/xen/include/xen/mem_access.h b/xen/include/xen/mem_access.h > index 6ceb2a4..1d01221 100644 > --- a/xen/include/xen/mem_access.h > +++ b/xen/include/xen/mem_access.h > @@ -29,7 +29,7 @@ > > int mem_access_memop(unsigned long cmd, > XEN_GUEST_HANDLE_PARAM(xen_mem_access_op_t) arg); > -int mem_access_send_req(struct domain *d, mem_event_request_t *req); > +int mem_access_send_req(struct domain *d, vm_event_request_t *req); > > /* Resumes the running of the VCPU, restarting the last instruction */ > void mem_access_resume(struct domain *d); > @@ -44,7 +44,7 @@ int mem_access_memop(unsigned long cmd, > } > > static inline > -int mem_access_send_req(struct domain *d, mem_event_request_t *req) > +int mem_access_send_req(struct domain *d, vm_event_request_t *req) > { > return -ENOSYS; > } > diff --git a/xen/include/xen/mem_event.h b/xen/include/xen/mem_event.h > deleted file mode 100644 > index 4f3ad8e..0000000 > --- a/xen/include/xen/mem_event.h > +++ /dev/null > @@ -1,143 +0,0 @@ > -/****************************************************************************** > - * mem_event.h > - * > - * Common interface for memory event support. > - * > - * Copyright (c) 2009 Citrix Systems, Inc. (Patrick Colp) > - * > - * This program is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published by > - * the Free Software Foundation; either version 2 of the License, or > - * (at your option) any later version. > - * > - * This program is distributed in the hope that it will be useful, > - * but WITHOUT ANY WARRANTY; without even the implied warranty of > - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > - * GNU General Public License for more details. > - * > - * You should have received a copy of the GNU General Public License > - * along with this program; if not, write to the Free Software > - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > - */ > - > - > -#ifndef __MEM_EVENT_H__ > -#define __MEM_EVENT_H__ > - > -#include > - > -#ifdef HAS_MEM_ACCESS > - > -/* Clean up on domain destruction */ > -void mem_event_cleanup(struct domain *d); > - > -/* Returns whether a ring has been set up */ > -bool_t mem_event_check_ring(struct mem_event_domain *med); > - > -/* Returns 0 on success, -ENOSYS if there is no ring, -EBUSY if there is no > - * available space and the caller is a foreign domain. If the guest itself > - * is the caller, -EBUSY is avoided by sleeping on a wait queue to ensure > - * that the ring does not lose future events. > - * > - * However, the allow_sleep flag can be set to false in cases in which it is ok > - * to lose future events, and thus -EBUSY can be returned to guest vcpus > - * (handle with care!). > - * > - * In general, you must follow a claim_slot() call with either put_request() or > - * cancel_slot(), both of which are guaranteed to > - * succeed. > - */ > -int __mem_event_claim_slot(struct domain *d, struct mem_event_domain *med, > - bool_t allow_sleep); > -static inline int mem_event_claim_slot(struct domain *d, > - struct mem_event_domain *med) > -{ > - return __mem_event_claim_slot(d, med, 1); > -} > - > -static inline int mem_event_claim_slot_nosleep(struct domain *d, > - struct mem_event_domain *med) > -{ > - return __mem_event_claim_slot(d, med, 0); > -} > - > -void mem_event_cancel_slot(struct domain *d, struct mem_event_domain *med); > - > -void mem_event_put_request(struct domain *d, struct mem_event_domain *med, > - mem_event_request_t *req); > - > -int mem_event_get_response(struct domain *d, struct mem_event_domain *med, > - mem_event_response_t *rsp); > - > -int do_mem_event_op(int op, uint32_t domain, void *arg); > -int mem_event_domctl(struct domain *d, xen_domctl_mem_event_op_t *mec, > - XEN_GUEST_HANDLE_PARAM(void) u_domctl); > - > -void mem_event_vcpu_pause(struct vcpu *v); > -void mem_event_vcpu_unpause(struct vcpu *v); > - > -#else > - > -static inline void mem_event_cleanup(struct domain *d) {} > - > -static inline bool_t mem_event_check_ring(struct mem_event_domain *med) > -{ > - return 0; > -} > - > -static inline int mem_event_claim_slot(struct domain *d, > - struct mem_event_domain *med) > -{ > - return -ENOSYS; > -} > - > -static inline int mem_event_claim_slot_nosleep(struct domain *d, > - struct mem_event_domain *med) > -{ > - return -ENOSYS; > -} > - > -static inline > -void mem_event_cancel_slot(struct domain *d, struct mem_event_domain *med) > -{} > - > -static inline > -void mem_event_put_request(struct domain *d, struct mem_event_domain *med, > - mem_event_request_t *req) > -{} > - > -static inline > -int mem_event_get_response(struct domain *d, struct mem_event_domain *med, > - mem_event_response_t *rsp) > -{ > - return -ENOSYS; > -} > - > -static inline int do_mem_event_op(int op, uint32_t domain, void *arg) > -{ > - return -ENOSYS; > -} > - > -static inline > -int mem_event_domctl(struct domain *d, xen_domctl_mem_event_op_t *mec, > - XEN_GUEST_HANDLE_PARAM(void) u_domctl) > -{ > - return -ENOSYS; > -} > - > -static inline void mem_event_vcpu_pause(struct vcpu *v) {} > -static inline void mem_event_vcpu_unpause(struct vcpu *v) {} > - > -#endif /* HAS_MEM_ACCESS */ > - > -#endif /* __MEM_EVENT_H__ */ > - > - > -/* > - * Local variables: > - * mode: C > - * c-file-style: "BSD" > - * c-basic-offset: 4 > - * indent-tabs-mode: nil > - * End: > - */ > diff --git a/xen/include/xen/p2m-common.h b/xen/include/xen/p2m-common.h > index 29f3628..5da8a2d 100644 > --- a/xen/include/xen/p2m-common.h > +++ b/xen/include/xen/p2m-common.h > @@ -1,12 +1,12 @@ > #ifndef _XEN_P2M_COMMON_H > #define _XEN_P2M_COMMON_H > > -#include > +#include > > /* > * Additional access types, which are used to further restrict > * the permissions given my the p2m_type_t memory type. Violations > - * caused by p2m_access_t restrictions are sent to the mem_event > + * caused by p2m_access_t restrictions are sent to the vm_event > * interface. > * > * The access permissions are soft state: when any ambiguous change of page > diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h > index 2fc36ea..14fae4a 100644 > --- a/xen/include/xen/sched.h > +++ b/xen/include/xen/sched.h > @@ -23,7 +23,7 @@ > #include > #include > #include > -#include > +#include > #include > > #ifdef CONFIG_COMPAT > @@ -214,8 +214,8 @@ struct vcpu > unsigned long pause_flags; > atomic_t pause_count; > > - /* VCPU paused for mem_event replies. */ > - atomic_t mem_event_pause_count; > + /* VCPU paused for vm_event replies. */ > + atomic_t vm_event_pause_count; > /* VCPU paused by system controller. */ > int controller_pause_count; > > @@ -258,7 +258,7 @@ struct vcpu > #define domain_is_locked(d) spin_is_locked(&(d)->domain_lock) > > /* Memory event */ > -struct mem_event_domain > +struct vm_event_domain > { > /* ring lock */ > spinlock_t ring_lock; > @@ -269,10 +269,10 @@ struct mem_event_domain > void *ring_page; > struct page_info *ring_pg_struct; > /* front-end ring */ > - mem_event_front_ring_t front_ring; > + vm_event_front_ring_t front_ring; > /* event channel port (vcpu0 only) */ > int xen_port; > - /* mem_event bit for vcpu->pause_flags */ > + /* vm_event bit for vcpu->pause_flags */ > int pause_flag; > /* list of vcpus waiting for room in the ring */ > struct waitqueue_head wq; > @@ -282,14 +282,14 @@ struct mem_event_domain > unsigned int last_vcpu_wake_up; > }; > > -struct mem_event_per_domain > +struct vm_event_per_domain > { > /* Memory sharing support */ > - struct mem_event_domain share; > + struct vm_event_domain share; > /* Memory paging support */ > - struct mem_event_domain paging; > - /* VM event monitor support */ > - struct mem_event_domain monitor; > + struct vm_event_domain paging; > + /* Memory access support */ > + struct vm_event_domain monitor; > }; > > struct evtchn_port_ops; > @@ -442,8 +442,8 @@ struct domain > /* Non-migratable and non-restoreable? */ > bool_t disable_migrate; > > - /* Various mem_events */ > - struct mem_event_per_domain *mem_event; > + /* Various vm_events */ > + struct vm_event_per_domain *vm_event; > > /* > * Can be specified by the user. If that is not the case, it is > diff --git a/xen/include/xen/vm_event.h b/xen/include/xen/vm_event.h > new file mode 100644 > index 0000000..988ea42 > --- /dev/null > +++ b/xen/include/xen/vm_event.h > @@ -0,0 +1,143 @@ > +/****************************************************************************** > + * vm_event.h > + * > + * Common interface for memory event support. > + * > + * Copyright (c) 2009 Citrix Systems, Inc. (Patrick Colp) > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > + */ > + > + > +#ifndef __VM_EVENT_H__ > +#define __VM_EVENT_H__ > + > +#include > + > +#ifdef HAS_MEM_ACCESS > + > +/* Clean up on domain destruction */ > +void vm_event_cleanup(struct domain *d); > + > +/* Returns whether a ring has been set up */ > +bool_t vm_event_check_ring(struct vm_event_domain *med); > + > +/* Returns 0 on success, -ENOSYS if there is no ring, -EBUSY if there is no > + * available space and the caller is a foreign domain. If the guest itself > + * is the caller, -EBUSY is avoided by sleeping on a wait queue to ensure > + * that the ring does not lose future events. > + * > + * However, the allow_sleep flag can be set to false in cases in which it is ok > + * to lose future events, and thus -EBUSY can be returned to guest vcpus > + * (handle with care!). > + * > + * In general, you must follow a claim_slot() call with either put_request() or > + * cancel_slot(), both of which are guaranteed to > + * succeed. > + */ > +int __vm_event_claim_slot(struct domain *d, struct vm_event_domain *med, > + bool_t allow_sleep); > +static inline int vm_event_claim_slot(struct domain *d, > + struct vm_event_domain *med) > +{ > + return __vm_event_claim_slot(d, med, 1); > +} > + > +static inline int vm_event_claim_slot_nosleep(struct domain *d, > + struct vm_event_domain *med) > +{ > + return __vm_event_claim_slot(d, med, 0); > +} > + > +void vm_event_cancel_slot(struct domain *d, struct vm_event_domain *med); > + > +void vm_event_put_request(struct domain *d, struct vm_event_domain *med, > + vm_event_request_t *req); > + > +int vm_event_get_response(struct domain *d, struct vm_event_domain *med, > + vm_event_response_t *rsp); > + > +int do_vm_event_op(int op, uint32_t domain, void *arg); > +int vm_event_domctl(struct domain *d, xen_domctl_vm_event_op_t *mec, > + XEN_GUEST_HANDLE_PARAM(void) u_domctl); > + > +void vm_event_vcpu_pause(struct vcpu *v); > +void vm_event_vcpu_unpause(struct vcpu *v); > + > +#else > + > +static inline void vm_event_cleanup(struct domain *d) {} > + > +static inline bool_t vm_event_check_ring(struct vm_event_domain *med) > +{ > + return 0; > +} > + > +static inline int vm_event_claim_slot(struct domain *d, > + struct vm_event_domain *med) > +{ > + return -ENOSYS; > +} > + > +static inline int vm_event_claim_slot_nosleep(struct domain *d, > + struct vm_event_domain *med) > +{ > + return -ENOSYS; > +} > + > +static inline > +void vm_event_cancel_slot(struct domain *d, struct vm_event_domain *med) > +{} > + > +static inline > +void vm_event_put_request(struct domain *d, struct vm_event_domain *med, > + vm_event_request_t *req) > +{} > + > +static inline > +int vm_event_get_response(struct domain *d, struct vm_event_domain *med, > + vm_event_response_t *rsp) > +{ > + return -ENOSYS; > +} > + > +static inline int do_vm_event_op(int op, uint32_t domain, void *arg) > +{ > + return -ENOSYS; > +} > + > +static inline > +int vm_event_domctl(struct domain *d, xen_domctl_vm_event_op_t *mec, > + XEN_GUEST_HANDLE_PARAM(void) u_domctl) > +{ > + return -ENOSYS; > +} > + > +static inline void vm_event_vcpu_pause(struct vcpu *v) {} > +static inline void vm_event_vcpu_unpause(struct vcpu *v) {} > + > +#endif /* HAS_MEM_ACCESS */ > + > +#endif /* __VM_EVENT_H__ */ > + > + > +/* > + * Local variables: > + * mode: C > + * c-file-style: "BSD" > + * c-basic-offset: 4 > + * indent-tabs-mode: nil > + * End: > + */ > diff --git a/xen/include/xsm/dummy.h b/xen/include/xsm/dummy.h > index f20e89c..4227093 100644 > --- a/xen/include/xsm/dummy.h > +++ b/xen/include/xsm/dummy.h > @@ -514,13 +514,13 @@ static XSM_INLINE int xsm_hvm_param_nested(XSM_DEFAULT_ARG struct domain *d) > } > > #ifdef HAS_MEM_ACCESS > -static XSM_INLINE int xsm_mem_event_control(XSM_DEFAULT_ARG struct domain *d, int mode, int op) > +static XSM_INLINE int xsm_vm_event_control(XSM_DEFAULT_ARG struct domain *d, int mode, int op) > { > XSM_ASSERT_ACTION(XSM_PRIV); > return xsm_default_action(action, current->domain, d); > } > > -static XSM_INLINE int xsm_mem_event_op(XSM_DEFAULT_ARG struct domain *d, int op) > +static XSM_INLINE int xsm_vm_event_op(XSM_DEFAULT_ARG struct domain *d, int op) > { > XSM_ASSERT_ACTION(XSM_DM_PRIV); > return xsm_default_action(action, current->domain, d); > diff --git a/xen/include/xsm/xsm.h b/xen/include/xsm/xsm.h > index 4ce089f..cff9d35 100644 > --- a/xen/include/xsm/xsm.h > +++ b/xen/include/xsm/xsm.h > @@ -142,8 +142,8 @@ struct xsm_operations { > int (*get_vnumainfo) (struct domain *d); > > #ifdef HAS_MEM_ACCESS > - int (*mem_event_control) (struct domain *d, int mode, int op); > - int (*mem_event_op) (struct domain *d, int op); > + int (*vm_event_control) (struct domain *d, int mode, int op); > + int (*vm_event_op) (struct domain *d, int op); > #endif > > #ifdef CONFIG_X86 > @@ -544,14 +544,14 @@ static inline int xsm_get_vnumainfo (xsm_default_t def, struct domain *d) > } > > #ifdef HAS_MEM_ACCESS > -static inline int xsm_mem_event_control (xsm_default_t def, struct domain *d, int mode, int op) > +static inline int xsm_vm_event_control (xsm_default_t def, struct domain *d, int mode, int op) > { > - return xsm_ops->mem_event_control(d, mode, op); > + return xsm_ops->vm_event_control(d, mode, op); > } > > -static inline int xsm_mem_event_op (xsm_default_t def, struct domain *d, int op) > +static inline int xsm_vm_event_op (xsm_default_t def, struct domain *d, int op) > { > - return xsm_ops->mem_event_op(d, op); > + return xsm_ops->vm_event_op(d, op); > } > #endif > > diff --git a/xen/xsm/dummy.c b/xen/xsm/dummy.c > index 8eb3050..25fca68 100644 > --- a/xen/xsm/dummy.c > +++ b/xen/xsm/dummy.c > @@ -119,8 +119,8 @@ void xsm_fixup_ops (struct xsm_operations *ops) > set_to_dummy_if_null(ops, map_gmfn_foreign); > > #ifdef HAS_MEM_ACCESS > - set_to_dummy_if_null(ops, mem_event_control); > - set_to_dummy_if_null(ops, mem_event_op); > + set_to_dummy_if_null(ops, vm_event_control); > + set_to_dummy_if_null(ops, vm_event_op); > #endif > > #ifdef CONFIG_X86 > diff --git a/xen/xsm/flask/hooks.c b/xen/xsm/flask/hooks.c > index d48463f..c419543 100644 > --- a/xen/xsm/flask/hooks.c > +++ b/xen/xsm/flask/hooks.c > @@ -578,7 +578,7 @@ static int flask_domctl(struct domain *d, int cmd) > case XEN_DOMCTL_memory_mapping: > case XEN_DOMCTL_set_target: > #ifdef HAS_MEM_ACCESS > - case XEN_DOMCTL_mem_event_op: > + case XEN_DOMCTL_vm_event_op: > #endif > #ifdef CONFIG_X86 > /* These have individual XSM hooks (arch/x86/domctl.c) */ > @@ -689,7 +689,7 @@ static int flask_domctl(struct domain *d, int cmd) > return current_has_perm(d, SECCLASS_DOMAIN, DOMAIN__TRIGGER); > > case XEN_DOMCTL_set_access_required: > - return current_has_perm(d, SECCLASS_HVM, HVM__MEM_EVENT); > + return current_has_perm(d, SECCLASS_HVM, HVM__VM_EVENT); > > case XEN_DOMCTL_debug_op: > case XEN_DOMCTL_gdbsx_guestmemio: > @@ -1203,14 +1203,14 @@ static int flask_deassign_device(struct domain *d, uint32_t machine_bdf) > #endif /* HAS_PASSTHROUGH && HAS_PCI */ > > #ifdef HAS_MEM_ACCESS > -static int flask_mem_event_control(struct domain *d, int mode, int op) > +static int flask_vm_event_control(struct domain *d, int mode, int op) > { > - return current_has_perm(d, SECCLASS_HVM, HVM__MEM_EVENT); > + return current_has_perm(d, SECCLASS_HVM, HVM__VM_EVENT); > } > > -static int flask_mem_event_op(struct domain *d, int op) > +static int flask_vm_event_op(struct domain *d, int op) > { > - return current_has_perm(d, SECCLASS_HVM, HVM__MEM_EVENT); > + return current_has_perm(d, SECCLASS_HVM, HVM__VM_EVENT); > } > #endif /* HAS_MEM_ACCESS */ > > @@ -1597,8 +1597,8 @@ static struct xsm_operations flask_ops = { > #endif > > #ifdef HAS_MEM_ACCESS > - .mem_event_control = flask_mem_event_control, > - .mem_event_op = flask_mem_event_op, > + .vm_event_control = flask_vm_event_control, > + .vm_event_op = flask_vm_event_op, > #endif > > #ifdef CONFIG_X86 > diff --git a/xen/xsm/flask/policy/access_vectors b/xen/xsm/flask/policy/access_vectors > index 1da9f63..9da3275 100644 > --- a/xen/xsm/flask/policy/access_vectors > +++ b/xen/xsm/flask/policy/access_vectors > @@ -249,7 +249,7 @@ class hvm > # HVMOP_inject_trap > hvmctl > # XEN_DOMCTL_set_access_required > - mem_event > + vm_event > # XEN_DOMCTL_mem_sharing_op and XENMEM_sharing_op_{share,add_physmap} with: > # source = the domain making the hypercall > # target = domain whose memory is being shared > -- > 2.1.4 >