2007-07-18 03:37:04 +02:00
|
|
|
/*
|
|
|
|
* Xen mmu operations
|
|
|
|
*
|
|
|
|
* This file contains the various mmu fetch and update operations.
|
|
|
|
* The most important job they must perform is the mapping between the
|
|
|
|
* domain's pfn and the overall machine mfns.
|
|
|
|
*
|
|
|
|
* Xen allows guests to directly update the pagetable, in a controlled
|
|
|
|
* fashion. In other words, the guest modifies the same pagetable
|
|
|
|
* that the CPU actually uses, which eliminates the overhead of having
|
|
|
|
* a separate shadow pagetable.
|
|
|
|
*
|
|
|
|
* In order to allow this, it falls on the guest domain to map its
|
|
|
|
* notion of a "physical" pfn - which is just a domain-local linear
|
|
|
|
* address - into a real "machine address" which the CPU's MMU can
|
|
|
|
* use.
|
|
|
|
*
|
|
|
|
* A pgd_t/pmd_t/pte_t will typically contain an mfn, and so can be
|
|
|
|
* inserted directly into the pagetable. When creating a new
|
|
|
|
* pte/pmd/pgd, it converts the passed pfn into an mfn. Conversely,
|
|
|
|
* when reading the content back with __(pgd|pmd|pte)_val, it converts
|
|
|
|
* the mfn back into a pfn.
|
|
|
|
*
|
|
|
|
* The other constraint is that all pages which make up a pagetable
|
|
|
|
* must be mapped read-only in the guest. This prevents uncontrolled
|
|
|
|
* guest updates to the pagetable. Xen strictly enforces this, and
|
|
|
|
* will disallow any pagetable update which will end up mapping a
|
|
|
|
* pagetable page RW, and will disallow using any writable page as a
|
|
|
|
* pagetable.
|
|
|
|
*
|
|
|
|
* Naively, when loading %cr3 with the base of a new pagetable, Xen
|
|
|
|
* would need to validate the whole pagetable before going on.
|
|
|
|
* Naturally, this is quite slow. The solution is to "pin" a
|
|
|
|
* pagetable, which enforces all the constraints on the pagetable even
|
|
|
|
* when it is not actively in use. This menas that Xen can be assured
|
|
|
|
* that it is still valid when you do load it into %cr3, and doesn't
|
|
|
|
* need to revalidate it.
|
|
|
|
*
|
|
|
|
* Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
|
|
|
|
*/
|
2007-07-18 03:37:06 +02:00
|
|
|
#include <linux/sched.h>
|
2007-07-18 03:37:05 +02:00
|
|
|
#include <linux/highmem.h>
|
2008-08-21 02:02:19 +02:00
|
|
|
#include <linux/debugfs.h>
|
2007-07-18 03:37:04 +02:00
|
|
|
#include <linux/bug.h>
|
|
|
|
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/tlbflush.h>
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
#include <asm/fixmap.h>
|
2007-07-18 03:37:04 +02:00
|
|
|
#include <asm/mmu_context.h>
|
2007-07-18 03:37:05 +02:00
|
|
|
#include <asm/paravirt.h>
|
2008-07-09 00:06:27 +02:00
|
|
|
#include <asm/linkage.h>
|
2007-07-18 03:37:04 +02:00
|
|
|
|
|
|
|
#include <asm/xen/hypercall.h>
|
2007-07-18 03:37:05 +02:00
|
|
|
#include <asm/xen/hypervisor.h>
|
2007-07-18 03:37:04 +02:00
|
|
|
|
|
|
|
#include <xen/page.h>
|
|
|
|
#include <xen/interface/xen.h>
|
|
|
|
|
2007-07-18 03:37:05 +02:00
|
|
|
#include "multicalls.h"
|
2007-07-18 03:37:04 +02:00
|
|
|
#include "mmu.h"
|
2008-08-21 02:02:19 +02:00
|
|
|
#include "debugfs.h"
|
|
|
|
|
|
|
|
#define MMU_UPDATE_HISTO 30
|
|
|
|
|
|
|
|
#ifdef CONFIG_XEN_DEBUG_FS
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
u32 pgd_update;
|
|
|
|
u32 pgd_update_pinned;
|
|
|
|
u32 pgd_update_batched;
|
|
|
|
|
|
|
|
u32 pud_update;
|
|
|
|
u32 pud_update_pinned;
|
|
|
|
u32 pud_update_batched;
|
|
|
|
|
|
|
|
u32 pmd_update;
|
|
|
|
u32 pmd_update_pinned;
|
|
|
|
u32 pmd_update_batched;
|
|
|
|
|
|
|
|
u32 pte_update;
|
|
|
|
u32 pte_update_pinned;
|
|
|
|
u32 pte_update_batched;
|
|
|
|
|
|
|
|
u32 mmu_update;
|
|
|
|
u32 mmu_update_extended;
|
|
|
|
u32 mmu_update_histo[MMU_UPDATE_HISTO];
|
|
|
|
|
|
|
|
u32 prot_commit;
|
|
|
|
u32 prot_commit_batched;
|
|
|
|
|
|
|
|
u32 set_pte_at;
|
|
|
|
u32 set_pte_at_batched;
|
|
|
|
u32 set_pte_at_pinned;
|
|
|
|
u32 set_pte_at_current;
|
|
|
|
u32 set_pte_at_kernel;
|
|
|
|
} mmu_stats;
|
|
|
|
|
|
|
|
static u8 zero_stats;
|
|
|
|
|
|
|
|
static inline void check_zero(void)
|
|
|
|
{
|
|
|
|
if (unlikely(zero_stats)) {
|
|
|
|
memset(&mmu_stats, 0, sizeof(mmu_stats));
|
|
|
|
zero_stats = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ADD_STATS(elem, val) \
|
|
|
|
do { check_zero(); mmu_stats.elem += (val); } while(0)
|
|
|
|
|
|
|
|
#else /* !CONFIG_XEN_DEBUG_FS */
|
|
|
|
|
|
|
|
#define ADD_STATS(elem, val) do { (void)(val); } while(0)
|
|
|
|
|
|
|
|
#endif /* CONFIG_XEN_DEBUG_FS */
|
2007-07-18 03:37:04 +02:00
|
|
|
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
/*
|
|
|
|
* Just beyond the highest usermode address. STACK_TOP_MAX has a
|
|
|
|
* redzone above it, so round it up to a PGD boundary.
|
|
|
|
*/
|
|
|
|
#define USER_LIMIT ((STACK_TOP_MAX + PGDIR_SIZE - 1) & PGDIR_MASK)
|
|
|
|
|
|
|
|
|
2008-05-27 00:31:18 +02:00
|
|
|
#define P2M_ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(unsigned long))
|
2008-05-27 00:31:20 +02:00
|
|
|
#define TOP_ENTRIES (MAX_DOMAIN_PAGES / P2M_ENTRIES_PER_PAGE)
|
2008-05-27 00:31:18 +02:00
|
|
|
|
2008-05-27 00:31:20 +02:00
|
|
|
/* Placeholder for holes in the address space */
|
2008-07-09 00:06:27 +02:00
|
|
|
static unsigned long p2m_missing[P2M_ENTRIES_PER_PAGE] __page_aligned_data =
|
2008-05-27 00:31:20 +02:00
|
|
|
{ [ 0 ... P2M_ENTRIES_PER_PAGE-1 ] = ~0UL };
|
|
|
|
|
|
|
|
/* Array of pointers to pages containing p2m entries */
|
2008-07-09 00:06:27 +02:00
|
|
|
static unsigned long *p2m_top[TOP_ENTRIES] __page_aligned_data =
|
2008-05-27 00:31:20 +02:00
|
|
|
{ [ 0 ... TOP_ENTRIES - 1] = &p2m_missing[0] };
|
2008-05-27 00:31:18 +02:00
|
|
|
|
2008-05-27 00:31:22 +02:00
|
|
|
/* Arrays of p2m arrays expressed in mfns used for save/restore */
|
2008-07-09 00:06:27 +02:00
|
|
|
static unsigned long p2m_top_mfn[TOP_ENTRIES] __page_aligned_bss;
|
2008-05-27 00:31:22 +02:00
|
|
|
|
2008-07-09 00:06:27 +02:00
|
|
|
static unsigned long p2m_top_mfn_list[TOP_ENTRIES / P2M_ENTRIES_PER_PAGE]
|
|
|
|
__page_aligned_bss;
|
2008-05-27 00:31:22 +02:00
|
|
|
|
2008-05-27 00:31:18 +02:00
|
|
|
static inline unsigned p2m_top_index(unsigned long pfn)
|
|
|
|
{
|
2008-05-27 00:31:19 +02:00
|
|
|
BUG_ON(pfn >= MAX_DOMAIN_PAGES);
|
2008-05-27 00:31:18 +02:00
|
|
|
return pfn / P2M_ENTRIES_PER_PAGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned p2m_index(unsigned long pfn)
|
|
|
|
{
|
|
|
|
return pfn % P2M_ENTRIES_PER_PAGE;
|
|
|
|
}
|
|
|
|
|
2008-05-27 00:31:22 +02:00
|
|
|
/* Build the parallel p2m_top_mfn structures */
|
|
|
|
void xen_setup_mfn_list_list(void)
|
|
|
|
{
|
|
|
|
unsigned pfn, idx;
|
|
|
|
|
2008-12-16 20:56:06 +01:00
|
|
|
for (pfn = 0; pfn < MAX_DOMAIN_PAGES; pfn += P2M_ENTRIES_PER_PAGE) {
|
2008-05-27 00:31:22 +02:00
|
|
|
unsigned topidx = p2m_top_index(pfn);
|
|
|
|
|
|
|
|
p2m_top_mfn[topidx] = virt_to_mfn(p2m_top[topidx]);
|
|
|
|
}
|
|
|
|
|
2008-12-16 20:56:06 +01:00
|
|
|
for (idx = 0; idx < ARRAY_SIZE(p2m_top_mfn_list); idx++) {
|
2008-05-27 00:31:22 +02:00
|
|
|
unsigned topidx = idx * P2M_ENTRIES_PER_PAGE;
|
|
|
|
p2m_top_mfn_list[idx] = virt_to_mfn(&p2m_top_mfn[topidx]);
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(HYPERVISOR_shared_info == &xen_dummy_shared_info);
|
|
|
|
|
|
|
|
HYPERVISOR_shared_info->arch.pfn_to_mfn_frame_list_list =
|
|
|
|
virt_to_mfn(p2m_top_mfn_list);
|
|
|
|
HYPERVISOR_shared_info->arch.max_pfn = xen_start_info->nr_pages;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set up p2m_top to point to the domain-builder provided p2m pages */
|
2008-05-27 00:31:18 +02:00
|
|
|
void __init xen_build_dynamic_phys_to_machine(void)
|
|
|
|
{
|
|
|
|
unsigned long *mfn_list = (unsigned long *)xen_start_info->mfn_list;
|
2008-05-27 00:31:19 +02:00
|
|
|
unsigned long max_pfn = min(MAX_DOMAIN_PAGES, xen_start_info->nr_pages);
|
2008-05-27 00:31:22 +02:00
|
|
|
unsigned pfn;
|
2008-05-27 00:31:18 +02:00
|
|
|
|
2008-12-16 20:56:06 +01:00
|
|
|
for (pfn = 0; pfn < max_pfn; pfn += P2M_ENTRIES_PER_PAGE) {
|
2008-05-27 00:31:18 +02:00
|
|
|
unsigned topidx = p2m_top_index(pfn);
|
|
|
|
|
|
|
|
p2m_top[topidx] = &mfn_list[pfn];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long get_phys_to_machine(unsigned long pfn)
|
|
|
|
{
|
|
|
|
unsigned topidx, idx;
|
|
|
|
|
2008-05-27 00:31:19 +02:00
|
|
|
if (unlikely(pfn >= MAX_DOMAIN_PAGES))
|
|
|
|
return INVALID_P2M_ENTRY;
|
|
|
|
|
2008-05-27 00:31:18 +02:00
|
|
|
topidx = p2m_top_index(pfn);
|
|
|
|
idx = p2m_index(pfn);
|
|
|
|
return p2m_top[topidx][idx];
|
|
|
|
}
|
2008-06-02 13:20:11 +02:00
|
|
|
EXPORT_SYMBOL_GPL(get_phys_to_machine);
|
2008-05-27 00:31:18 +02:00
|
|
|
|
2008-05-27 00:31:22 +02:00
|
|
|
static void alloc_p2m(unsigned long **pp, unsigned long *mfnp)
|
2008-05-27 00:31:18 +02:00
|
|
|
{
|
|
|
|
unsigned long *p;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
p = (void *)__get_free_page(GFP_KERNEL | __GFP_NOFAIL);
|
|
|
|
BUG_ON(p == NULL);
|
|
|
|
|
2008-12-16 20:56:06 +01:00
|
|
|
for (i = 0; i < P2M_ENTRIES_PER_PAGE; i++)
|
2008-05-27 00:31:18 +02:00
|
|
|
p[i] = INVALID_P2M_ENTRY;
|
|
|
|
|
2008-05-27 00:31:20 +02:00
|
|
|
if (cmpxchg(pp, p2m_missing, p) != p2m_missing)
|
2008-05-27 00:31:18 +02:00
|
|
|
free_page((unsigned long)p);
|
2008-05-27 00:31:22 +02:00
|
|
|
else
|
|
|
|
*mfnp = virt_to_mfn(p);
|
2008-05-27 00:31:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void set_phys_to_machine(unsigned long pfn, unsigned long mfn)
|
|
|
|
{
|
|
|
|
unsigned topidx, idx;
|
|
|
|
|
|
|
|
if (unlikely(xen_feature(XENFEAT_auto_translated_physmap))) {
|
|
|
|
BUG_ON(pfn != mfn && mfn != INVALID_P2M_ENTRY);
|
2008-05-27 00:31:19 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(pfn >= MAX_DOMAIN_PAGES)) {
|
|
|
|
BUG_ON(mfn != INVALID_P2M_ENTRY);
|
2008-05-27 00:31:18 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
topidx = p2m_top_index(pfn);
|
2008-05-27 00:31:20 +02:00
|
|
|
if (p2m_top[topidx] == p2m_missing) {
|
2008-05-27 00:31:18 +02:00
|
|
|
/* no need to allocate a page to store an invalid entry */
|
|
|
|
if (mfn == INVALID_P2M_ENTRY)
|
|
|
|
return;
|
2008-05-27 00:31:22 +02:00
|
|
|
alloc_p2m(&p2m_top[topidx], &p2m_top_mfn[topidx]);
|
2008-05-27 00:31:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
idx = p2m_index(pfn);
|
|
|
|
p2m_top[topidx][idx] = mfn;
|
|
|
|
}
|
|
|
|
|
2008-07-09 00:06:55 +02:00
|
|
|
xmaddr_t arbitrary_virt_to_machine(void *vaddr)
|
2007-07-18 03:37:04 +02:00
|
|
|
{
|
2008-07-09 00:06:55 +02:00
|
|
|
unsigned long address = (unsigned long)vaddr;
|
2008-02-09 23:24:08 +01:00
|
|
|
unsigned int level;
|
xen: fix Xen domU boot with batched mprotect
Impact: fix guest kernel boot crash on certain configs
Recent i686 2.6.27 kernels with a certain amount of memory (between
736 and 855MB) have a problem booting under a hypervisor that supports
batched mprotect (this includes the RHEL-5 Xen hypervisor as well as
any 3.3 or later Xen hypervisor).
The problem ends up being that xen_ptep_modify_prot_commit() is using
virt_to_machine to calculate which pfn to update. However, this only
works for pages that are in the p2m list, and the pages coming from
change_pte_range() in mm/mprotect.c are kmap_atomic pages. Because of
this, we can run into the situation where the lookup in the p2m table
returns an INVALID_MFN, which we then try to pass to the hypervisor,
which then (correctly) denies the request to a totally bogus pfn.
The right thing to do is to use arbitrary_virt_to_machine, so that we
can be sure we are modifying the right pfn. This unfortunately
introduces a performance penalty because of a full page-table-walk,
but we can avoid that penalty for pages in the p2m list by checking if
virt_addr_valid is true, and if so, just doing the lookup in the p2m
table.
The attached patch implements this, and allows my 2.6.27 i686 based
guest with 768MB of memory to boot on a RHEL-5 hypervisor again.
Thanks to Jeremy for the suggestions about how to fix this particular
issue.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Chris Lalancette <clalance@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-10-24 02:40:25 +02:00
|
|
|
pte_t *pte;
|
|
|
|
unsigned offset;
|
2007-07-18 03:37:04 +02:00
|
|
|
|
xen: fix Xen domU boot with batched mprotect
Impact: fix guest kernel boot crash on certain configs
Recent i686 2.6.27 kernels with a certain amount of memory (between
736 and 855MB) have a problem booting under a hypervisor that supports
batched mprotect (this includes the RHEL-5 Xen hypervisor as well as
any 3.3 or later Xen hypervisor).
The problem ends up being that xen_ptep_modify_prot_commit() is using
virt_to_machine to calculate which pfn to update. However, this only
works for pages that are in the p2m list, and the pages coming from
change_pte_range() in mm/mprotect.c are kmap_atomic pages. Because of
this, we can run into the situation where the lookup in the p2m table
returns an INVALID_MFN, which we then try to pass to the hypervisor,
which then (correctly) denies the request to a totally bogus pfn.
The right thing to do is to use arbitrary_virt_to_machine, so that we
can be sure we are modifying the right pfn. This unfortunately
introduces a performance penalty because of a full page-table-walk,
but we can avoid that penalty for pages in the p2m list by checking if
virt_addr_valid is true, and if so, just doing the lookup in the p2m
table.
The attached patch implements this, and allows my 2.6.27 i686 based
guest with 768MB of memory to boot on a RHEL-5 hypervisor again.
Thanks to Jeremy for the suggestions about how to fix this particular
issue.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Chris Lalancette <clalance@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-10-24 02:40:25 +02:00
|
|
|
/*
|
|
|
|
* if the PFN is in the linear mapped vaddr range, we can just use
|
|
|
|
* the (quick) virt_to_machine() p2m lookup
|
|
|
|
*/
|
|
|
|
if (virt_addr_valid(vaddr))
|
|
|
|
return virt_to_machine(vaddr);
|
|
|
|
|
|
|
|
/* otherwise we have to do a (slower) full page-table walk */
|
2007-07-18 03:37:04 +02:00
|
|
|
|
xen: fix Xen domU boot with batched mprotect
Impact: fix guest kernel boot crash on certain configs
Recent i686 2.6.27 kernels with a certain amount of memory (between
736 and 855MB) have a problem booting under a hypervisor that supports
batched mprotect (this includes the RHEL-5 Xen hypervisor as well as
any 3.3 or later Xen hypervisor).
The problem ends up being that xen_ptep_modify_prot_commit() is using
virt_to_machine to calculate which pfn to update. However, this only
works for pages that are in the p2m list, and the pages coming from
change_pte_range() in mm/mprotect.c are kmap_atomic pages. Because of
this, we can run into the situation where the lookup in the p2m table
returns an INVALID_MFN, which we then try to pass to the hypervisor,
which then (correctly) denies the request to a totally bogus pfn.
The right thing to do is to use arbitrary_virt_to_machine, so that we
can be sure we are modifying the right pfn. This unfortunately
introduces a performance penalty because of a full page-table-walk,
but we can avoid that penalty for pages in the p2m list by checking if
virt_addr_valid is true, and if so, just doing the lookup in the p2m
table.
The attached patch implements this, and allows my 2.6.27 i686 based
guest with 768MB of memory to boot on a RHEL-5 hypervisor again.
Thanks to Jeremy for the suggestions about how to fix this particular
issue.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Chris Lalancette <clalance@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-10-24 02:40:25 +02:00
|
|
|
pte = lookup_address(address, &level);
|
|
|
|
BUG_ON(pte == NULL);
|
|
|
|
offset = address & ~PAGE_MASK;
|
2008-07-09 00:06:54 +02:00
|
|
|
return XMADDR(((phys_addr_t)pte_mfn(*pte) << PAGE_SHIFT) + offset);
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void make_lowmem_page_readonly(void *vaddr)
|
|
|
|
{
|
|
|
|
pte_t *pte, ptev;
|
|
|
|
unsigned long address = (unsigned long)vaddr;
|
2008-02-09 23:24:08 +01:00
|
|
|
unsigned int level;
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2008-01-30 13:33:43 +01:00
|
|
|
pte = lookup_address(address, &level);
|
2007-07-18 03:37:04 +02:00
|
|
|
BUG_ON(pte == NULL);
|
|
|
|
|
|
|
|
ptev = pte_wrprotect(*pte);
|
|
|
|
|
|
|
|
if (HYPERVISOR_update_va_mapping(address, ptev, 0))
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
void make_lowmem_page_readwrite(void *vaddr)
|
|
|
|
{
|
|
|
|
pte_t *pte, ptev;
|
|
|
|
unsigned long address = (unsigned long)vaddr;
|
2008-02-09 23:24:08 +01:00
|
|
|
unsigned int level;
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2008-01-30 13:33:43 +01:00
|
|
|
pte = lookup_address(address, &level);
|
2007-07-18 03:37:04 +02:00
|
|
|
BUG_ON(pte == NULL);
|
|
|
|
|
|
|
|
ptev = pte_mkwrite(*pte);
|
|
|
|
|
|
|
|
if (HYPERVISOR_update_va_mapping(address, ptev, 0))
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-08-19 22:34:22 +02:00
|
|
|
static bool xen_page_pinned(void *ptr)
|
2008-05-31 02:24:27 +02:00
|
|
|
{
|
|
|
|
struct page *page = virt_to_page(ptr);
|
|
|
|
|
|
|
|
return PagePinned(page);
|
|
|
|
}
|
|
|
|
|
2008-08-19 22:34:22 +02:00
|
|
|
static void xen_extend_mmu_update(const struct mmu_update *update)
|
2007-07-18 03:37:04 +02:00
|
|
|
{
|
2007-07-18 03:37:06 +02:00
|
|
|
struct multicall_space mcs;
|
|
|
|
struct mmu_update *u;
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2008-06-16 13:30:03 +02:00
|
|
|
mcs = xen_mc_extend_args(__HYPERVISOR_mmu_update, sizeof(*u));
|
|
|
|
|
2008-08-21 02:02:19 +02:00
|
|
|
if (mcs.mc != NULL) {
|
|
|
|
ADD_STATS(mmu_update_extended, 1);
|
|
|
|
ADD_STATS(mmu_update_histo[mcs.mc->args[1]], -1);
|
|
|
|
|
2008-06-16 13:30:03 +02:00
|
|
|
mcs.mc->args[1]++;
|
2008-08-21 02:02:19 +02:00
|
|
|
|
|
|
|
if (mcs.mc->args[1] < MMU_UPDATE_HISTO)
|
|
|
|
ADD_STATS(mmu_update_histo[mcs.mc->args[1]], 1);
|
|
|
|
else
|
|
|
|
ADD_STATS(mmu_update_histo[0], 1);
|
|
|
|
} else {
|
|
|
|
ADD_STATS(mmu_update, 1);
|
2008-06-16 13:30:03 +02:00
|
|
|
mcs = __xen_mc_entry(sizeof(*u));
|
|
|
|
MULTI_mmu_update(mcs.mc, mcs.args, 1, NULL, DOMID_SELF);
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(mmu_update_histo[1], 1);
|
2008-06-16 13:30:03 +02:00
|
|
|
}
|
2007-07-18 03:37:06 +02:00
|
|
|
|
|
|
|
u = mcs.args;
|
2008-06-16 13:30:03 +02:00
|
|
|
*u = *update;
|
|
|
|
}
|
|
|
|
|
|
|
|
void xen_set_pmd_hyper(pmd_t *ptr, pmd_t val)
|
|
|
|
{
|
|
|
|
struct mmu_update u;
|
|
|
|
|
|
|
|
preempt_disable();
|
|
|
|
|
|
|
|
xen_mc_batch();
|
|
|
|
|
2008-07-09 00:06:55 +02:00
|
|
|
/* ptr may be ioremapped for 64-bit pagetable setup */
|
|
|
|
u.ptr = arbitrary_virt_to_machine(ptr).maddr;
|
2008-06-16 13:30:03 +02:00
|
|
|
u.val = pmd_val_ma(val);
|
2008-08-19 22:34:22 +02:00
|
|
|
xen_extend_mmu_update(&u);
|
2007-07-18 03:37:06 +02:00
|
|
|
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(pmd_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);
|
|
|
|
|
2007-07-18 03:37:06 +02:00
|
|
|
xen_mc_issue(PARAVIRT_LAZY_MMU);
|
|
|
|
|
|
|
|
preempt_enable();
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
2008-05-31 02:24:27 +02:00
|
|
|
void xen_set_pmd(pmd_t *ptr, pmd_t val)
|
|
|
|
{
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(pmd_update, 1);
|
|
|
|
|
2008-05-31 02:24:27 +02:00
|
|
|
/* If page is not pinned, we can just update the entry
|
|
|
|
directly */
|
2008-08-19 22:34:22 +02:00
|
|
|
if (!xen_page_pinned(ptr)) {
|
2008-05-31 02:24:27 +02:00
|
|
|
*ptr = val;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(pmd_update_pinned, 1);
|
|
|
|
|
2008-05-31 02:24:27 +02:00
|
|
|
xen_set_pmd_hyper(ptr, val);
|
|
|
|
}
|
|
|
|
|
2007-07-18 03:37:04 +02:00
|
|
|
/*
|
|
|
|
* Associate a virtual page frame with a given physical page frame
|
|
|
|
* and protection flags for that frame.
|
|
|
|
*/
|
|
|
|
void set_pte_mfn(unsigned long vaddr, unsigned long mfn, pgprot_t flags)
|
|
|
|
{
|
2008-07-09 00:06:58 +02:00
|
|
|
set_pte_vaddr(vaddr, mfn_pte(mfn, flags));
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep, pte_t pteval)
|
|
|
|
{
|
2008-04-02 19:54:10 +02:00
|
|
|
/* updates to init_mm may be done without lock */
|
|
|
|
if (mm == &init_mm)
|
|
|
|
preempt_disable();
|
|
|
|
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(set_pte_at, 1);
|
|
|
|
// ADD_STATS(set_pte_at_pinned, xen_page_pinned(ptep));
|
|
|
|
ADD_STATS(set_pte_at_current, mm == current->mm);
|
|
|
|
ADD_STATS(set_pte_at_kernel, mm == &init_mm);
|
|
|
|
|
2007-07-18 03:37:06 +02:00
|
|
|
if (mm == current->mm || mm == &init_mm) {
|
paravirt: clean up lazy mode handling
Currently, the set_lazy_mode pv_op is overloaded with 5 functions:
1. enter lazy cpu mode
2. leave lazy cpu mode
3. enter lazy mmu mode
4. leave lazy mmu mode
5. flush pending batched operations
This complicates each paravirt backend, since it needs to deal with
all the possible state transitions, handling flushing, etc. In
particular, flushing is quite distinct from the other 4 functions, and
seems to just cause complication.
This patch removes the set_lazy_mode operation, and adds "enter" and
"leave" lazy mode operations on mmu_ops and cpu_ops. All the logic
associated with enter and leaving lazy states is now in common code
(basically BUG_ONs to make sure that no mode is current when entering
a lazy mode, and make sure that the mode is current when leaving).
Also, flush is handled in a common way, by simply leaving and
re-entering the lazy mode.
The result is that the Xen, lguest and VMI lazy mode implementations
are much simpler.
Signed-off-by: Jeremy Fitzhardinge <jeremy@xensource.com>
Cc: Andi Kleen <ak@suse.de>
Cc: Zach Amsden <zach@vmware.com>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Avi Kivity <avi@qumranet.com>
Cc: Anthony Liguory <aliguori@us.ibm.com>
Cc: "Glauber de Oliveira Costa" <glommer@gmail.com>
Cc: Jun Nakajima <jun.nakajima@intel.com>
2007-10-16 20:51:29 +02:00
|
|
|
if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
|
2007-07-18 03:37:06 +02:00
|
|
|
struct multicall_space mcs;
|
|
|
|
mcs = xen_mc_entry(0);
|
|
|
|
|
|
|
|
MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(set_pte_at_batched, 1);
|
2007-07-18 03:37:06 +02:00
|
|
|
xen_mc_issue(PARAVIRT_LAZY_MMU);
|
2008-04-02 19:54:10 +02:00
|
|
|
goto out;
|
2007-07-18 03:37:06 +02:00
|
|
|
} else
|
|
|
|
if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)
|
2008-04-02 19:54:10 +02:00
|
|
|
goto out;
|
2007-07-18 03:37:06 +02:00
|
|
|
}
|
|
|
|
xen_set_pte(ptep, pteval);
|
2008-04-02 19:54:10 +02:00
|
|
|
|
|
|
|
out:
|
|
|
|
if (mm == &init_mm)
|
|
|
|
preempt_enable();
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
2008-12-16 20:56:06 +01:00
|
|
|
pte_t xen_ptep_modify_prot_start(struct mm_struct *mm,
|
|
|
|
unsigned long addr, pte_t *ptep)
|
2008-03-18 00:37:09 +01:00
|
|
|
{
|
2008-06-16 13:30:02 +02:00
|
|
|
/* Just return the pte as-is. We preserve the bits on commit */
|
|
|
|
return *ptep;
|
|
|
|
}
|
|
|
|
|
|
|
|
void xen_ptep_modify_prot_commit(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pte_t *ptep, pte_t pte)
|
|
|
|
{
|
2008-06-16 13:30:03 +02:00
|
|
|
struct mmu_update u;
|
2008-06-16 13:30:02 +02:00
|
|
|
|
2008-06-16 13:30:03 +02:00
|
|
|
xen_mc_batch();
|
2008-03-18 00:37:09 +01:00
|
|
|
|
xen: fix Xen domU boot with batched mprotect
Impact: fix guest kernel boot crash on certain configs
Recent i686 2.6.27 kernels with a certain amount of memory (between
736 and 855MB) have a problem booting under a hypervisor that supports
batched mprotect (this includes the RHEL-5 Xen hypervisor as well as
any 3.3 or later Xen hypervisor).
The problem ends up being that xen_ptep_modify_prot_commit() is using
virt_to_machine to calculate which pfn to update. However, this only
works for pages that are in the p2m list, and the pages coming from
change_pte_range() in mm/mprotect.c are kmap_atomic pages. Because of
this, we can run into the situation where the lookup in the p2m table
returns an INVALID_MFN, which we then try to pass to the hypervisor,
which then (correctly) denies the request to a totally bogus pfn.
The right thing to do is to use arbitrary_virt_to_machine, so that we
can be sure we are modifying the right pfn. This unfortunately
introduces a performance penalty because of a full page-table-walk,
but we can avoid that penalty for pages in the p2m list by checking if
virt_addr_valid is true, and if so, just doing the lookup in the p2m
table.
The attached patch implements this, and allows my 2.6.27 i686 based
guest with 768MB of memory to boot on a RHEL-5 hypervisor again.
Thanks to Jeremy for the suggestions about how to fix this particular
issue.
Signed-off-by: Chris Lalancette <clalance@redhat.com>
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Chris Lalancette <clalance@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-10-24 02:40:25 +02:00
|
|
|
u.ptr = arbitrary_virt_to_machine(ptep).maddr | MMU_PT_UPDATE_PRESERVE_AD;
|
2008-06-16 13:30:03 +02:00
|
|
|
u.val = pte_val_ma(pte);
|
2008-08-19 22:34:22 +02:00
|
|
|
xen_extend_mmu_update(&u);
|
2008-03-18 00:37:09 +01:00
|
|
|
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(prot_commit, 1);
|
|
|
|
ADD_STATS(prot_commit_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);
|
|
|
|
|
2008-06-16 13:30:02 +02:00
|
|
|
xen_mc_issue(PARAVIRT_LAZY_MMU);
|
2008-03-18 00:37:09 +01:00
|
|
|
}
|
|
|
|
|
2008-06-17 00:01:56 +02:00
|
|
|
/* Assume pteval_t is equivalent to all the other *val_t types. */
|
|
|
|
static pteval_t pte_mfn_to_pfn(pteval_t val)
|
2008-03-18 00:37:09 +01:00
|
|
|
{
|
2008-06-17 00:01:56 +02:00
|
|
|
if (val & _PAGE_PRESENT) {
|
2008-07-22 07:59:42 +02:00
|
|
|
unsigned long mfn = (val & PTE_PFN_MASK) >> PAGE_SHIFT;
|
2008-07-22 07:59:56 +02:00
|
|
|
pteval_t flags = val & PTE_FLAGS_MASK;
|
2008-07-04 07:10:18 +02:00
|
|
|
val = ((pteval_t)mfn_to_pfn(mfn) << PAGE_SHIFT) | flags;
|
2008-06-17 00:01:56 +02:00
|
|
|
}
|
2008-03-18 00:37:09 +01:00
|
|
|
|
2008-06-17 00:01:56 +02:00
|
|
|
return val;
|
2008-03-18 00:37:09 +01:00
|
|
|
}
|
|
|
|
|
2008-06-17 00:01:56 +02:00
|
|
|
static pteval_t pte_pfn_to_mfn(pteval_t val)
|
2008-03-18 00:37:09 +01:00
|
|
|
{
|
2008-06-17 00:01:56 +02:00
|
|
|
if (val & _PAGE_PRESENT) {
|
2008-07-22 07:59:42 +02:00
|
|
|
unsigned long pfn = (val & PTE_PFN_MASK) >> PAGE_SHIFT;
|
2008-07-22 07:59:56 +02:00
|
|
|
pteval_t flags = val & PTE_FLAGS_MASK;
|
2008-07-04 07:10:18 +02:00
|
|
|
val = ((pteval_t)pfn_to_mfn(pfn) << PAGE_SHIFT) | flags;
|
2008-03-18 00:37:09 +01:00
|
|
|
}
|
|
|
|
|
2008-06-17 00:01:56 +02:00
|
|
|
return val;
|
2008-03-18 00:37:09 +01:00
|
|
|
}
|
|
|
|
|
2008-06-17 00:01:56 +02:00
|
|
|
pteval_t xen_pte_val(pte_t pte)
|
2008-03-18 00:37:09 +01:00
|
|
|
{
|
2008-06-17 00:01:56 +02:00
|
|
|
return pte_mfn_to_pfn(pte.pte);
|
2008-03-18 00:37:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pgdval_t xen_pgd_val(pgd_t pgd)
|
|
|
|
{
|
2008-06-17 00:01:56 +02:00
|
|
|
return pte_mfn_to_pfn(pgd.pgd);
|
2008-03-18 00:37:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pte_t xen_make_pte(pteval_t pte)
|
|
|
|
{
|
2008-06-17 00:01:56 +02:00
|
|
|
pte = pte_pfn_to_mfn(pte);
|
|
|
|
return native_make_pte(pte);
|
2008-03-18 00:37:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pgd_t xen_make_pgd(pgdval_t pgd)
|
|
|
|
{
|
2008-06-17 00:01:56 +02:00
|
|
|
pgd = pte_pfn_to_mfn(pgd);
|
|
|
|
return native_make_pgd(pgd);
|
2008-03-18 00:37:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pmdval_t xen_pmd_val(pmd_t pmd)
|
|
|
|
{
|
2008-06-17 00:01:56 +02:00
|
|
|
return pte_mfn_to_pfn(pmd.pmd);
|
2008-03-18 00:37:09 +01:00
|
|
|
}
|
2008-05-09 13:05:57 +02:00
|
|
|
|
2008-05-31 02:24:27 +02:00
|
|
|
void xen_set_pud_hyper(pud_t *ptr, pud_t val)
|
2007-07-18 03:37:05 +02:00
|
|
|
{
|
2008-06-16 13:30:03 +02:00
|
|
|
struct mmu_update u;
|
2007-07-18 03:37:05 +02:00
|
|
|
|
2007-07-18 03:37:06 +02:00
|
|
|
preempt_disable();
|
|
|
|
|
2008-06-16 13:30:03 +02:00
|
|
|
xen_mc_batch();
|
|
|
|
|
2008-07-09 00:06:55 +02:00
|
|
|
/* ptr may be ioremapped for 64-bit pagetable setup */
|
|
|
|
u.ptr = arbitrary_virt_to_machine(ptr).maddr;
|
2008-06-16 13:30:03 +02:00
|
|
|
u.val = pud_val_ma(val);
|
2008-08-19 22:34:22 +02:00
|
|
|
xen_extend_mmu_update(&u);
|
2007-07-18 03:37:06 +02:00
|
|
|
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(pud_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);
|
|
|
|
|
2007-07-18 03:37:06 +02:00
|
|
|
xen_mc_issue(PARAVIRT_LAZY_MMU);
|
|
|
|
|
|
|
|
preempt_enable();
|
2007-07-18 03:37:05 +02:00
|
|
|
}
|
|
|
|
|
2008-05-31 02:24:27 +02:00
|
|
|
void xen_set_pud(pud_t *ptr, pud_t val)
|
|
|
|
{
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(pud_update, 1);
|
|
|
|
|
2008-05-31 02:24:27 +02:00
|
|
|
/* If page is not pinned, we can just update the entry
|
|
|
|
directly */
|
2008-08-19 22:34:22 +02:00
|
|
|
if (!xen_page_pinned(ptr)) {
|
2008-05-31 02:24:27 +02:00
|
|
|
*ptr = val;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(pud_update_pinned, 1);
|
|
|
|
|
2008-05-31 02:24:27 +02:00
|
|
|
xen_set_pud_hyper(ptr, val);
|
|
|
|
}
|
|
|
|
|
2007-07-18 03:37:05 +02:00
|
|
|
void xen_set_pte(pte_t *ptep, pte_t pte)
|
|
|
|
{
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(pte_update, 1);
|
|
|
|
// ADD_STATS(pte_update_pinned, xen_page_pinned(ptep));
|
|
|
|
ADD_STATS(pte_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);
|
|
|
|
|
2008-07-09 00:06:38 +02:00
|
|
|
#ifdef CONFIG_X86_PAE
|
2007-07-18 03:37:05 +02:00
|
|
|
ptep->pte_high = pte.pte_high;
|
|
|
|
smp_wmb();
|
|
|
|
ptep->pte_low = pte.pte_low;
|
2008-07-09 00:06:38 +02:00
|
|
|
#else
|
|
|
|
*ptep = pte;
|
|
|
|
#endif
|
2007-07-18 03:37:05 +02:00
|
|
|
}
|
|
|
|
|
2008-07-09 00:06:38 +02:00
|
|
|
#ifdef CONFIG_X86_PAE
|
2007-07-18 03:37:04 +02:00
|
|
|
void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
|
|
|
|
{
|
2008-07-09 00:06:38 +02:00
|
|
|
set_64bit((u64 *)ptep, native_pte_val(pte));
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void xen_pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
|
|
|
|
{
|
|
|
|
ptep->pte_low = 0;
|
|
|
|
smp_wmb(); /* make sure low gets written first */
|
|
|
|
ptep->pte_high = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void xen_pmd_clear(pmd_t *pmdp)
|
|
|
|
{
|
2008-05-31 02:24:27 +02:00
|
|
|
set_pmd(pmdp, __pmd(0));
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
2008-07-09 00:06:38 +02:00
|
|
|
#endif /* CONFIG_X86_PAE */
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2008-03-18 00:37:07 +01:00
|
|
|
pmd_t xen_make_pmd(pmdval_t pmd)
|
2007-07-18 03:37:04 +02:00
|
|
|
{
|
2008-06-17 00:01:56 +02:00
|
|
|
pmd = pte_pfn_to_mfn(pmd);
|
2008-03-18 00:37:09 +01:00
|
|
|
return native_make_pmd(pmd);
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
2008-07-09 00:06:38 +02:00
|
|
|
#if PAGETABLE_LEVELS == 4
|
|
|
|
pudval_t xen_pud_val(pud_t pud)
|
|
|
|
{
|
|
|
|
return pte_mfn_to_pfn(pud.pud);
|
|
|
|
}
|
|
|
|
|
|
|
|
pud_t xen_make_pud(pudval_t pud)
|
|
|
|
{
|
|
|
|
pud = pte_pfn_to_mfn(pud);
|
|
|
|
|
|
|
|
return native_make_pud(pud);
|
|
|
|
}
|
|
|
|
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
pgd_t *xen_get_user_pgd(pgd_t *pgd)
|
2008-07-09 00:06:38 +02:00
|
|
|
{
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
pgd_t *pgd_page = (pgd_t *)(((unsigned long)pgd) & PAGE_MASK);
|
|
|
|
unsigned offset = pgd - pgd_page;
|
|
|
|
pgd_t *user_ptr = NULL;
|
2008-07-09 00:06:38 +02:00
|
|
|
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
if (offset < pgd_index(USER_LIMIT)) {
|
|
|
|
struct page *page = virt_to_page(pgd_page);
|
|
|
|
user_ptr = (pgd_t *)page->private;
|
|
|
|
if (user_ptr)
|
|
|
|
user_ptr += offset;
|
|
|
|
}
|
2008-07-09 00:06:38 +02:00
|
|
|
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
return user_ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __xen_set_pgd_hyper(pgd_t *ptr, pgd_t val)
|
|
|
|
{
|
|
|
|
struct mmu_update u;
|
2008-07-09 00:06:38 +02:00
|
|
|
|
|
|
|
u.ptr = virt_to_machine(ptr).maddr;
|
|
|
|
u.val = pgd_val_ma(val);
|
2008-08-19 22:34:22 +02:00
|
|
|
xen_extend_mmu_update(&u);
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Raw hypercall-based set_pgd, intended for in early boot before
|
|
|
|
* there's a page structure. This implies:
|
|
|
|
* 1. The only existing pagetable is the kernel's
|
|
|
|
* 2. It is always pinned
|
|
|
|
* 3. It has no user pagetable attached to it
|
|
|
|
*/
|
|
|
|
void __init xen_set_pgd_hyper(pgd_t *ptr, pgd_t val)
|
|
|
|
{
|
|
|
|
preempt_disable();
|
|
|
|
|
|
|
|
xen_mc_batch();
|
|
|
|
|
|
|
|
__xen_set_pgd_hyper(ptr, val);
|
2008-07-09 00:06:38 +02:00
|
|
|
|
|
|
|
xen_mc_issue(PARAVIRT_LAZY_MMU);
|
|
|
|
|
|
|
|
preempt_enable();
|
|
|
|
}
|
|
|
|
|
|
|
|
void xen_set_pgd(pgd_t *ptr, pgd_t val)
|
|
|
|
{
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
pgd_t *user_ptr = xen_get_user_pgd(ptr);
|
|
|
|
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(pgd_update, 1);
|
|
|
|
|
2008-07-09 00:06:38 +02:00
|
|
|
/* If page is not pinned, we can just update the entry
|
|
|
|
directly */
|
2008-08-19 22:34:22 +02:00
|
|
|
if (!xen_page_pinned(ptr)) {
|
2008-07-09 00:06:38 +02:00
|
|
|
*ptr = val;
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
if (user_ptr) {
|
2008-08-19 22:34:22 +02:00
|
|
|
WARN_ON(xen_page_pinned(user_ptr));
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
*user_ptr = val;
|
|
|
|
}
|
2008-07-09 00:06:38 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-08-21 02:02:19 +02:00
|
|
|
ADD_STATS(pgd_update_pinned, 1);
|
|
|
|
ADD_STATS(pgd_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);
|
|
|
|
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
/* If it's pinned, then we can at least batch the kernel and
|
|
|
|
user updates together. */
|
|
|
|
xen_mc_batch();
|
|
|
|
|
|
|
|
__xen_set_pgd_hyper(ptr, val);
|
|
|
|
if (user_ptr)
|
|
|
|
__xen_set_pgd_hyper(user_ptr, val);
|
|
|
|
|
|
|
|
xen_mc_issue(PARAVIRT_LAZY_MMU);
|
2008-07-09 00:06:38 +02:00
|
|
|
}
|
|
|
|
#endif /* PAGETABLE_LEVELS == 4 */
|
|
|
|
|
2007-07-18 03:37:05 +02:00
|
|
|
/*
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
* (Yet another) pagetable walker. This one is intended for pinning a
|
|
|
|
* pagetable. This means that it walks a pagetable and calls the
|
|
|
|
* callback function on each page it finds making up the page table,
|
|
|
|
* at every level. It walks the entire pagetable, but it only bothers
|
|
|
|
* pinning pte pages which are below limit. In the normal case this
|
|
|
|
* will be STACK_TOP_MAX, but at boot we need to pin up to
|
|
|
|
* FIXADDR_TOP.
|
|
|
|
*
|
|
|
|
* For 32-bit the important bit is that we don't pin beyond there,
|
|
|
|
* because then we start getting into Xen's ptes.
|
|
|
|
*
|
|
|
|
* For 64-bit, we must skip the Xen hole in the middle of the address
|
|
|
|
* space, just after the big x86-64 virtual hole.
|
|
|
|
*/
|
2008-11-21 11:21:33 +01:00
|
|
|
static int __xen_pgd_walk(struct mm_struct *mm, pgd_t *pgd,
|
|
|
|
int (*func)(struct mm_struct *mm, struct page *,
|
|
|
|
enum pt_level),
|
|
|
|
unsigned long limit)
|
2007-07-18 03:37:04 +02:00
|
|
|
{
|
2007-07-18 03:37:05 +02:00
|
|
|
int flush = 0;
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
unsigned hole_low, hole_high;
|
|
|
|
unsigned pgdidx_limit, pudidx_limit, pmdidx_limit;
|
|
|
|
unsigned pgdidx, pudidx, pmdidx;
|
2007-07-18 03:37:05 +02:00
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
/* The limit is the last byte to be touched */
|
|
|
|
limit--;
|
|
|
|
BUG_ON(limit >= FIXADDR_TOP);
|
2007-07-18 03:37:04 +02:00
|
|
|
|
|
|
|
if (xen_feature(XENFEAT_auto_translated_physmap))
|
2007-07-18 03:37:05 +02:00
|
|
|
return 0;
|
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
/*
|
|
|
|
* 64-bit has a great big hole in the middle of the address
|
|
|
|
* space, which contains the Xen mappings. On 32-bit these
|
|
|
|
* will end up making a zero-sized hole and so is a no-op.
|
|
|
|
*/
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
hole_low = pgd_index(USER_LIMIT);
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
hole_high = pgd_index(PAGE_OFFSET);
|
|
|
|
|
|
|
|
pgdidx_limit = pgd_index(limit);
|
|
|
|
#if PTRS_PER_PUD > 1
|
|
|
|
pudidx_limit = pud_index(limit);
|
|
|
|
#else
|
|
|
|
pudidx_limit = 0;
|
|
|
|
#endif
|
|
|
|
#if PTRS_PER_PMD > 1
|
|
|
|
pmdidx_limit = pmd_index(limit);
|
|
|
|
#else
|
|
|
|
pmdidx_limit = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
for (pgdidx = 0; pgdidx <= pgdidx_limit; pgdidx++) {
|
2007-07-18 03:37:05 +02:00
|
|
|
pud_t *pud;
|
2007-07-18 03:37:04 +02:00
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
if (pgdidx >= hole_low && pgdidx < hole_high)
|
|
|
|
continue;
|
2007-07-18 03:37:05 +02:00
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
if (!pgd_val(pgd[pgdidx]))
|
2007-07-18 03:37:04 +02:00
|
|
|
continue;
|
2007-07-18 03:37:05 +02:00
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
pud = pud_offset(&pgd[pgdidx], 0);
|
2007-07-18 03:37:04 +02:00
|
|
|
|
|
|
|
if (PTRS_PER_PUD > 1) /* not folded */
|
2008-10-08 22:01:39 +02:00
|
|
|
flush |= (*func)(mm, virt_to_page(pud), PT_PUD);
|
2007-07-18 03:37:05 +02:00
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
for (pudidx = 0; pudidx < PTRS_PER_PUD; pudidx++) {
|
2007-07-18 03:37:05 +02:00
|
|
|
pmd_t *pmd;
|
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
if (pgdidx == pgdidx_limit &&
|
|
|
|
pudidx > pudidx_limit)
|
|
|
|
goto out;
|
2007-07-18 03:37:04 +02:00
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
if (pud_none(pud[pudidx]))
|
2007-07-18 03:37:04 +02:00
|
|
|
continue;
|
2007-07-18 03:37:05 +02:00
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
pmd = pmd_offset(&pud[pudidx], 0);
|
2007-07-18 03:37:04 +02:00
|
|
|
|
|
|
|
if (PTRS_PER_PMD > 1) /* not folded */
|
2008-10-08 22:01:39 +02:00
|
|
|
flush |= (*func)(mm, virt_to_page(pmd), PT_PMD);
|
2007-07-18 03:37:05 +02:00
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
for (pmdidx = 0; pmdidx < PTRS_PER_PMD; pmdidx++) {
|
|
|
|
struct page *pte;
|
|
|
|
|
|
|
|
if (pgdidx == pgdidx_limit &&
|
|
|
|
pudidx == pudidx_limit &&
|
|
|
|
pmdidx > pmdidx_limit)
|
|
|
|
goto out;
|
2007-07-18 03:37:04 +02:00
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
if (pmd_none(pmd[pmdidx]))
|
2007-07-18 03:37:04 +02:00
|
|
|
continue;
|
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
pte = pmd_page(pmd[pmdidx]);
|
2008-10-08 22:01:39 +02:00
|
|
|
flush |= (*func)(mm, pte, PT_PTE);
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-08-19 22:32:51 +02:00
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
out:
|
2008-08-19 22:32:51 +02:00
|
|
|
/* Do the top level last, so that the callbacks can use it as
|
|
|
|
a cue to do final things like tlb flushes. */
|
2008-10-08 22:01:39 +02:00
|
|
|
flush |= (*func)(mm, virt_to_page(pgd), PT_PGD);
|
2007-07-18 03:37:05 +02:00
|
|
|
|
|
|
|
return flush;
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
2008-11-21 11:21:33 +01:00
|
|
|
static int xen_pgd_walk(struct mm_struct *mm,
|
|
|
|
int (*func)(struct mm_struct *mm, struct page *,
|
|
|
|
enum pt_level),
|
|
|
|
unsigned long limit)
|
|
|
|
{
|
|
|
|
return __xen_pgd_walk(mm, mm->pgd, func, limit);
|
|
|
|
}
|
|
|
|
|
2008-08-19 22:34:22 +02:00
|
|
|
/* If we're using split pte locks, then take the page's lock and
|
|
|
|
return a pointer to it. Otherwise return NULL. */
|
2008-10-08 22:01:39 +02:00
|
|
|
static spinlock_t *xen_pte_lock(struct page *page, struct mm_struct *mm)
|
2007-10-16 20:51:30 +02:00
|
|
|
{
|
|
|
|
spinlock_t *ptl = NULL;
|
|
|
|
|
2008-09-10 00:43:22 +02:00
|
|
|
#if USE_SPLIT_PTLOCKS
|
2007-10-16 20:51:30 +02:00
|
|
|
ptl = __pte_lockptr(page);
|
2008-10-08 22:01:39 +02:00
|
|
|
spin_lock_nest_lock(ptl, &mm->page_table_lock);
|
2007-10-16 20:51:30 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
return ptl;
|
|
|
|
}
|
|
|
|
|
2008-08-19 22:34:22 +02:00
|
|
|
static void xen_pte_unlock(void *v)
|
2007-10-16 20:51:30 +02:00
|
|
|
{
|
|
|
|
spinlock_t *ptl = v;
|
|
|
|
spin_unlock(ptl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void xen_do_pin(unsigned level, unsigned long pfn)
|
|
|
|
{
|
|
|
|
struct mmuext_op *op;
|
|
|
|
struct multicall_space mcs;
|
|
|
|
|
|
|
|
mcs = __xen_mc_entry(sizeof(*op));
|
|
|
|
op = mcs.args;
|
|
|
|
op->cmd = level;
|
|
|
|
op->arg1.mfn = pfn_to_mfn(pfn);
|
|
|
|
MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);
|
|
|
|
}
|
|
|
|
|
2008-10-08 22:01:39 +02:00
|
|
|
static int xen_pin_page(struct mm_struct *mm, struct page *page,
|
|
|
|
enum pt_level level)
|
2007-07-18 03:37:05 +02:00
|
|
|
{
|
2008-04-28 11:12:51 +02:00
|
|
|
unsigned pgfl = TestSetPagePinned(page);
|
2007-07-18 03:37:05 +02:00
|
|
|
int flush;
|
|
|
|
|
|
|
|
if (pgfl)
|
|
|
|
flush = 0; /* already pinned */
|
|
|
|
else if (PageHighMem(page))
|
|
|
|
/* kmaps need flushing if we found an unpinned
|
|
|
|
highpage */
|
|
|
|
flush = 1;
|
|
|
|
else {
|
|
|
|
void *pt = lowmem_page_address(page);
|
|
|
|
unsigned long pfn = page_to_pfn(page);
|
|
|
|
struct multicall_space mcs = __xen_mc_entry(0);
|
2007-10-16 20:51:30 +02:00
|
|
|
spinlock_t *ptl;
|
2007-07-18 03:37:05 +02:00
|
|
|
|
|
|
|
flush = 0;
|
|
|
|
|
2008-08-19 22:32:51 +02:00
|
|
|
/*
|
|
|
|
* We need to hold the pagetable lock between the time
|
|
|
|
* we make the pagetable RO and when we actually pin
|
|
|
|
* it. If we don't, then other users may come in and
|
|
|
|
* attempt to update the pagetable by writing it,
|
|
|
|
* which will fail because the memory is RO but not
|
|
|
|
* pinned, so Xen won't do the trap'n'emulate.
|
|
|
|
*
|
|
|
|
* If we're using split pte locks, we can't hold the
|
|
|
|
* entire pagetable's worth of locks during the
|
|
|
|
* traverse, because we may wrap the preempt count (8
|
|
|
|
* bits). The solution is to mark RO and pin each PTE
|
|
|
|
* page while holding the lock. This means the number
|
|
|
|
* of locks we end up holding is never more than a
|
|
|
|
* batch size (~32 entries, at present).
|
|
|
|
*
|
|
|
|
* If we're not using split pte locks, we needn't pin
|
|
|
|
* the PTE pages independently, because we're
|
|
|
|
* protected by the overall pagetable lock.
|
|
|
|
*/
|
2007-10-16 20:51:30 +02:00
|
|
|
ptl = NULL;
|
|
|
|
if (level == PT_PTE)
|
2008-10-08 22:01:39 +02:00
|
|
|
ptl = xen_pte_lock(page, mm);
|
2007-10-16 20:51:30 +02:00
|
|
|
|
2007-07-18 03:37:05 +02:00
|
|
|
MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
|
|
|
|
pfn_pte(pfn, PAGE_KERNEL_RO),
|
2007-10-16 20:51:30 +02:00
|
|
|
level == PT_PGD ? UVMF_TLB_FLUSH : 0);
|
|
|
|
|
2008-08-19 22:32:51 +02:00
|
|
|
if (ptl) {
|
2007-10-16 20:51:30 +02:00
|
|
|
xen_do_pin(MMUEXT_PIN_L1_TABLE, pfn);
|
|
|
|
|
|
|
|
/* Queue a deferred unlock for when this batch
|
|
|
|
is completed. */
|
2008-08-19 22:34:22 +02:00
|
|
|
xen_mc_callback(xen_pte_unlock, ptl);
|
2007-10-16 20:51:30 +02:00
|
|
|
}
|
2007-07-18 03:37:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return flush;
|
|
|
|
}
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2007-07-18 03:37:05 +02:00
|
|
|
/* This is called just after a mm has been created, but it has not
|
|
|
|
been used yet. We need to make sure that its pagetable is all
|
|
|
|
read-only, and can be pinned. */
|
2008-10-08 22:01:39 +02:00
|
|
|
static void __xen_pgd_pin(struct mm_struct *mm, pgd_t *pgd)
|
2007-07-18 03:37:04 +02:00
|
|
|
{
|
2008-10-28 09:23:06 +01:00
|
|
|
vm_unmap_aliases();
|
|
|
|
|
2007-07-18 03:37:05 +02:00
|
|
|
xen_mc_batch();
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2008-11-21 11:21:33 +01:00
|
|
|
if (__xen_pgd_walk(mm, pgd, xen_pin_page, USER_LIMIT)) {
|
2008-10-28 09:23:06 +01:00
|
|
|
/* re-enable interrupts for flushing */
|
2007-07-18 03:37:06 +02:00
|
|
|
xen_mc_issue(0);
|
2008-10-28 09:23:06 +01:00
|
|
|
|
2007-07-18 03:37:05 +02:00
|
|
|
kmap_flush_unused();
|
2008-10-28 09:23:06 +01:00
|
|
|
|
2007-07-18 03:37:06 +02:00
|
|
|
xen_mc_batch();
|
|
|
|
}
|
2007-07-18 03:37:05 +02:00
|
|
|
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
{
|
|
|
|
pgd_t *user_pgd = xen_get_user_pgd(pgd);
|
|
|
|
|
|
|
|
xen_do_pin(MMUEXT_PIN_L4_TABLE, PFN_DOWN(__pa(pgd)));
|
|
|
|
|
|
|
|
if (user_pgd) {
|
2008-10-08 22:01:39 +02:00
|
|
|
xen_pin_page(mm, virt_to_page(user_pgd), PT_PGD);
|
2008-12-16 20:56:06 +01:00
|
|
|
xen_do_pin(MMUEXT_PIN_L4_TABLE,
|
|
|
|
PFN_DOWN(__pa(user_pgd)));
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#else /* CONFIG_X86_32 */
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
#ifdef CONFIG_X86_PAE
|
|
|
|
/* Need to make sure unshared kernel PMD is pinnable */
|
2008-11-06 22:48:24 +01:00
|
|
|
xen_pin_page(mm, pgd_page(pgd[pgd_index(TASK_SIZE)]),
|
2008-10-08 22:01:39 +02:00
|
|
|
PT_PMD);
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
#endif
|
2008-05-09 13:05:57 +02:00
|
|
|
xen_do_pin(MMUEXT_PIN_L3_TABLE, PFN_DOWN(__pa(pgd)));
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
#endif /* CONFIG_X86_64 */
|
2007-07-18 03:37:05 +02:00
|
|
|
xen_mc_issue(0);
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
2008-10-08 22:01:39 +02:00
|
|
|
static void xen_pgd_pin(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
__xen_pgd_pin(mm, mm->pgd);
|
|
|
|
}
|
|
|
|
|
2008-05-27 00:31:27 +02:00
|
|
|
/*
|
|
|
|
* On save, we need to pin all pagetables to make sure they get their
|
|
|
|
* mfns turned into pfns. Search the list for any unpinned pgds and pin
|
|
|
|
* them (unpinned pgds are not currently in use, probably because the
|
|
|
|
* process is under construction or destruction).
|
2008-10-08 22:01:39 +02:00
|
|
|
*
|
|
|
|
* Expected to be called in stop_machine() ("equivalent to taking
|
|
|
|
* every spinlock in the system"), so the locking doesn't really
|
|
|
|
* matter all that much.
|
2008-05-27 00:31:27 +02:00
|
|
|
*/
|
|
|
|
void xen_mm_pin_all(void)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct page *page;
|
2007-10-16 20:51:30 +02:00
|
|
|
|
2008-05-27 00:31:27 +02:00
|
|
|
spin_lock_irqsave(&pgd_lock, flags);
|
2007-07-18 03:37:05 +02:00
|
|
|
|
2008-05-27 00:31:27 +02:00
|
|
|
list_for_each_entry(page, &pgd_list, lru) {
|
|
|
|
if (!PagePinned(page)) {
|
2008-10-08 22:01:39 +02:00
|
|
|
__xen_pgd_pin(&init_mm, (pgd_t *)page_address(page));
|
2008-05-27 00:31:27 +02:00
|
|
|
SetPageSavePinned(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&pgd_lock, flags);
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
2008-07-09 00:06:24 +02:00
|
|
|
/*
|
|
|
|
* The init_mm pagetable is really pinned as soon as its created, but
|
|
|
|
* that's before we have page structures to store the bits. So do all
|
|
|
|
* the book-keeping now.
|
|
|
|
*/
|
2008-10-08 22:01:39 +02:00
|
|
|
static __init int xen_mark_pinned(struct mm_struct *mm, struct page *page,
|
|
|
|
enum pt_level level)
|
2007-07-18 03:37:04 +02:00
|
|
|
{
|
2007-07-18 03:37:05 +02:00
|
|
|
SetPagePinned(page);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2007-07-18 03:37:05 +02:00
|
|
|
void __init xen_mark_init_mm_pinned(void)
|
|
|
|
{
|
2008-10-08 22:01:39 +02:00
|
|
|
xen_pgd_walk(&init_mm, xen_mark_pinned, FIXADDR_TOP);
|
2007-07-18 03:37:05 +02:00
|
|
|
}
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2008-10-08 22:01:39 +02:00
|
|
|
static int xen_unpin_page(struct mm_struct *mm, struct page *page,
|
|
|
|
enum pt_level level)
|
2007-07-18 03:37:05 +02:00
|
|
|
{
|
2008-04-28 11:12:51 +02:00
|
|
|
unsigned pgfl = TestClearPagePinned(page);
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2007-07-18 03:37:05 +02:00
|
|
|
if (pgfl && !PageHighMem(page)) {
|
|
|
|
void *pt = lowmem_page_address(page);
|
|
|
|
unsigned long pfn = page_to_pfn(page);
|
2007-10-16 20:51:30 +02:00
|
|
|
spinlock_t *ptl = NULL;
|
|
|
|
struct multicall_space mcs;
|
|
|
|
|
2008-08-19 22:32:51 +02:00
|
|
|
/*
|
|
|
|
* Do the converse to pin_page. If we're using split
|
|
|
|
* pte locks, we must be holding the lock for while
|
|
|
|
* the pte page is unpinned but still RO to prevent
|
|
|
|
* concurrent updates from seeing it in this
|
|
|
|
* partially-pinned state.
|
|
|
|
*/
|
2007-10-16 20:51:30 +02:00
|
|
|
if (level == PT_PTE) {
|
2008-10-08 22:01:39 +02:00
|
|
|
ptl = xen_pte_lock(page, mm);
|
2007-10-16 20:51:30 +02:00
|
|
|
|
2008-08-19 22:32:51 +02:00
|
|
|
if (ptl)
|
|
|
|
xen_do_pin(MMUEXT_UNPIN_TABLE, pfn);
|
2007-10-16 20:51:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
mcs = __xen_mc_entry(0);
|
2007-07-18 03:37:05 +02:00
|
|
|
|
|
|
|
MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
|
|
|
|
pfn_pte(pfn, PAGE_KERNEL),
|
2007-10-16 20:51:30 +02:00
|
|
|
level == PT_PGD ? UVMF_TLB_FLUSH : 0);
|
|
|
|
|
|
|
|
if (ptl) {
|
|
|
|
/* unlock when batch completed */
|
2008-08-19 22:34:22 +02:00
|
|
|
xen_mc_callback(xen_pte_unlock, ptl);
|
2007-10-16 20:51:30 +02:00
|
|
|
}
|
2007-07-18 03:37:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0; /* never need to flush on unpin */
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
2007-07-18 03:37:05 +02:00
|
|
|
/* Release a pagetables pages back as normal RW */
|
2008-10-08 22:01:39 +02:00
|
|
|
static void __xen_pgd_unpin(struct mm_struct *mm, pgd_t *pgd)
|
2007-07-18 03:37:05 +02:00
|
|
|
{
|
|
|
|
xen_mc_batch();
|
|
|
|
|
2007-10-16 20:51:30 +02:00
|
|
|
xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(pgd)));
|
2007-07-18 03:37:05 +02:00
|
|
|
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
{
|
|
|
|
pgd_t *user_pgd = xen_get_user_pgd(pgd);
|
|
|
|
|
|
|
|
if (user_pgd) {
|
2008-12-16 20:56:06 +01:00
|
|
|
xen_do_pin(MMUEXT_UNPIN_TABLE,
|
|
|
|
PFN_DOWN(__pa(user_pgd)));
|
2008-10-08 22:01:39 +02:00
|
|
|
xen_unpin_page(mm, virt_to_page(user_pgd), PT_PGD);
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
#ifdef CONFIG_X86_PAE
|
|
|
|
/* Need to make sure unshared kernel PMD is unpinned */
|
2008-11-06 22:48:24 +01:00
|
|
|
xen_unpin_page(mm, pgd_page(pgd[pgd_index(TASK_SIZE)]),
|
2008-10-08 22:01:39 +02:00
|
|
|
PT_PMD);
|
xen: rework pgd_walk to deal with 32/64 bit
Rewrite pgd_walk to deal with 64-bit address spaces. There are two
notible features of 64-bit workspaces:
1. The physical address is only 48 bits wide, with the upper 16 bits
being sign extension; kernel addresses are negative, and userspace is
positive.
2. The Xen hypervisor mapping is at the negative-most address, just above
the sign-extension hole.
1. means that we can't easily use addresses when traversing the space,
since we must deal with sign extension. This rewrite expresses
everything in terms of pgd/pud/pmd indices, which means we don't need
to worry about the exact configuration of the virtual memory space.
This approach works equally well in 32-bit.
To deal with 2, assume the hole is between the uppermost userspace
address and PAGE_OFFSET. For 64-bit this skips the Xen mapping hole.
For 32-bit, the hole is zero-sized.
In all cases, the uppermost kernel address is FIXADDR_TOP.
A side-effect of this patch is that the upper boundary is actually
handled properly, exposing a long-standing bug in 32-bit, which failed
to pin kernel pmd page. The kernel pmd is not shared, and so must be
explicitly pinned, even though the kernel ptes are shared and don't
need pinning.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:06 +02:00
|
|
|
#endif
|
xen64: allocate and manage user pagetables
Because the x86_64 architecture does not enforce segment limits, Xen
cannot protect itself with them as it does in 32-bit mode. Therefore,
to protect itself, it runs the guest kernel in ring 3. Since it also
runs the guest userspace in ring3, the guest kernel must maintain a
second pagetable for its userspace, which does not map kernel space.
Naturally, the guest kernel pagetables map both kernel and userspace.
The userspace pagetable is attached to the corresponding kernel
pagetable via the pgd's page->private field. It is allocated and
freed at the same time as the kernel pgd via the
paravirt_pgd_alloc/free hooks.
Fortunately, the user pagetable is almost entirely shared with the
kernel pagetable; the only difference is the pgd page itself. set_pgd
will populate all entries in the kernel pagetable, and also set the
corresponding user pgd entry if the address is less than
STACK_TOP_MAX.
The user pagetable must be pinned and unpinned with the kernel one,
but because the pagetables are aliased, pgd_walk() only needs to be
called on the kernel pagetable. The user pgd page is then
pinned/unpinned along with the kernel pgd page.
xen_write_cr3 must write both the kernel and user cr3s.
The init_mm.pgd pagetable never has a user pagetable allocated for it,
because it can never be used while running usermode.
One awkward area is that early in boot the page structures are not
available. No user pagetable can exist at that point, but it
complicates the logic to avoid looking at the page structure.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Stephen Tweedie <sct@redhat.com>
Cc: Eduardo Habkost <ehabkost@redhat.com>
Cc: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-09 00:07:13 +02:00
|
|
|
|
2008-11-21 11:21:33 +01:00
|
|
|
__xen_pgd_walk(mm, pgd, xen_unpin_page, USER_LIMIT);
|
2007-07-18 03:37:05 +02:00
|
|
|
|
|
|
|
xen_mc_issue(0);
|
|
|
|
}
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2008-10-08 22:01:39 +02:00
|
|
|
static void xen_pgd_unpin(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
__xen_pgd_unpin(mm, mm->pgd);
|
|
|
|
}
|
|
|
|
|
2008-05-27 00:31:27 +02:00
|
|
|
/*
|
|
|
|
* On resume, undo any pinning done at save, so that the rest of the
|
|
|
|
* kernel doesn't see any unexpected pinned pagetables.
|
|
|
|
*/
|
|
|
|
void xen_mm_unpin_all(void)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&pgd_lock, flags);
|
|
|
|
|
|
|
|
list_for_each_entry(page, &pgd_list, lru) {
|
|
|
|
if (PageSavePinned(page)) {
|
|
|
|
BUG_ON(!PagePinned(page));
|
2008-10-08 22:01:39 +02:00
|
|
|
__xen_pgd_unpin(&init_mm, (pgd_t *)page_address(page));
|
2008-05-27 00:31:27 +02:00
|
|
|
ClearPageSavePinned(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&pgd_lock, flags);
|
|
|
|
}
|
|
|
|
|
2007-07-18 03:37:04 +02:00
|
|
|
void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
|
|
|
|
{
|
2007-07-18 03:37:05 +02:00
|
|
|
spin_lock(&next->page_table_lock);
|
2008-10-08 22:01:39 +02:00
|
|
|
xen_pgd_pin(next);
|
2007-07-18 03:37:05 +02:00
|
|
|
spin_unlock(&next->page_table_lock);
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
|
|
|
|
{
|
2007-07-18 03:37:05 +02:00
|
|
|
spin_lock(&mm->page_table_lock);
|
2008-10-08 22:01:39 +02:00
|
|
|
xen_pgd_pin(mm);
|
2007-07-18 03:37:05 +02:00
|
|
|
spin_unlock(&mm->page_table_lock);
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-07-18 03:37:06 +02:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/* Another cpu may still have their %cr3 pointing at the pagetable, so
|
|
|
|
we need to repoint it somewhere else before we can unpin it. */
|
|
|
|
static void drop_other_mm_ref(void *info)
|
|
|
|
{
|
|
|
|
struct mm_struct *mm = info;
|
2008-07-09 00:06:40 +02:00
|
|
|
struct mm_struct *active_mm;
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2009-01-18 16:38:57 +01:00
|
|
|
active_mm = percpu_read(cpu_tlbstate.active_mm);
|
2008-07-09 00:06:40 +02:00
|
|
|
|
|
|
|
if (active_mm == mm)
|
2007-07-18 03:37:06 +02:00
|
|
|
leave_mm(smp_processor_id());
|
2007-10-16 20:51:30 +02:00
|
|
|
|
|
|
|
/* If this cpu still has a stale cr3 reference, then make sure
|
|
|
|
it has been flushed. */
|
percpu: add optimized generic percpu accessors
It is an optimization and a cleanup, and adds the following new
generic percpu methods:
percpu_read()
percpu_write()
percpu_add()
percpu_sub()
percpu_and()
percpu_or()
percpu_xor()
and implements support for them on x86. (other architectures will fall
back to a default implementation)
The advantage is that for example to read a local percpu variable,
instead of this sequence:
return __get_cpu_var(var);
ffffffff8102ca2b: 48 8b 14 fd 80 09 74 mov -0x7e8bf680(,%rdi,8),%rdx
ffffffff8102ca32: 81
ffffffff8102ca33: 48 c7 c0 d8 59 00 00 mov $0x59d8,%rax
ffffffff8102ca3a: 48 8b 04 10 mov (%rax,%rdx,1),%rax
We can get a single instruction by using the optimized variants:
return percpu_read(var);
ffffffff8102ca3f: 65 48 8b 05 91 8f fd mov %gs:0x7efd8f91(%rip),%rax
I also cleaned up the x86-specific APIs and made the x86 code use
these new generic percpu primitives.
tj: * fixed generic percpu_sub() definition as Roel Kluin pointed out
* added percpu_and() for completeness's sake
* made generic percpu ops atomic against preemption
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Tejun Heo <tj@kernel.org>
2009-01-15 14:15:53 +01:00
|
|
|
if (percpu_read(xen_current_cr3) == __pa(mm->pgd)) {
|
2007-10-16 20:51:30 +02:00
|
|
|
load_cr3(swapper_pg_dir);
|
|
|
|
arch_flush_lazy_cpu_mode();
|
|
|
|
}
|
2007-07-18 03:37:06 +02:00
|
|
|
}
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2008-08-19 22:34:22 +02:00
|
|
|
static void xen_drop_mm_ref(struct mm_struct *mm)
|
2007-07-18 03:37:06 +02:00
|
|
|
{
|
2008-12-17 02:34:05 +01:00
|
|
|
cpumask_var_t mask;
|
2007-10-16 20:51:30 +02:00
|
|
|
unsigned cpu;
|
|
|
|
|
2007-07-18 03:37:06 +02:00
|
|
|
if (current->active_mm == mm) {
|
|
|
|
if (current->mm == mm)
|
|
|
|
load_cr3(swapper_pg_dir);
|
|
|
|
else
|
|
|
|
leave_mm(smp_processor_id());
|
2007-10-16 20:51:30 +02:00
|
|
|
arch_flush_lazy_cpu_mode();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the "official" set of cpus referring to our pagetable. */
|
2008-12-17 02:34:05 +01:00
|
|
|
if (!alloc_cpumask_var(&mask, GFP_ATOMIC)) {
|
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
if (!cpumask_test_cpu(cpu, &mm->cpu_vm_mask)
|
|
|
|
&& per_cpu(xen_current_cr3, cpu) != __pa(mm->pgd))
|
|
|
|
continue;
|
|
|
|
smp_call_function_single(cpu, drop_other_mm_ref, mm, 1);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
cpumask_copy(mask, &mm->cpu_vm_mask);
|
2007-10-16 20:51:30 +02:00
|
|
|
|
|
|
|
/* It's possible that a vcpu may have a stale reference to our
|
|
|
|
cr3, because its in lazy mode, and it hasn't yet flushed
|
|
|
|
its set of pending hypercalls yet. In this case, we can
|
|
|
|
look at its actual current cr3 value, and force it to flush
|
|
|
|
if needed. */
|
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
if (per_cpu(xen_current_cr3, cpu) == __pa(mm->pgd))
|
2008-12-17 02:34:05 +01:00
|
|
|
cpumask_set_cpu(cpu, mask);
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
|
|
|
|
2008-12-17 02:34:05 +01:00
|
|
|
if (!cpumask_empty(mask))
|
|
|
|
smp_call_function_many(mask, drop_other_mm_ref, mm, 1);
|
|
|
|
free_cpumask_var(mask);
|
2007-07-18 03:37:06 +02:00
|
|
|
}
|
|
|
|
#else
|
2008-08-19 22:34:22 +02:00
|
|
|
static void xen_drop_mm_ref(struct mm_struct *mm)
|
2007-07-18 03:37:06 +02:00
|
|
|
{
|
|
|
|
if (current->active_mm == mm)
|
|
|
|
load_cr3(swapper_pg_dir);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* While a process runs, Xen pins its pagetables, which means that the
|
|
|
|
* hypervisor forces it to be read-only, and it controls all updates
|
|
|
|
* to it. This means that all pagetable updates have to go via the
|
|
|
|
* hypervisor, which is moderately expensive.
|
|
|
|
*
|
|
|
|
* Since we're pulling the pagetable down, we switch to use init_mm,
|
|
|
|
* unpin old process pagetable and mark it all read-write, which
|
|
|
|
* allows further operations on it to be simple memory accesses.
|
|
|
|
*
|
|
|
|
* The only subtle point is that another CPU may be still using the
|
|
|
|
* pagetable because of lazy tlb flushing. This means we need need to
|
|
|
|
* switch all CPUs off this pagetable before we can unpin it.
|
|
|
|
*/
|
|
|
|
void xen_exit_mmap(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
get_cpu(); /* make sure we don't move around */
|
2008-08-19 22:34:22 +02:00
|
|
|
xen_drop_mm_ref(mm);
|
2007-07-18 03:37:06 +02:00
|
|
|
put_cpu();
|
2007-07-18 03:37:04 +02:00
|
|
|
|
2007-07-18 03:37:06 +02:00
|
|
|
spin_lock(&mm->page_table_lock);
|
2007-09-25 20:50:00 +02:00
|
|
|
|
|
|
|
/* pgd may not be pinned in the error exit path of execve */
|
2008-08-19 22:34:22 +02:00
|
|
|
if (xen_page_pinned(mm->pgd))
|
2008-10-08 22:01:39 +02:00
|
|
|
xen_pgd_unpin(mm);
|
2007-10-16 20:51:30 +02:00
|
|
|
|
2007-07-18 03:37:06 +02:00
|
|
|
spin_unlock(&mm->page_table_lock);
|
2007-07-18 03:37:04 +02:00
|
|
|
}
|
2008-08-21 02:02:19 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_XEN_DEBUG_FS
|
|
|
|
|
|
|
|
static struct dentry *d_mmu_debug;
|
|
|
|
|
|
|
|
static int __init xen_mmu_debugfs(void)
|
|
|
|
{
|
|
|
|
struct dentry *d_xen = xen_init_debugfs();
|
|
|
|
|
|
|
|
if (d_xen == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
d_mmu_debug = debugfs_create_dir("mmu", d_xen);
|
|
|
|
|
|
|
|
debugfs_create_u8("zero_stats", 0644, d_mmu_debug, &zero_stats);
|
|
|
|
|
|
|
|
debugfs_create_u32("pgd_update", 0444, d_mmu_debug, &mmu_stats.pgd_update);
|
|
|
|
debugfs_create_u32("pgd_update_pinned", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.pgd_update_pinned);
|
|
|
|
debugfs_create_u32("pgd_update_batched", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.pgd_update_pinned);
|
|
|
|
|
|
|
|
debugfs_create_u32("pud_update", 0444, d_mmu_debug, &mmu_stats.pud_update);
|
|
|
|
debugfs_create_u32("pud_update_pinned", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.pud_update_pinned);
|
|
|
|
debugfs_create_u32("pud_update_batched", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.pud_update_pinned);
|
|
|
|
|
|
|
|
debugfs_create_u32("pmd_update", 0444, d_mmu_debug, &mmu_stats.pmd_update);
|
|
|
|
debugfs_create_u32("pmd_update_pinned", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.pmd_update_pinned);
|
|
|
|
debugfs_create_u32("pmd_update_batched", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.pmd_update_pinned);
|
|
|
|
|
|
|
|
debugfs_create_u32("pte_update", 0444, d_mmu_debug, &mmu_stats.pte_update);
|
|
|
|
// debugfs_create_u32("pte_update_pinned", 0444, d_mmu_debug,
|
|
|
|
// &mmu_stats.pte_update_pinned);
|
|
|
|
debugfs_create_u32("pte_update_batched", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.pte_update_pinned);
|
|
|
|
|
|
|
|
debugfs_create_u32("mmu_update", 0444, d_mmu_debug, &mmu_stats.mmu_update);
|
|
|
|
debugfs_create_u32("mmu_update_extended", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.mmu_update_extended);
|
|
|
|
xen_debugfs_create_u32_array("mmu_update_histo", 0444, d_mmu_debug,
|
|
|
|
mmu_stats.mmu_update_histo, 20);
|
|
|
|
|
|
|
|
debugfs_create_u32("set_pte_at", 0444, d_mmu_debug, &mmu_stats.set_pte_at);
|
|
|
|
debugfs_create_u32("set_pte_at_batched", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.set_pte_at_batched);
|
|
|
|
debugfs_create_u32("set_pte_at_current", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.set_pte_at_current);
|
|
|
|
debugfs_create_u32("set_pte_at_kernel", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.set_pte_at_kernel);
|
|
|
|
|
|
|
|
debugfs_create_u32("prot_commit", 0444, d_mmu_debug, &mmu_stats.prot_commit);
|
|
|
|
debugfs_create_u32("prot_commit_batched", 0444, d_mmu_debug,
|
|
|
|
&mmu_stats.prot_commit_batched);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
fs_initcall(xen_mmu_debugfs);
|
|
|
|
|
|
|
|
#endif /* CONFIG_XEN_DEBUG_FS */
|