|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [PATCH v2 2/2] p2m: split mem_access into separate files
This patch relocates mem_access components that are currently mixed with p2m
code into separate files. This better aligns the code with similar subsystems,
such as mem_sharing and mem_paging, which are already in separate files. There
are no code-changes introduced, the patch is mechanical code movement.
On ARM we also relocate the static inline gfn_next_boundary function to p2m.h
as it is a function the mem_access code needs access to.
Signed-off-by: Tamas K Lengyel <tamas.lengyel@xxxxxxxxxxxx>
Acked-by: Razvan Cojocaru <rcojocaru@xxxxxxxxxxxxxxx>
---
Cc: Stefano Stabellini <sstabellini@xxxxxxxxxx>
Cc: Julien Grall <julien.grall@xxxxxxx>
Cc: Jan Beulich <jbeulich@xxxxxxxx>
Cc: Andrew Cooper <andrew.cooper3@xxxxxxxxxx>
Cc: George Dunlap <george.dunlap@xxxxxxxxxxxxx>
v2: Don't move ARM radix tree functions
Include asm/mem_accesss.h in xen/mem_access.h
---
MAINTAINERS | 2 +
xen/arch/arm/Makefile | 1 +
xen/arch/arm/mem_access.c | 431 ++++++++++++++++++++++++++++++++++++
xen/arch/arm/p2m.c | 414 +----------------------------------
xen/arch/arm/traps.c | 1 +
xen/arch/x86/mm/Makefile | 1 +
xen/arch/x86/mm/mem_access.c | 462 +++++++++++++++++++++++++++++++++++++++
xen/arch/x86/mm/p2m.c | 421 -----------------------------------
xen/arch/x86/vm_event.c | 3 +-
xen/common/mem_access.c | 2 +-
xen/include/asm-arm/mem_access.h | 53 +++++
xen/include/asm-arm/p2m.h | 31 ++-
xen/include/asm-x86/mem_access.h | 61 ++++++
xen/include/asm-x86/p2m.h | 24 +-
xen/include/xen/mem_access.h | 67 +++++-
xen/include/xen/p2m-common.h | 52 -----
16 files changed, 1089 insertions(+), 937 deletions(-)
create mode 100644 xen/arch/arm/mem_access.c
create mode 100644 xen/arch/x86/mm/mem_access.c
create mode 100644 xen/include/asm-arm/mem_access.h
create mode 100644 xen/include/asm-x86/mem_access.h
diff --git a/MAINTAINERS b/MAINTAINERS
index f0d0202..fb26be3 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -402,6 +402,8 @@ S: Supported
F: tools/tests/xen-access
F: xen/arch/*/monitor.c
F: xen/arch/*/vm_event.c
+F: xen/arch/arm/mem_access.c
+F: xen/arch/x86/mm/mem_access.c
F: xen/arch/x86/hvm/monitor.c
F: xen/common/mem_access.c
F: xen/common/monitor.c
diff --git a/xen/arch/arm/Makefile b/xen/arch/arm/Makefile
index da39d39..b095e8a 100644
--- a/xen/arch/arm/Makefile
+++ b/xen/arch/arm/Makefile
@@ -24,6 +24,7 @@ obj-y += io.o
obj-y += irq.o
obj-y += kernel.o
obj-$(CONFIG_LIVEPATCH) += livepatch.o
+obj-y += mem_access.o
obj-y += mm.o
obj-y += monitor.o
obj-y += p2m.o
diff --git a/xen/arch/arm/mem_access.c b/xen/arch/arm/mem_access.c
new file mode 100644
index 0000000..a6e5bcd
--- /dev/null
+++ b/xen/arch/arm/mem_access.c
@@ -0,0 +1,431 @@
+/*
+ * arch/arm/mem_access.c
+ *
+ * Architecture-specific mem_access handling routines
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <xen/config.h>
+#include <xen/mem_access.h>
+#include <xen/monitor.h>
+#include <xen/sched.h>
+#include <xen/vm_event.h>
+#include <public/vm_event.h>
+#include <asm/event.h>
+
+static int __p2m_get_mem_access(struct domain *d, gfn_t gfn,
+ xenmem_access_t *access)
+{
+ struct p2m_domain *p2m = p2m_get_hostp2m(d);
+ void *i;
+ unsigned int index;
+
+ static const xenmem_access_t memaccess[] = {
+#define ACCESS(ac) [p2m_access_##ac] = XENMEM_access_##ac
+ ACCESS(n),
+ ACCESS(r),
+ ACCESS(w),
+ ACCESS(rw),
+ ACCESS(x),
+ ACCESS(rx),
+ ACCESS(wx),
+ ACCESS(rwx),
+ ACCESS(rx2rw),
+ ACCESS(n2rwx),
+#undef ACCESS
+ };
+
+ ASSERT(p2m_is_locked(p2m));
+
+ /* If no setting was ever set, just return rwx. */
+ if ( !p2m->mem_access_enabled )
+ {
+ *access = XENMEM_access_rwx;
+ return 0;
+ }
+
+ /* If request to get default access. */
+ if ( gfn_eq(gfn, INVALID_GFN) )
+ {
+ *access = memaccess[p2m->default_access];
+ return 0;
+ }
+
+ i = radix_tree_lookup(&p2m->mem_access_settings, gfn_x(gfn));
+
+ if ( !i )
+ {
+ /*
+ * No setting was found in the Radix tree. Check if the
+ * entry exists in the page-tables.
+ */
+ mfn_t mfn = p2m_get_entry(p2m, gfn, NULL, NULL, NULL);
+
+ if ( mfn_eq(mfn, INVALID_MFN) )
+ return -ESRCH;
+
+ /* If entry exists then its rwx. */
+ *access = XENMEM_access_rwx;
+ }
+ else
+ {
+ /* Setting was found in the Radix tree. */
+ index = radix_tree_ptr_to_int(i);
+ if ( index >= ARRAY_SIZE(memaccess) )
+ return -ERANGE;
+
+ *access = memaccess[index];
+ }
+
+ return 0;
+}
+
+/*
+ * If mem_access is in use it might have been the reason why get_page_from_gva
+ * failed to fetch the page, as it uses the MMU for the permission checking.
+ * Only in these cases we do a software-based type check and fetch the page if
+ * we indeed found a conflicting mem_access setting.
+ */
+struct page_info*
+p2m_mem_access_check_and_get_page(vaddr_t gva, unsigned long flag,
+ const struct vcpu *v)
+{
+ long rc;
+ paddr_t ipa;
+ gfn_t gfn;
+ mfn_t mfn;
+ xenmem_access_t xma;
+ p2m_type_t t;
+ struct page_info *page = NULL;
+ struct p2m_domain *p2m = &v->domain->arch.p2m;
+
+ rc = gva_to_ipa(gva, &ipa, flag);
+ if ( rc < 0 )
+ goto err;
+
+ gfn = _gfn(paddr_to_pfn(ipa));
+
+ /*
+ * We do this first as this is faster in the default case when no
+ * permission is set on the page.
+ */
+ rc = __p2m_get_mem_access(v->domain, gfn, &xma);
+ if ( rc < 0 )
+ goto err;
+
+ /* Let's check if mem_access limited the access. */
+ switch ( xma )
+ {
+ default:
+ case XENMEM_access_rwx:
+ case XENMEM_access_rw:
+ /*
+ * If mem_access contains no rw perm restrictions at all then the
original
+ * fault was correct.
+ */
+ goto err;
+ case XENMEM_access_n2rwx:
+ case XENMEM_access_n:
+ case XENMEM_access_x:
+ /*
+ * If no r/w is permitted by mem_access, this was a fault caused by
mem_access.
+ */
+ break;
+ case XENMEM_access_wx:
+ case XENMEM_access_w:
+ /*
+ * If this was a read then it was because of mem_access, but if it was
+ * a write then the original get_page_from_gva fault was correct.
+ */
+ if ( flag == GV2M_READ )
+ break;
+ else
+ goto err;
+ case XENMEM_access_rx2rw:
+ case XENMEM_access_rx:
+ case XENMEM_access_r:
+ /*
+ * If this was a write then it was because of mem_access, but if it was
+ * a read then the original get_page_from_gva fault was correct.
+ */
+ if ( flag == GV2M_WRITE )
+ break;
+ else
+ goto err;
+ }
+
+ /*
+ * We had a mem_access permission limiting the access, but the page type
+ * could also be limiting, so we need to check that as well.
+ */
+ mfn = p2m_get_entry(p2m, gfn, &t, NULL, NULL);
+ if ( mfn_eq(mfn, INVALID_MFN) )
+ goto err;
+
+ if ( !mfn_valid(mfn_x(mfn)) )
+ goto err;
+
+ /*
+ * Base type doesn't allow r/w
+ */
+ if ( t != p2m_ram_rw )
+ goto err;
+
+ page = mfn_to_page(mfn_x(mfn));
+
+ if ( unlikely(!get_page(page, v->domain)) )
+ page = NULL;
+
+err:
+ return page;
+}
+
+bool_t p2m_mem_access_check(paddr_t gpa, vaddr_t gla, const struct npfec npfec)
+{
+ int rc;
+ bool_t violation;
+ xenmem_access_t xma;
+ vm_event_request_t *req;
+ struct vcpu *v = current;
+ struct p2m_domain *p2m = p2m_get_hostp2m(v->domain);
+
+ /* Mem_access is not in use. */
+ if ( !p2m->mem_access_enabled )
+ return true;
+
+ rc = p2m_get_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), &xma);
+ if ( rc )
+ return true;
+
+ /* Now check for mem_access violation. */
+ switch ( xma )
+ {
+ case XENMEM_access_rwx:
+ violation = false;
+ break;
+ case XENMEM_access_rw:
+ violation = npfec.insn_fetch;
+ break;
+ case XENMEM_access_wx:
+ violation = npfec.read_access;
+ break;
+ case XENMEM_access_rx:
+ case XENMEM_access_rx2rw:
+ violation = npfec.write_access;
+ break;
+ case XENMEM_access_x:
+ violation = npfec.read_access || npfec.write_access;
+ break;
+ case XENMEM_access_w:
+ violation = npfec.read_access || npfec.insn_fetch;
+ break;
+ case XENMEM_access_r:
+ violation = npfec.write_access || npfec.insn_fetch;
+ break;
+ default:
+ case XENMEM_access_n:
+ case XENMEM_access_n2rwx:
+ violation = true;
+ break;
+ }
+
+ if ( !violation )
+ return true;
+
+ /* First, handle rx2rw and n2rwx conversion automatically. */
+ if ( npfec.write_access && xma == XENMEM_access_rx2rw )
+ {
+ rc = p2m_set_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), 1,
+ 0, ~0, XENMEM_access_rw, 0);
+ return false;
+ }
+ else if ( xma == XENMEM_access_n2rwx )
+ {
+ rc = p2m_set_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), 1,
+ 0, ~0, XENMEM_access_rwx, 0);
+ }
+
+ /* Otherwise, check if there is a vm_event monitor subscriber */
+ if ( !vm_event_check_ring(&v->domain->vm_event->monitor) )
+ {
+ /* No listener */
+ if ( p2m->access_required )
+ {
+ gdprintk(XENLOG_INFO, "Memory access permissions failure, "
+ "no vm_event listener VCPU %d, dom %d\n",
+ v->vcpu_id, v->domain->domain_id);
+ domain_crash(v->domain);
+ }
+ else
+ {
+ /* n2rwx was already handled */
+ if ( xma != XENMEM_access_n2rwx )
+ {
+ /* A listener is not required, so clear the access
+ * restrictions. */
+ rc = p2m_set_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), 1,
+ 0, ~0, XENMEM_access_rwx, 0);
+ }
+ }
+
+ /* No need to reinject */
+ return false;
+ }
+
+ req = xzalloc(vm_event_request_t);
+ if ( req )
+ {
+ req->reason = VM_EVENT_REASON_MEM_ACCESS;
+
+ /* Send request to mem access subscriber */
+ req->u.mem_access.gfn = gpa >> PAGE_SHIFT;
+ req->u.mem_access.offset = gpa & ((1 << PAGE_SHIFT) - 1);
+ if ( npfec.gla_valid )
+ {
+ req->u.mem_access.flags |= MEM_ACCESS_GLA_VALID;
+ req->u.mem_access.gla = gla;
+
+ if ( npfec.kind == npfec_kind_with_gla )
+ req->u.mem_access.flags |= MEM_ACCESS_FAULT_WITH_GLA;
+ else if ( npfec.kind == npfec_kind_in_gpt )
+ req->u.mem_access.flags |= MEM_ACCESS_FAULT_IN_GPT;
+ }
+ req->u.mem_access.flags |= npfec.read_access ? MEM_ACCESS_R : 0;
+ req->u.mem_access.flags |= npfec.write_access ? MEM_ACCESS_W : 0;
+ req->u.mem_access.flags |= npfec.insn_fetch ? MEM_ACCESS_X : 0;
+
+ if ( monitor_traps(v, (xma != XENMEM_access_n2rwx), req) < 0 )
+ domain_crash(v->domain);
+
+ xfree(req);
+ }
+
+ return false;
+}
+
+/*
+ * Set access type for a region of pfns.
+ * If gfn == INVALID_GFN, sets the default access type.
+ */
+long p2m_set_mem_access(struct domain *d, gfn_t gfn, uint32_t nr,
+ uint32_t start, uint32_t mask, xenmem_access_t access,
+ unsigned int altp2m_idx)
+{
+ struct p2m_domain *p2m = p2m_get_hostp2m(d);
+ p2m_access_t a;
+ unsigned int order;
+ long rc = 0;
+
+ static const p2m_access_t memaccess[] = {
+#define ACCESS(ac) [XENMEM_access_##ac] = p2m_access_##ac
+ ACCESS(n),
+ ACCESS(r),
+ ACCESS(w),
+ ACCESS(rw),
+ ACCESS(x),
+ ACCESS(rx),
+ ACCESS(wx),
+ ACCESS(rwx),
+ ACCESS(rx2rw),
+ ACCESS(n2rwx),
+#undef ACCESS
+ };
+
+ switch ( access )
+ {
+ case 0 ... ARRAY_SIZE(memaccess) - 1:
+ a = memaccess[access];
+ break;
+ case XENMEM_access_default:
+ a = p2m->default_access;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ /*
+ * Flip mem_access_enabled to true when a permission is set, as to prevent
+ * allocating or inserting super-pages.
+ */
+ p2m->mem_access_enabled = true;
+
+ /* If request to set default access. */
+ if ( gfn_eq(gfn, INVALID_GFN) )
+ {
+ p2m->default_access = a;
+ return 0;
+ }
+
+ p2m_write_lock(p2m);
+
+ for ( gfn = gfn_add(gfn, start); nr > start;
+ gfn = gfn_next_boundary(gfn, order) )
+ {
+ p2m_type_t t;
+ mfn_t mfn = p2m_get_entry(p2m, gfn, &t, NULL, &order);
+
+
+ if ( !mfn_eq(mfn, INVALID_MFN) )
+ {
+ order = 0;
+ rc = p2m_set_entry(p2m, gfn, 1, mfn, t, a);
+ if ( rc )
+ break;
+ }
+
+ start += gfn_x(gfn_next_boundary(gfn, order)) - gfn_x(gfn);
+ /* Check for continuation if it is not the last iteration */
+ if ( nr > start && !(start & mask) && hypercall_preempt_check() )
+ {
+ rc = start;
+ break;
+ }
+ }
+
+ p2m_write_unlock(p2m);
+
+ return rc;
+}
+
+long p2m_set_mem_access_multi(struct domain *d,
+ const XEN_GUEST_HANDLE(const_uint64) pfn_list,
+ const XEN_GUEST_HANDLE(const_uint8) access_list,
+ uint32_t nr, uint32_t start, uint32_t mask,
+ unsigned int altp2m_idx)
+{
+ /* Not yet implemented on ARM. */
+ return -EOPNOTSUPP;
+}
+
+int p2m_get_mem_access(struct domain *d, gfn_t gfn,
+ xenmem_access_t *access)
+{
+ int ret;
+ struct p2m_domain *p2m = p2m_get_hostp2m(d);
+
+ p2m_read_lock(p2m);
+ ret = __p2m_get_mem_access(d, gfn, access);
+ p2m_read_unlock(p2m);
+
+ return ret;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
diff --git a/xen/arch/arm/p2m.c b/xen/arch/arm/p2m.c
index 837be1d..4e7ce3d 100644
--- a/xen/arch/arm/p2m.c
+++ b/xen/arch/arm/p2m.c
@@ -7,6 +7,7 @@
#include <xen/vm_event.h>
#include <xen/monitor.h>
#include <xen/iocap.h>
+#include <xen/mem_access.h>
#include <public/vm_event.h>
#include <asm/flushtlb.h>
#include <asm/gic.h>
@@ -58,22 +59,6 @@ static inline bool p2m_is_superpage(lpae_t pte, unsigned int
level)
return (level < 3) && p2m_mapping(pte);
}
-/*
- * Return the start of the next mapping based on the order of the
- * current one.
- */
-static inline gfn_t gfn_next_boundary(gfn_t gfn, unsigned int order)
-{
- /*
- * The order corresponds to the order of the mapping (or invalid
- * range) in the page table. So we need to align the GFN before
- * incrementing.
- */
- gfn = _gfn(gfn_x(gfn) & ~((1UL << order) - 1));
-
- return gfn_add(gfn, 1UL << order);
-}
-
static void p2m_flush_tlb(struct p2m_domain *p2m);
/* Unlock the flush and do a P2M TLB flush if necessary */
@@ -602,73 +587,6 @@ static int p2m_create_table(struct p2m_domain *p2m, lpae_t
*entry)
return 0;
}
-static int __p2m_get_mem_access(struct domain *d, gfn_t gfn,
- xenmem_access_t *access)
-{
- struct p2m_domain *p2m = p2m_get_hostp2m(d);
- void *i;
- unsigned int index;
-
- static const xenmem_access_t memaccess[] = {
-#define ACCESS(ac) [p2m_access_##ac] = XENMEM_access_##ac
- ACCESS(n),
- ACCESS(r),
- ACCESS(w),
- ACCESS(rw),
- ACCESS(x),
- ACCESS(rx),
- ACCESS(wx),
- ACCESS(rwx),
- ACCESS(rx2rw),
- ACCESS(n2rwx),
-#undef ACCESS
- };
-
- ASSERT(p2m_is_locked(p2m));
-
- /* If no setting was ever set, just return rwx. */
- if ( !p2m->mem_access_enabled )
- {
- *access = XENMEM_access_rwx;
- return 0;
- }
-
- /* If request to get default access. */
- if ( gfn_eq(gfn, INVALID_GFN) )
- {
- *access = memaccess[p2m->default_access];
- return 0;
- }
-
- i = radix_tree_lookup(&p2m->mem_access_settings, gfn_x(gfn));
-
- if ( !i )
- {
- /*
- * No setting was found in the Radix tree. Check if the
- * entry exists in the page-tables.
- */
- mfn_t mfn = p2m_get_entry(p2m, gfn, NULL, NULL, NULL);
-
- if ( mfn_eq(mfn, INVALID_MFN) )
- return -ESRCH;
-
- /* If entry exists then its rwx. */
- *access = XENMEM_access_rwx;
- }
- else
- {
- /* Setting was found in the Radix tree. */
- index = radix_tree_ptr_to_int(i);
- if ( index >= ARRAY_SIZE(memaccess) )
- return -ERANGE;
-
- *access = memaccess[index];
- }
-
- return 0;
-}
-
static int p2m_mem_access_radix_set(struct p2m_domain *p2m, gfn_t gfn,
p2m_access_t a)
{
@@ -1454,106 +1372,6 @@ mfn_t gfn_to_mfn(struct domain *d, gfn_t gfn)
return p2m_lookup(d, gfn, NULL);
}
-/*
- * If mem_access is in use it might have been the reason why get_page_from_gva
- * failed to fetch the page, as it uses the MMU for the permission checking.
- * Only in these cases we do a software-based type check and fetch the page if
- * we indeed found a conflicting mem_access setting.
- */
-static struct page_info*
-p2m_mem_access_check_and_get_page(vaddr_t gva, unsigned long flag,
- const struct vcpu *v)
-{
- long rc;
- paddr_t ipa;
- gfn_t gfn;
- mfn_t mfn;
- xenmem_access_t xma;
- p2m_type_t t;
- struct page_info *page = NULL;
- struct p2m_domain *p2m = &v->domain->arch.p2m;
-
- rc = gva_to_ipa(gva, &ipa, flag);
- if ( rc < 0 )
- goto err;
-
- gfn = _gfn(paddr_to_pfn(ipa));
-
- /*
- * We do this first as this is faster in the default case when no
- * permission is set on the page.
- */
- rc = __p2m_get_mem_access(v->domain, gfn, &xma);
- if ( rc < 0 )
- goto err;
-
- /* Let's check if mem_access limited the access. */
- switch ( xma )
- {
- default:
- case XENMEM_access_rwx:
- case XENMEM_access_rw:
- /*
- * If mem_access contains no rw perm restrictions at all then the
original
- * fault was correct.
- */
- goto err;
- case XENMEM_access_n2rwx:
- case XENMEM_access_n:
- case XENMEM_access_x:
- /*
- * If no r/w is permitted by mem_access, this was a fault caused by
mem_access.
- */
- break;
- case XENMEM_access_wx:
- case XENMEM_access_w:
- /*
- * If this was a read then it was because of mem_access, but if it was
- * a write then the original get_page_from_gva fault was correct.
- */
- if ( flag == GV2M_READ )
- break;
- else
- goto err;
- case XENMEM_access_rx2rw:
- case XENMEM_access_rx:
- case XENMEM_access_r:
- /*
- * If this was a write then it was because of mem_access, but if it was
- * a read then the original get_page_from_gva fault was correct.
- */
- if ( flag == GV2M_WRITE )
- break;
- else
- goto err;
- }
-
- /*
- * We had a mem_access permission limiting the access, but the page type
- * could also be limiting, so we need to check that as well.
- */
- mfn = p2m_get_entry(p2m, gfn, &t, NULL, NULL);
- if ( mfn_eq(mfn, INVALID_MFN) )
- goto err;
-
- if ( !mfn_valid(mfn_x(mfn)) )
- goto err;
-
- /*
- * Base type doesn't allow r/w
- */
- if ( t != p2m_ram_rw )
- goto err;
-
- page = mfn_to_page(mfn_x(mfn));
-
- if ( unlikely(!get_page(page, v->domain)) )
- page = NULL;
-
-err:
- return page;
-}
-
struct page_info *get_page_from_gva(struct vcpu *v, vaddr_t va,
unsigned long flags)
{
@@ -1666,236 +1484,6 @@ void __init setup_virt_paging(void)
smp_call_function(setup_virt_paging_one, (void *)val, 1);
}
-bool_t p2m_mem_access_check(paddr_t gpa, vaddr_t gla, const struct npfec npfec)
-{
- int rc;
- bool_t violation;
- xenmem_access_t xma;
- vm_event_request_t *req;
- struct vcpu *v = current;
- struct p2m_domain *p2m = p2m_get_hostp2m(v->domain);
-
- /* Mem_access is not in use. */
- if ( !p2m->mem_access_enabled )
- return true;
-
- rc = p2m_get_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), &xma);
- if ( rc )
- return true;
-
- /* Now check for mem_access violation. */
- switch ( xma )
- {
- case XENMEM_access_rwx:
- violation = false;
- break;
- case XENMEM_access_rw:
- violation = npfec.insn_fetch;
- break;
- case XENMEM_access_wx:
- violation = npfec.read_access;
- break;
- case XENMEM_access_rx:
- case XENMEM_access_rx2rw:
- violation = npfec.write_access;
- break;
- case XENMEM_access_x:
- violation = npfec.read_access || npfec.write_access;
- break;
- case XENMEM_access_w:
- violation = npfec.read_access || npfec.insn_fetch;
- break;
- case XENMEM_access_r:
- violation = npfec.write_access || npfec.insn_fetch;
- break;
- default:
- case XENMEM_access_n:
- case XENMEM_access_n2rwx:
- violation = true;
- break;
- }
-
- if ( !violation )
- return true;
-
- /* First, handle rx2rw and n2rwx conversion automatically. */
- if ( npfec.write_access && xma == XENMEM_access_rx2rw )
- {
- rc = p2m_set_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), 1,
- 0, ~0, XENMEM_access_rw, 0);
- return false;
- }
- else if ( xma == XENMEM_access_n2rwx )
- {
- rc = p2m_set_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), 1,
- 0, ~0, XENMEM_access_rwx, 0);
- }
-
- /* Otherwise, check if there is a vm_event monitor subscriber */
- if ( !vm_event_check_ring(&v->domain->vm_event->monitor) )
- {
- /* No listener */
- if ( p2m->access_required )
- {
- gdprintk(XENLOG_INFO, "Memory access permissions failure, "
- "no vm_event listener VCPU %d, dom %d\n",
- v->vcpu_id, v->domain->domain_id);
- domain_crash(v->domain);
- }
- else
- {
- /* n2rwx was already handled */
- if ( xma != XENMEM_access_n2rwx )
- {
- /* A listener is not required, so clear the access
- * restrictions. */
- rc = p2m_set_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), 1,
- 0, ~0, XENMEM_access_rwx, 0);
- }
- }
-
- /* No need to reinject */
- return false;
- }
-
- req = xzalloc(vm_event_request_t);
- if ( req )
- {
- req->reason = VM_EVENT_REASON_MEM_ACCESS;
-
- /* Send request to mem access subscriber */
- req->u.mem_access.gfn = gpa >> PAGE_SHIFT;
- req->u.mem_access.offset = gpa & ((1 << PAGE_SHIFT) - 1);
- if ( npfec.gla_valid )
- {
- req->u.mem_access.flags |= MEM_ACCESS_GLA_VALID;
- req->u.mem_access.gla = gla;
-
- if ( npfec.kind == npfec_kind_with_gla )
- req->u.mem_access.flags |= MEM_ACCESS_FAULT_WITH_GLA;
- else if ( npfec.kind == npfec_kind_in_gpt )
- req->u.mem_access.flags |= MEM_ACCESS_FAULT_IN_GPT;
- }
- req->u.mem_access.flags |= npfec.read_access ? MEM_ACCESS_R : 0;
- req->u.mem_access.flags |= npfec.write_access ? MEM_ACCESS_W : 0;
- req->u.mem_access.flags |= npfec.insn_fetch ? MEM_ACCESS_X : 0;
-
- if ( monitor_traps(v, (xma != XENMEM_access_n2rwx), req) < 0 )
- domain_crash(v->domain);
-
- xfree(req);
- }
-
- return false;
-}
-
-/*
- * Set access type for a region of pfns.
- * If gfn == INVALID_GFN, sets the default access type.
- */
-long p2m_set_mem_access(struct domain *d, gfn_t gfn, uint32_t nr,
- uint32_t start, uint32_t mask, xenmem_access_t access,
- unsigned int altp2m_idx)
-{
- struct p2m_domain *p2m = p2m_get_hostp2m(d);
- p2m_access_t a;
- unsigned int order;
- long rc = 0;
-
- static const p2m_access_t memaccess[] = {
-#define ACCESS(ac) [XENMEM_access_##ac] = p2m_access_##ac
- ACCESS(n),
- ACCESS(r),
- ACCESS(w),
- ACCESS(rw),
- ACCESS(x),
- ACCESS(rx),
- ACCESS(wx),
- ACCESS(rwx),
- ACCESS(rx2rw),
- ACCESS(n2rwx),
-#undef ACCESS
- };
-
- switch ( access )
- {
- case 0 ... ARRAY_SIZE(memaccess) - 1:
- a = memaccess[access];
- break;
- case XENMEM_access_default:
- a = p2m->default_access;
- break;
- default:
- return -EINVAL;
- }
-
- /*
- * Flip mem_access_enabled to true when a permission is set, as to prevent
- * allocating or inserting super-pages.
- */
- p2m->mem_access_enabled = true;
-
- /* If request to set default access. */
- if ( gfn_eq(gfn, INVALID_GFN) )
- {
- p2m->default_access = a;
- return 0;
- }
-
- p2m_write_lock(p2m);
-
- for ( gfn = gfn_add(gfn, start); nr > start;
- gfn = gfn_next_boundary(gfn, order) )
- {
- p2m_type_t t;
- mfn_t mfn = p2m_get_entry(p2m, gfn, &t, NULL, &order);
-
-
- if ( !mfn_eq(mfn, INVALID_MFN) )
- {
- order = 0;
- rc = __p2m_set_entry(p2m, gfn, 0, mfn, t, a);
- if ( rc )
- break;
- }
-
- start += gfn_x(gfn_next_boundary(gfn, order)) - gfn_x(gfn);
- /* Check for continuation if it is not the last iteration */
- if ( nr > start && !(start & mask) && hypercall_preempt_check() )
- {
- rc = start;
- break;
- }
- }
-
- p2m_write_unlock(p2m);
-
- return rc;
-}
-
-long p2m_set_mem_access_multi(struct domain *d,
- const XEN_GUEST_HANDLE(const_uint64) pfn_list,
- const XEN_GUEST_HANDLE(const_uint8) access_list,
- uint32_t nr, uint32_t start, uint32_t mask,
- unsigned int altp2m_idx)
-{
- /* Not yet implemented on ARM. */
- return -EOPNOTSUPP;
-}
-
-int p2m_get_mem_access(struct domain *d, gfn_t gfn,
- xenmem_access_t *access)
-{
- int ret;
- struct p2m_domain *p2m = p2m_get_hostp2m(d);
-
- p2m_read_lock(p2m);
- ret = __p2m_get_mem_access(d, gfn, access);
- p2m_read_unlock(p2m);
-
- return ret;
-}
-
/*
* Local variables:
* mode: C
diff --git a/xen/arch/arm/traps.c b/xen/arch/arm/traps.c
index 8ff73fe..f2ea083 100644
--- a/xen/arch/arm/traps.c
+++ b/xen/arch/arm/traps.c
@@ -32,6 +32,7 @@
#include <xen/domain_page.h>
#include <xen/perfc.h>
#include <xen/virtual_region.h>
+#include <xen/mem_access.h>
#include <public/sched.h>
#include <public/xen.h>
#include <asm/debugger.h>
diff --git a/xen/arch/x86/mm/Makefile b/xen/arch/x86/mm/Makefile
index 9804c3a..e977dd8 100644
--- a/xen/arch/x86/mm/Makefile
+++ b/xen/arch/x86/mm/Makefile
@@ -9,6 +9,7 @@ obj-y += guest_walk_3.o
obj-y += guest_walk_4.o
obj-y += mem_paging.o
obj-y += mem_sharing.o
+obj-y += mem_access.o
guest_walk_%.o: guest_walk.c Makefile
$(CC) $(CFLAGS) -DGUEST_PAGING_LEVELS=$* -c $< -o $@
diff --git a/xen/arch/x86/mm/mem_access.c b/xen/arch/x86/mm/mem_access.c
new file mode 100644
index 0000000..34a994d
--- /dev/null
+++ b/xen/arch/x86/mm/mem_access.c
@@ -0,0 +1,462 @@
+/******************************************************************************
+ * arch/x86/mm/mem_access.c
+ *
+ * Parts of this code are Copyright (c) 2009 by Citrix Systems, Inc. (Patrick
Colp)
+ * Parts of this code are Copyright (c) 2007 by Advanced Micro Devices.
+ * Parts of this code are Copyright (c) 2006-2007 by XenSource Inc.
+ * Parts of this code are Copyright (c) 2006 by Michael A Fetterman
+ * Parts based on earlier work by Michael A Fetterman, Ian Pratt et al.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <xen/guest_access.h> /* copy_from_guest() */
+#include <xen/mem_access.h>
+#include <xen/vm_event.h>
+#include <xen/event.h>
+#include <public/vm_event.h>
+#include <asm/p2m.h>
+#include <asm/altp2m.h>
+#include <asm/vm_event.h>
+
+#include "mm-locks.h"
+
+bool p2m_mem_access_emulate_check(struct vcpu *v,
+ const vm_event_response_t *rsp)
+{
+ xenmem_access_t access;
+ bool violation = 1;
+ const struct vm_event_mem_access *data = &rsp->u.mem_access;
+
+ if ( p2m_get_mem_access(v->domain, _gfn(data->gfn), &access) == 0 )
+ {
+ switch ( access )
+ {
+ case XENMEM_access_n:
+ case XENMEM_access_n2rwx:
+ default:
+ violation = data->flags & MEM_ACCESS_RWX;
+ break;
+
+ case XENMEM_access_r:
+ violation = data->flags & MEM_ACCESS_WX;
+ break;
+
+ case XENMEM_access_w:
+ violation = data->flags & MEM_ACCESS_RX;
+ break;
+
+ case XENMEM_access_x:
+ violation = data->flags & MEM_ACCESS_RW;
+ break;
+
+ case XENMEM_access_rx:
+ case XENMEM_access_rx2rw:
+ violation = data->flags & MEM_ACCESS_W;
+ break;
+
+ case XENMEM_access_wx:
+ violation = data->flags & MEM_ACCESS_R;
+ break;
+
+ case XENMEM_access_rw:
+ violation = data->flags & MEM_ACCESS_X;
+ break;
+
+ case XENMEM_access_rwx:
+ violation = 0;
+ break;
+ }
+ }
+
+ return violation;
+}
+
+bool_t p2m_mem_access_check(paddr_t gpa, unsigned long gla,
+ struct npfec npfec,
+ vm_event_request_t **req_ptr)
+{
+ struct vcpu *v = current;
+ unsigned long gfn = gpa >> PAGE_SHIFT;
+ struct domain *d = v->domain;
+ struct p2m_domain *p2m = NULL;
+ mfn_t mfn;
+ p2m_type_t p2mt;
+ p2m_access_t p2ma;
+ vm_event_request_t *req;
+ int rc;
+
+ if ( altp2m_active(d) )
+ p2m = p2m_get_altp2m(v);
+ if ( !p2m )
+ p2m = p2m_get_hostp2m(d);
+
+ /* First, handle rx2rw conversion automatically.
+ * These calls to p2m->set_entry() must succeed: we have the gfn
+ * locked and just did a successful get_entry(). */
+ gfn_lock(p2m, gfn, 0);
+ mfn = p2m->get_entry(p2m, gfn, &p2mt, &p2ma, 0, NULL, NULL);
+
+ if ( npfec.write_access && p2ma == p2m_access_rx2rw )
+ {
+ rc = p2m->set_entry(p2m, gfn, mfn, PAGE_ORDER_4K, p2mt, p2m_access_rw,
-1);
+ ASSERT(rc == 0);
+ gfn_unlock(p2m, gfn, 0);
+ return 1;
+ }
+ else if ( p2ma == p2m_access_n2rwx )
+ {
+ ASSERT(npfec.write_access || npfec.read_access || npfec.insn_fetch);
+ rc = p2m->set_entry(p2m, gfn, mfn, PAGE_ORDER_4K,
+ p2mt, p2m_access_rwx, -1);
+ ASSERT(rc == 0);
+ }
+ gfn_unlock(p2m, gfn, 0);
+
+ /* Otherwise, check if there is a memory event listener, and send the
message along */
+ 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 vm_event listener VCPU %d, dom %d\n",
+ v->vcpu_id, d->domain_id);
+ domain_crash(v->domain);
+ return 0;
+ }
+ else
+ {
+ gfn_lock(p2m, gfn, 0);
+ mfn = p2m->get_entry(p2m, gfn, &p2mt, &p2ma, 0, NULL, NULL);
+ if ( p2ma != p2m_access_n2rwx )
+ {
+ /* A listener is not required, so clear the access
+ * restrictions. This set must succeed: we have the
+ * gfn locked and just did a successful get_entry(). */
+ rc = p2m->set_entry(p2m, gfn, mfn, PAGE_ORDER_4K,
+ p2mt, p2m_access_rwx, -1);
+ ASSERT(rc == 0);
+ }
+ gfn_unlock(p2m, gfn, 0);
+ return 1;
+ }
+ }
+
+ *req_ptr = NULL;
+ req = xzalloc(vm_event_request_t);
+ if ( req )
+ {
+ *req_ptr = req;
+
+ req->reason = VM_EVENT_REASON_MEM_ACCESS;
+ req->u.mem_access.gfn = gfn;
+ req->u.mem_access.offset = gpa & ((1 << PAGE_SHIFT) - 1);
+ if ( npfec.gla_valid )
+ {
+ req->u.mem_access.flags |= MEM_ACCESS_GLA_VALID;
+ req->u.mem_access.gla = gla;
+
+ if ( npfec.kind == npfec_kind_with_gla )
+ req->u.mem_access.flags |= MEM_ACCESS_FAULT_WITH_GLA;
+ else if ( npfec.kind == npfec_kind_in_gpt )
+ req->u.mem_access.flags |= MEM_ACCESS_FAULT_IN_GPT;
+ }
+ req->u.mem_access.flags |= npfec.read_access ? MEM_ACCESS_R : 0;
+ req->u.mem_access.flags |= npfec.write_access ? MEM_ACCESS_W : 0;
+ req->u.mem_access.flags |= npfec.insn_fetch ? MEM_ACCESS_X : 0;
+ }
+
+ /* Return whether vCPU pause is required (aka. sync event) */
+ return (p2ma != p2m_access_n2rwx);
+}
+
+int p2m_set_altp2m_mem_access(struct domain *d, struct p2m_domain *hp2m,
+ struct p2m_domain *ap2m, p2m_access_t a,
+ gfn_t gfn)
+{
+ mfn_t mfn;
+ p2m_type_t t;
+ p2m_access_t old_a;
+ unsigned int page_order;
+ unsigned long gfn_l = gfn_x(gfn);
+ int rc;
+
+ mfn = ap2m->get_entry(ap2m, gfn_l, &t, &old_a, 0, NULL, NULL);
+
+ /* Check host p2m if no valid entry in alternate */
+ if ( !mfn_valid(mfn_x(mfn)) )
+ {
+
+ mfn = __get_gfn_type_access(hp2m, gfn_l, &t, &old_a,
+ P2M_ALLOC | P2M_UNSHARE, &page_order, 0);
+
+ rc = -ESRCH;
+ if ( !mfn_valid(mfn_x(mfn)) || t != p2m_ram_rw )
+ return rc;
+
+ /* If this is a superpage, copy that first */
+ if ( page_order != PAGE_ORDER_4K )
+ {
+ unsigned long mask = ~((1UL << page_order) - 1);
+ unsigned long gfn2_l = gfn_l & mask;
+ mfn_t mfn2 = _mfn(mfn_x(mfn) & mask);
+
+ rc = ap2m->set_entry(ap2m, gfn2_l, mfn2, page_order, t, old_a, 1);
+ if ( rc )
+ return rc;
+ }
+ }
+
+ return ap2m->set_entry(ap2m, gfn_l, mfn, PAGE_ORDER_4K, t, a,
+ (current->domain != d));
+}
+
+static int set_mem_access(struct domain *d, struct p2m_domain *p2m,
+ struct p2m_domain *ap2m, p2m_access_t a,
+ gfn_t gfn)
+{
+ int rc = 0;
+
+ if ( ap2m )
+ {
+ rc = p2m_set_altp2m_mem_access(d, p2m, ap2m, a, gfn);
+ /* If the corresponding mfn is invalid we will want to just skip it */
+ if ( rc == -ESRCH )
+ rc = 0;
+ }
+ else
+ {
+ mfn_t mfn;
+ p2m_access_t _a;
+ p2m_type_t t;
+ unsigned long gfn_l = gfn_x(gfn);
+
+ mfn = p2m->get_entry(p2m, gfn_l, &t, &_a, 0, NULL, NULL);
+ rc = p2m->set_entry(p2m, gfn_l, mfn, PAGE_ORDER_4K, t, a, -1);
+ }
+
+ return rc;
+}
+
+static bool xenmem_access_to_p2m_access(struct p2m_domain *p2m,
+ xenmem_access_t xaccess,
+ p2m_access_t *paccess)
+{
+ static const p2m_access_t memaccess[] = {
+#define ACCESS(ac) [XENMEM_access_##ac] = p2m_access_##ac
+ ACCESS(n),
+ ACCESS(r),
+ ACCESS(w),
+ ACCESS(rw),
+ ACCESS(x),
+ ACCESS(rx),
+ ACCESS(wx),
+ ACCESS(rwx),
+ ACCESS(rx2rw),
+ ACCESS(n2rwx),
+#undef ACCESS
+ };
+
+ switch ( xaccess )
+ {
+ case 0 ... ARRAY_SIZE(memaccess) - 1:
+ *paccess = memaccess[xaccess];
+ break;
+ case XENMEM_access_default:
+ *paccess = p2m->default_access;
+ break;
+ default:
+ return false;
+ }
+
+ return true;
+}
+
+/*
+ * Set access type for a region of gfns.
+ * If gfn == INVALID_GFN, sets the default access type.
+ */
+long p2m_set_mem_access(struct domain *d, gfn_t gfn, uint32_t nr,
+ uint32_t start, uint32_t mask, xenmem_access_t access,
+ unsigned int altp2m_idx)
+{
+ struct p2m_domain *p2m = p2m_get_hostp2m(d), *ap2m = NULL;
+ p2m_access_t a;
+ unsigned long gfn_l;
+ long rc = 0;
+
+ /* altp2m view 0 is treated as the hostp2m */
+ if ( altp2m_idx )
+ {
+ if ( altp2m_idx >= MAX_ALTP2M ||
+ d->arch.altp2m_eptp[altp2m_idx] == mfn_x(INVALID_MFN) )
+ return -EINVAL;
+
+ ap2m = d->arch.altp2m_p2m[altp2m_idx];
+ }
+
+ if ( !xenmem_access_to_p2m_access(p2m, access, &a) )
+ return -EINVAL;
+
+ /* If request to set default access. */
+ if ( gfn_eq(gfn, INVALID_GFN) )
+ {
+ p2m->default_access = a;
+ return 0;
+ }
+
+ p2m_lock(p2m);
+ if ( ap2m )
+ p2m_lock(ap2m);
+
+ for ( gfn_l = gfn_x(gfn) + start; nr > start; ++gfn_l )
+ {
+ rc = set_mem_access(d, p2m, ap2m, a, _gfn(gfn_l));
+
+ if ( rc )
+ break;
+
+ /* Check for continuation if it's not the last iteration. */
+ if ( nr > ++start && !(start & mask) && hypercall_preempt_check() )
+ {
+ rc = start;
+ break;
+ }
+ }
+
+ if ( ap2m )
+ p2m_unlock(ap2m);
+ p2m_unlock(p2m);
+
+ return rc;
+}
+
+long p2m_set_mem_access_multi(struct domain *d,
+ const XEN_GUEST_HANDLE(const_uint64) pfn_list,
+ const XEN_GUEST_HANDLE(const_uint8) access_list,
+ uint32_t nr, uint32_t start, uint32_t mask,
+ unsigned int altp2m_idx)
+{
+ struct p2m_domain *p2m = p2m_get_hostp2m(d), *ap2m = NULL;
+ long rc = 0;
+
+ /* altp2m view 0 is treated as the hostp2m */
+ if ( altp2m_idx )
+ {
+ if ( altp2m_idx >= MAX_ALTP2M ||
+ d->arch.altp2m_eptp[altp2m_idx] == mfn_x(INVALID_MFN) )
+ return -EINVAL;
+
+ ap2m = d->arch.altp2m_p2m[altp2m_idx];
+ }
+
+ p2m_lock(p2m);
+ if ( ap2m )
+ p2m_lock(ap2m);
+
+ while ( start < nr )
+ {
+ p2m_access_t a;
+ uint8_t access;
+ uint64_t gfn_l;
+
+ if ( copy_from_guest_offset(&gfn_l, pfn_list, start, 1) ||
+ copy_from_guest_offset(&access, access_list, start, 1) )
+ {
+ rc = -EFAULT;
+ break;
+ }
+
+ if ( !xenmem_access_to_p2m_access(p2m, access, &a) )
+ {
+ rc = -EINVAL;
+ break;
+ }
+
+ rc = set_mem_access(d, p2m, ap2m, a, _gfn(gfn_l));
+
+ if ( rc )
+ break;
+
+ /* Check for continuation if it's not the last iteration. */
+ if ( nr > ++start && !(start & mask) && hypercall_preempt_check() )
+ {
+ rc = start;
+ break;
+ }
+ }
+
+ if ( ap2m )
+ p2m_unlock(ap2m);
+ p2m_unlock(p2m);
+
+ return rc;
+}
+
+/*
+ * Get access type for a gfn.
+ * If gfn == INVALID_GFN, gets the default access type.
+ */
+int p2m_get_mem_access(struct domain *d, gfn_t gfn, xenmem_access_t *access)
+{
+ struct p2m_domain *p2m = p2m_get_hostp2m(d);
+ p2m_type_t t;
+ p2m_access_t a;
+ mfn_t mfn;
+
+ static const xenmem_access_t memaccess[] = {
+#define ACCESS(ac) [p2m_access_##ac] = XENMEM_access_##ac
+ ACCESS(n),
+ ACCESS(r),
+ ACCESS(w),
+ ACCESS(rw),
+ ACCESS(x),
+ ACCESS(rx),
+ ACCESS(wx),
+ ACCESS(rwx),
+ ACCESS(rx2rw),
+ ACCESS(n2rwx),
+#undef ACCESS
+ };
+
+ /* If request to get default access. */
+ if ( gfn_eq(gfn, INVALID_GFN) )
+ {
+ *access = memaccess[p2m->default_access];
+ return 0;
+ }
+
+ gfn_lock(p2m, gfn, 0);
+ mfn = p2m->get_entry(p2m, gfn_x(gfn), &t, &a, 0, NULL, NULL);
+ gfn_unlock(p2m, gfn, 0);
+
+ if ( mfn_eq(mfn, INVALID_MFN) )
+ return -ESRCH;
+
+ if ( (unsigned) a >= ARRAY_SIZE(memaccess) )
+ return -ERANGE;
+
+ *access = memaccess[a];
+ return 0;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
diff --git a/xen/arch/x86/mm/p2m.c b/xen/arch/x86/mm/p2m.c
index 6a45185..6299d5a 100644
--- a/xen/arch/x86/mm/p2m.c
+++ b/xen/arch/x86/mm/p2m.c
@@ -1589,433 +1589,12 @@ void p2m_mem_paging_resume(struct domain *d,
vm_event_response_t *rsp)
}
}
-bool p2m_mem_access_emulate_check(struct vcpu *v,
- const vm_event_response_t *rsp)
-{
- xenmem_access_t access;
- bool violation = 1;
- const struct vm_event_mem_access *data = &rsp->u.mem_access;
-
- if ( p2m_get_mem_access(v->domain, _gfn(data->gfn), &access) == 0 )
- {
- switch ( access )
- {
- case XENMEM_access_n:
- case XENMEM_access_n2rwx:
- default:
- violation = data->flags & MEM_ACCESS_RWX;
- break;
-
- case XENMEM_access_r:
- violation = data->flags & MEM_ACCESS_WX;
- break;
-
- case XENMEM_access_w:
- violation = data->flags & MEM_ACCESS_RX;
- break;
-
- case XENMEM_access_x:
- violation = data->flags & MEM_ACCESS_RW;
- break;
-
- case XENMEM_access_rx:
- case XENMEM_access_rx2rw:
- violation = data->flags & MEM_ACCESS_W;
- break;
-
- case XENMEM_access_wx:
- violation = data->flags & MEM_ACCESS_R;
- break;
-
- case XENMEM_access_rw:
- violation = data->flags & MEM_ACCESS_X;
- break;
-
- case XENMEM_access_rwx:
- violation = 0;
- break;
- }
- }
-
- return violation;
-}
-
void p2m_altp2m_check(struct vcpu *v, uint16_t idx)
{
if ( altp2m_active(v->domain) )
p2m_switch_vcpu_altp2m_by_id(v, idx);
}
-bool_t p2m_mem_access_check(paddr_t gpa, unsigned long gla,
- struct npfec npfec,
- vm_event_request_t **req_ptr)
-{
- struct vcpu *v = current;
- unsigned long gfn = gpa >> PAGE_SHIFT;
- struct domain *d = v->domain;
- struct p2m_domain *p2m = NULL;
- mfn_t mfn;
- p2m_type_t p2mt;
- p2m_access_t p2ma;
- vm_event_request_t *req;
- int rc;
-
- if ( altp2m_active(d) )
- p2m = p2m_get_altp2m(v);
- if ( !p2m )
- p2m = p2m_get_hostp2m(d);
-
- /* First, handle rx2rw conversion automatically.
- * These calls to p2m->set_entry() must succeed: we have the gfn
- * locked and just did a successful get_entry(). */
- gfn_lock(p2m, gfn, 0);
- mfn = p2m->get_entry(p2m, gfn, &p2mt, &p2ma, 0, NULL, NULL);
-
- if ( npfec.write_access && p2ma == p2m_access_rx2rw )
- {
- rc = p2m->set_entry(p2m, gfn, mfn, PAGE_ORDER_4K, p2mt, p2m_access_rw,
-1);
- ASSERT(rc == 0);
- gfn_unlock(p2m, gfn, 0);
- return 1;
- }
- else if ( p2ma == p2m_access_n2rwx )
- {
- ASSERT(npfec.write_access || npfec.read_access || npfec.insn_fetch);
- rc = p2m->set_entry(p2m, gfn, mfn, PAGE_ORDER_4K,
- p2mt, p2m_access_rwx, -1);
- ASSERT(rc == 0);
- }
- gfn_unlock(p2m, gfn, 0);
-
- /* Otherwise, check if there is a memory event listener, and send the
message along */
- 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 vm_event listener VCPU %d, dom %d\n",
- v->vcpu_id, d->domain_id);
- domain_crash(v->domain);
- return 0;
- }
- else
- {
- gfn_lock(p2m, gfn, 0);
- mfn = p2m->get_entry(p2m, gfn, &p2mt, &p2ma, 0, NULL, NULL);
- if ( p2ma != p2m_access_n2rwx )
- {
- /* A listener is not required, so clear the access
- * restrictions. This set must succeed: we have the
- * gfn locked and just did a successful get_entry(). */
- rc = p2m->set_entry(p2m, gfn, mfn, PAGE_ORDER_4K,
- p2mt, p2m_access_rwx, -1);
- ASSERT(rc == 0);
- }
- gfn_unlock(p2m, gfn, 0);
- return 1;
- }
- }
-
- *req_ptr = NULL;
- req = xzalloc(vm_event_request_t);
- if ( req )
- {
- *req_ptr = req;
-
- req->reason = VM_EVENT_REASON_MEM_ACCESS;
- req->u.mem_access.gfn = gfn;
- req->u.mem_access.offset = gpa & ((1 << PAGE_SHIFT) - 1);
- if ( npfec.gla_valid )
- {
- req->u.mem_access.flags |= MEM_ACCESS_GLA_VALID;
- req->u.mem_access.gla = gla;
-
- if ( npfec.kind == npfec_kind_with_gla )
- req->u.mem_access.flags |= MEM_ACCESS_FAULT_WITH_GLA;
- else if ( npfec.kind == npfec_kind_in_gpt )
- req->u.mem_access.flags |= MEM_ACCESS_FAULT_IN_GPT;
- }
- req->u.mem_access.flags |= npfec.read_access ? MEM_ACCESS_R : 0;
- req->u.mem_access.flags |= npfec.write_access ? MEM_ACCESS_W : 0;
- req->u.mem_access.flags |= npfec.insn_fetch ? MEM_ACCESS_X : 0;
- }
-
- /* Return whether vCPU pause is required (aka. sync event) */
- return (p2ma != p2m_access_n2rwx);
-}
-
-static inline
-int p2m_set_altp2m_mem_access(struct domain *d, struct p2m_domain *hp2m,
- struct p2m_domain *ap2m, p2m_access_t a,
- gfn_t gfn)
-{
- mfn_t mfn;
- p2m_type_t t;
- p2m_access_t old_a;
- unsigned int page_order;
- unsigned long gfn_l = gfn_x(gfn);
- int rc;
-
- mfn = ap2m->get_entry(ap2m, gfn_l, &t, &old_a, 0, NULL, NULL);
-
- /* Check host p2m if no valid entry in alternate */
- if ( !mfn_valid(mfn) )
- {
-
- mfn = __get_gfn_type_access(hp2m, gfn_l, &t, &old_a,
- P2M_ALLOC | P2M_UNSHARE, &page_order, 0);
-
- rc = -ESRCH;
- if ( !mfn_valid(mfn) || t != p2m_ram_rw )
- return rc;
-
- /* If this is a superpage, copy that first */
- if ( page_order != PAGE_ORDER_4K )
- {
- unsigned long mask = ~((1UL << page_order) - 1);
- unsigned long gfn2_l = gfn_l & mask;
- mfn_t mfn2 = _mfn(mfn_x(mfn) & mask);
-
- rc = ap2m->set_entry(ap2m, gfn2_l, mfn2, page_order, t, old_a, 1);
- if ( rc )
- return rc;
- }
- }
-
- return ap2m->set_entry(ap2m, gfn_l, mfn, PAGE_ORDER_4K, t, a,
- (current->domain != d));
-}
-
-static int set_mem_access(struct domain *d, struct p2m_domain *p2m,
- struct p2m_domain *ap2m, p2m_access_t a,
- gfn_t gfn)
-{
- int rc = 0;
-
- if ( ap2m )
- {
- rc = p2m_set_altp2m_mem_access(d, p2m, ap2m, a, gfn);
- /* If the corresponding mfn is invalid we will want to just skip it */
- if ( rc == -ESRCH )
- rc = 0;
- }
- else
- {
- mfn_t mfn;
- p2m_access_t _a;
- p2m_type_t t;
- unsigned long gfn_l = gfn_x(gfn);
-
- mfn = p2m->get_entry(p2m, gfn_l, &t, &_a, 0, NULL, NULL);
- rc = p2m->set_entry(p2m, gfn_l, mfn, PAGE_ORDER_4K, t, a, -1);
- }
-
- return rc;
-}
-
-static bool xenmem_access_to_p2m_access(struct p2m_domain *p2m,
- xenmem_access_t xaccess,
- p2m_access_t *paccess)
-{
- static const p2m_access_t memaccess[] = {
-#define ACCESS(ac) [XENMEM_access_##ac] = p2m_access_##ac
- ACCESS(n),
- ACCESS(r),
- ACCESS(w),
- ACCESS(rw),
- ACCESS(x),
- ACCESS(rx),
- ACCESS(wx),
- ACCESS(rwx),
- ACCESS(rx2rw),
- ACCESS(n2rwx),
-#undef ACCESS
- };
-
- switch ( xaccess )
- {
- case 0 ... ARRAY_SIZE(memaccess) - 1:
- *paccess = memaccess[xaccess];
- break;
- case XENMEM_access_default:
- *paccess = p2m->default_access;
- break;
- default:
- return false;
- }
-
- return true;
-}
-
-/*
- * Set access type for a region of gfns.
- * If gfn == INVALID_GFN, sets the default access type.
- */
-long p2m_set_mem_access(struct domain *d, gfn_t gfn, uint32_t nr,
- uint32_t start, uint32_t mask, xenmem_access_t access,
- unsigned int altp2m_idx)
-{
- struct p2m_domain *p2m = p2m_get_hostp2m(d), *ap2m = NULL;
- p2m_access_t a;
- unsigned long gfn_l;
- long rc = 0;
-
- /* altp2m view 0 is treated as the hostp2m */
- if ( altp2m_idx )
- {
- if ( altp2m_idx >= MAX_ALTP2M ||
- d->arch.altp2m_eptp[altp2m_idx] == mfn_x(INVALID_MFN) )
- return -EINVAL;
-
- ap2m = d->arch.altp2m_p2m[altp2m_idx];
- }
-
- if ( !xenmem_access_to_p2m_access(p2m, access, &a) )
- return -EINVAL;
-
- /* If request to set default access. */
- if ( gfn_eq(gfn, INVALID_GFN) )
- {
- p2m->default_access = a;
- return 0;
- }
-
- p2m_lock(p2m);
- if ( ap2m )
- p2m_lock(ap2m);
-
- for ( gfn_l = gfn_x(gfn) + start; nr > start; ++gfn_l )
- {
- rc = set_mem_access(d, p2m, ap2m, a, _gfn(gfn_l));
-
- if ( rc )
- break;
-
- /* Check for continuation if it's not the last iteration. */
- if ( nr > ++start && !(start & mask) && hypercall_preempt_check() )
- {
- rc = start;
- break;
- }
- }
-
- if ( ap2m )
- p2m_unlock(ap2m);
- p2m_unlock(p2m);
-
- return rc;
-}
-
-long p2m_set_mem_access_multi(struct domain *d,
- const XEN_GUEST_HANDLE(const_uint64) pfn_list,
- const XEN_GUEST_HANDLE(const_uint8) access_list,
- uint32_t nr, uint32_t start, uint32_t mask,
- unsigned int altp2m_idx)
-{
- struct p2m_domain *p2m = p2m_get_hostp2m(d), *ap2m = NULL;
- long rc = 0;
-
- /* altp2m view 0 is treated as the hostp2m */
- if ( altp2m_idx )
- {
- if ( altp2m_idx >= MAX_ALTP2M ||
- d->arch.altp2m_eptp[altp2m_idx] == mfn_x(INVALID_MFN) )
- return -EINVAL;
-
- ap2m = d->arch.altp2m_p2m[altp2m_idx];
- }
-
- p2m_lock(p2m);
- if ( ap2m )
- p2m_lock(ap2m);
-
- while ( start < nr )
- {
- p2m_access_t a;
- uint8_t access;
- uint64_t gfn_l;
-
- if ( copy_from_guest_offset(&gfn_l, pfn_list, start, 1) ||
- copy_from_guest_offset(&access, access_list, start, 1) )
- {
- rc = -EFAULT;
- break;
- }
-
- if ( !xenmem_access_to_p2m_access(p2m, access, &a) )
- {
- rc = -EINVAL;
- break;
- }
-
- rc = set_mem_access(d, p2m, ap2m, a, _gfn(gfn_l));
-
- if ( rc )
- break;
-
- /* Check for continuation if it's not the last iteration. */
- if ( nr > ++start && !(start & mask) && hypercall_preempt_check() )
- {
- rc = start;
- break;
- }
- }
-
- if ( ap2m )
- p2m_unlock(ap2m);
- p2m_unlock(p2m);
-
- return rc;
-}
-
-/*
- * Get access type for a gfn.
- * If gfn == INVALID_GFN, gets the default access type.
- */
-int p2m_get_mem_access(struct domain *d, gfn_t gfn, xenmem_access_t *access)
-{
- struct p2m_domain *p2m = p2m_get_hostp2m(d);
- p2m_type_t t;
- p2m_access_t a;
- mfn_t mfn;
-
- static const xenmem_access_t memaccess[] = {
-#define ACCESS(ac) [p2m_access_##ac] = XENMEM_access_##ac
- ACCESS(n),
- ACCESS(r),
- ACCESS(w),
- ACCESS(rw),
- ACCESS(x),
- ACCESS(rx),
- ACCESS(wx),
- ACCESS(rwx),
- ACCESS(rx2rw),
- ACCESS(n2rwx),
-#undef ACCESS
- };
-
- /* If request to get default access. */
- if ( gfn_eq(gfn, INVALID_GFN) )
- {
- *access = memaccess[p2m->default_access];
- return 0;
- }
-
- gfn_lock(p2m, gfn, 0);
- mfn = p2m->get_entry(p2m, gfn_x(gfn), &t, &a, 0, NULL, NULL);
- gfn_unlock(p2m, gfn, 0);
-
- if ( mfn_eq(mfn, INVALID_MFN) )
- return -ESRCH;
-
- if ( (unsigned) a >= ARRAY_SIZE(memaccess) )
- return -ERANGE;
-
- *access = memaccess[a];
- return 0;
-}
-
static struct p2m_domain *
p2m_getlru_nestedp2m(struct domain *d, struct p2m_domain *p2m)
{
diff --git a/xen/arch/x86/vm_event.c b/xen/arch/x86/vm_event.c
index 1e88d67..8d8bc4a 100644
--- a/xen/arch/x86/vm_event.c
+++ b/xen/arch/x86/vm_event.c
@@ -18,7 +18,8 @@
* License along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
-#include <asm/p2m.h>
+#include <xen/sched.h>
+#include <xen/mem_access.h>
#include <asm/vm_event.h>
/* Implicitly serialized by the domctl lock. */
diff --git a/xen/common/mem_access.c b/xen/common/mem_access.c
index 565a320..19f63bb 100644
--- a/xen/common/mem_access.c
+++ b/xen/common/mem_access.c
@@ -24,8 +24,8 @@
#include <xen/guest_access.h>
#include <xen/hypercall.h>
#include <xen/vm_event.h>
+#include <xen/mem_access.h>
#include <public/memory.h>
-#include <asm/p2m.h>
#include <xsm/xsm.h>
int mem_access_memop(unsigned long cmd,
diff --git a/xen/include/asm-arm/mem_access.h b/xen/include/asm-arm/mem_access.h
new file mode 100644
index 0000000..3a155f8
--- /dev/null
+++ b/xen/include/asm-arm/mem_access.h
@@ -0,0 +1,53 @@
+/*
+ * mem_access.h: architecture specific mem_access handling routines
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ASM_ARM_MEM_ACCESS_H
+#define _ASM_ARM_MEM_ACCESS_H
+
+static inline
+bool p2m_mem_access_emulate_check(struct vcpu *v,
+ const vm_event_response_t *rsp)
+{
+ /* Not supported on ARM. */
+ return 0;
+}
+
+/* vm_event and mem_access are supported on any ARM guest */
+static inline bool_t p2m_mem_access_sanity_check(struct domain *d)
+{
+ return 1;
+}
+
+/*
+ * Send mem event based on the access. Boolean return value indicates if trap
+ * needs to be injected into guest.
+ */
+bool_t p2m_mem_access_check(paddr_t gpa, vaddr_t gla, const struct npfec
npfec);
+
+struct page_info*
+p2m_mem_access_check_and_get_page(vaddr_t gva, unsigned long flag,
+ const struct vcpu *v);
+
+#endif /* _ASM_ARM_MEM_ACCESS_H */
+
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
diff --git a/xen/include/asm-arm/p2m.h b/xen/include/asm-arm/p2m.h
index fdb6b47..2b22e9a 100644
--- a/xen/include/asm-arm/p2m.h
+++ b/xen/include/asm-arm/p2m.h
@@ -4,6 +4,7 @@
#include <xen/mm.h>
#include <xen/radix-tree.h>
#include <xen/rwlock.h>
+#include <xen/mem_access.h>
#include <public/vm_event.h> /* for vm_event_response_t */
#include <public/memory.h>
#include <xen/p2m-common.h>
@@ -139,14 +140,6 @@ typedef enum {
p2m_to_mask(p2m_map_foreign)))
static inline
-bool p2m_mem_access_emulate_check(struct vcpu *v,
- const vm_event_response_t *rsp)
-{
- /* Not supported on ARM. */
- return 0;
-}
-
-static inline
void p2m_altp2m_check(struct vcpu *v, uint16_t idx)
{
/* Not supported on ARM. */
@@ -343,22 +336,26 @@ static inline int get_page_and_type(struct page_info
*page,
/* get host p2m table */
#define p2m_get_hostp2m(d) (&(d)->arch.p2m)
-/* vm_event and mem_access are supported on any ARM guest */
-static inline bool_t p2m_mem_access_sanity_check(struct domain *d)
-{
- return 1;
-}
-
static inline bool_t p2m_vm_event_sanity_check(struct domain *d)
{
return 1;
}
/*
- * Send mem event based on the access. Boolean return value indicates if trap
- * needs to be injected into guest.
+ * Return the start of the next mapping based on the order of the
+ * current one.
*/
-bool_t p2m_mem_access_check(paddr_t gpa, vaddr_t gla, const struct npfec
npfec);
+static inline gfn_t gfn_next_boundary(gfn_t gfn, unsigned int order)
+{
+ /*
+ * The order corresponds to the order of the mapping (or invalid
+ * range) in the page table. So we need to align the GFN before
+ * incrementing.
+ */
+ gfn = _gfn(gfn_x(gfn) & ~((1UL << order) - 1));
+
+ return gfn_add(gfn, 1UL << order);
+}
#endif /* _XEN_P2M_H */
diff --git a/xen/include/asm-x86/mem_access.h b/xen/include/asm-x86/mem_access.h
new file mode 100644
index 0000000..9f7b409
--- /dev/null
+++ b/xen/include/asm-x86/mem_access.h
@@ -0,0 +1,61 @@
+/******************************************************************************
+ * include/asm-x86/mem_access.h
+ *
+ * Memory access support.
+ *
+ * Copyright (c) 2011 GridCentric Inc. (Andres Lagar-Cavilla)
+ * Copyright (c) 2007 Advanced Micro Devices (Wei Huang)
+ * Parts of this code are Copyright (c) 2006-2007 by XenSource Inc.
+ * Parts of this code are Copyright (c) 2006 by Michael A Fetterman
+ * Parts based on earlier work by Michael A Fetterman, Ian Pratt et al.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ASM_X86_MEM_ACCESS_H__
+#define __ASM_X86_MEM_ACCESS_H__
+
+/*
+ * Setup vm_event request based on the access (gla is -1ull if not available).
+ * Handles the rw2rx conversion. Boolean return value indicates if event type
+ * is syncronous (aka. requires vCPU pause). If the req_ptr has been populated,
+ * then the caller should use monitor_traps to send the event on the MONITOR
+ * ring. Once having released get_gfn* locks caller must also xfree the
+ * request.
+ */
+bool_t p2m_mem_access_check(paddr_t gpa, unsigned long gla,
+ struct npfec npfec,
+ vm_event_request_t **req_ptr);
+
+/* Check for emulation and mark vcpu for skipping one instruction
+ * upon rescheduling if required. */
+bool p2m_mem_access_emulate_check(struct vcpu *v,
+ const vm_event_response_t *rsp);
+
+/* Sanity check for mem_access hardware support */
+static inline bool_t p2m_mem_access_sanity_check(struct domain *d)
+{
+ return is_hvm_domain(d) && cpu_has_vmx && hap_enabled(d);
+}
+
+#endif /*__ASM_X86_MEM_ACCESS_H__ */
+
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
diff --git a/xen/include/asm-x86/p2m.h b/xen/include/asm-x86/p2m.h
index 7035860..8964e90 100644
--- a/xen/include/asm-x86/p2m.h
+++ b/xen/include/asm-x86/p2m.h
@@ -29,6 +29,7 @@
#include <xen/config.h>
#include <xen/paging.h>
#include <xen/p2m-common.h>
+#include <xen/mem_access.h>
#include <asm/mem_sharing.h>
#include <asm/page.h> /* for pagetable_t */
@@ -663,29 +664,6 @@ int p2m_mem_paging_prep(struct domain *d, unsigned long
gfn, uint64_t buffer);
/* Resume normal operation (in case a domain was paused) */
void p2m_mem_paging_resume(struct domain *d, vm_event_response_t *rsp);
-/*
- * Setup vm_event request based on the access (gla is -1ull if not available).
- * Handles the rw2rx conversion. Boolean return value indicates if event type
- * is syncronous (aka. requires vCPU pause). If the req_ptr has been populated,
- * then the caller should use monitor_traps to send the event on the MONITOR
- * ring. Once having released get_gfn* locks caller must also xfree the
- * request.
- */
-bool_t p2m_mem_access_check(paddr_t gpa, unsigned long gla,
- struct npfec npfec,
- vm_event_request_t **req_ptr);
-
-/* Check for emulation and mark vcpu for skipping one instruction
- * upon rescheduling if required. */
-bool p2m_mem_access_emulate_check(struct vcpu *v,
- const vm_event_response_t *rsp);
-
-/* Sanity check for mem_access hardware support */
-static inline bool_t p2m_mem_access_sanity_check(struct domain *d)
-{
- return is_hvm_domain(d) && cpu_has_vmx && hap_enabled(d);
-}
-
/*
* Internal functions, only called by other p2m code
*/
diff --git a/xen/include/xen/mem_access.h b/xen/include/xen/mem_access.h
index da36e07..5ab34c1 100644
--- a/xen/include/xen/mem_access.h
+++ b/xen/include/xen/mem_access.h
@@ -19,29 +19,78 @@
* along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
-#ifndef _XEN_ASM_MEM_ACCESS_H
-#define _XEN_ASM_MEM_ACCESS_H
+#ifndef _XEN_MEM_ACCESS_H
+#define _XEN_MEM_ACCESS_H
+#include <xen/types.h>
+#include <xen/mm.h>
#include <public/memory.h>
-#include <asm/p2m.h>
+#include <public/vm_event.h>
+#include <asm/mem_access.h>
-#ifdef CONFIG_HAS_MEM_ACCESS
+/*
+ * 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 vm_event
+ * interface.
+ *
+ * The access permissions are soft state: when any ambiguous change of page
+ * type or use occurs, or when pages are flushed, swapped, or at any other
+ * convenient type, the access permissions can get reset to the p2m_domain
+ * default.
+ */
+typedef enum {
+ /* Code uses bottom three bits with bitmask semantics */
+ p2m_access_n = 0, /* No access allowed. */
+ p2m_access_r = 1 << 0,
+ p2m_access_w = 1 << 1,
+ p2m_access_x = 1 << 2,
+ p2m_access_rw = p2m_access_r | p2m_access_w,
+ p2m_access_rx = p2m_access_r | p2m_access_x,
+ p2m_access_wx = p2m_access_w | p2m_access_x,
+ p2m_access_rwx = p2m_access_r | p2m_access_w | p2m_access_x,
+
+ p2m_access_rx2rw = 8, /* Special: page goes from RX to RW on write */
+ p2m_access_n2rwx = 9, /* Special: page goes from N to RWX on access, *
+ * generates an event but does not pause the
+ * vcpu */
+
+ /* NOTE: Assumed to be only 4 bits right now on x86. */
+} p2m_access_t;
+
+/*
+ * Set access type for a region of gfns.
+ * If gfn == INVALID_GFN, sets the default access type.
+ */
+long p2m_set_mem_access(struct domain *d, gfn_t gfn, uint32_t nr,
+ uint32_t start, uint32_t mask, xenmem_access_t access,
+ unsigned int altp2m_idx);
+long p2m_set_mem_access_multi(struct domain *d,
+ const XEN_GUEST_HANDLE(const_uint64) pfn_list,
+ const XEN_GUEST_HANDLE(const_uint8) access_list,
+ uint32_t nr, uint32_t start, uint32_t mask,
+ unsigned int altp2m_idx);
+
+/*
+ * Get access type for a gfn.
+ * If gfn == INVALID_GFN, gets the default access type.
+ */
+int p2m_get_mem_access(struct domain *d, gfn_t gfn, xenmem_access_t *access);
+
+#ifdef CONFIG_HAS_MEM_ACCESS
int mem_access_memop(unsigned long cmd,
XEN_GUEST_HANDLE_PARAM(xen_mem_access_op_t) arg);
-
#else
-
static inline
int mem_access_memop(unsigned long cmd,
XEN_GUEST_HANDLE_PARAM(xen_mem_access_op_t) arg)
{
return -ENOSYS;
}
+#endif /* CONFIG_HAS_MEM_ACCESS */
-#endif /* HAS_MEM_ACCESS */
-
-#endif /* _XEN_ASM_MEM_ACCESS_H */
+#endif /* _XEN_MEM_ACCESS_H */
/*
* Local variables:
diff --git a/xen/include/xen/p2m-common.h b/xen/include/xen/p2m-common.h
index 3be1e91..8cd5a6b 100644
--- a/xen/include/xen/p2m-common.h
+++ b/xen/include/xen/p2m-common.h
@@ -1,38 +1,6 @@
#ifndef _XEN_P2M_COMMON_H
#define _XEN_P2M_COMMON_H
-#include <public/vm_event.h>
-
-/*
- * 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 vm_event
- * interface.
- *
- * The access permissions are soft state: when any ambiguous change of page
- * type or use occurs, or when pages are flushed, swapped, or at any other
- * convenient type, the access permissions can get reset to the p2m_domain
- * default.
- */
-typedef enum {
- /* Code uses bottom three bits with bitmask semantics */
- p2m_access_n = 0, /* No access allowed. */
- p2m_access_r = 1 << 0,
- p2m_access_w = 1 << 1,
- p2m_access_x = 1 << 2,
- p2m_access_rw = p2m_access_r | p2m_access_w,
- p2m_access_rx = p2m_access_r | p2m_access_x,
- p2m_access_wx = p2m_access_w | p2m_access_x,
- p2m_access_rwx = p2m_access_r | p2m_access_w | p2m_access_x,
-
- p2m_access_rx2rw = 8, /* Special: page goes from RX to RW on write */
- p2m_access_n2rwx = 9, /* Special: page goes from N to RWX on access, *
- * generates an event but does not pause the
- * vcpu */
-
- /* NOTE: Assumed to be only 4 bits right now on x86. */
-} p2m_access_t;
-
/* Map MMIO regions in the p2m: start_gfn and nr describe the range in
* * the guest physical address space to map, starting from the machine
* * frame number mfn. */
@@ -45,24 +13,4 @@ int unmap_mmio_regions(struct domain *d,
unsigned long nr,
mfn_t mfn);
-/*
- * Set access type for a region of gfns.
- * If gfn == INVALID_GFN, sets the default access type.
- */
-long p2m_set_mem_access(struct domain *d, gfn_t gfn, uint32_t nr,
- uint32_t start, uint32_t mask, xenmem_access_t access,
- unsigned int altp2m_idx);
-
-long p2m_set_mem_access_multi(struct domain *d,
- const XEN_GUEST_HANDLE(const_uint64) pfn_list,
- const XEN_GUEST_HANDLE(const_uint8) access_list,
- uint32_t nr, uint32_t start, uint32_t mask,
- unsigned int altp2m_idx);
-
-/*
- * Get access type for a gfn.
- * If gfn == INVALID_GFN, gets the default access type.
- */
-int p2m_get_mem_access(struct domain *d, gfn_t gfn, xenmem_access_t *access);
-
#endif /* _XEN_P2M_COMMON_H */
--
2.10.2
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
https://lists.xen.org/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |