mmu.c 29.2 KB
Newer Older
J
Jeremy Fitzhardinge 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
/*
 * 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
 */
41
#include <linux/sched.h>
42
#include <linux/highmem.h>
J
Jeremy Fitzhardinge 已提交
43
#include <linux/debugfs.h>
J
Jeremy Fitzhardinge 已提交
44 45 46 47
#include <linux/bug.h>

#include <asm/pgtable.h>
#include <asm/tlbflush.h>
48
#include <asm/fixmap.h>
J
Jeremy Fitzhardinge 已提交
49
#include <asm/mmu_context.h>
50
#include <asm/paravirt.h>
51
#include <asm/linkage.h>
J
Jeremy Fitzhardinge 已提交
52 53

#include <asm/xen/hypercall.h>
54
#include <asm/xen/hypervisor.h>
J
Jeremy Fitzhardinge 已提交
55 56 57 58

#include <xen/page.h>
#include <xen/interface/xen.h>

59
#include "multicalls.h"
J
Jeremy Fitzhardinge 已提交
60
#include "mmu.h"
J
Jeremy Fitzhardinge 已提交
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
#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 */
J
Jeremy Fitzhardinge 已提交
116

117 118 119 120 121 122 123
/*
 * 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)


124
#define P2M_ENTRIES_PER_PAGE	(PAGE_SIZE / sizeof(unsigned long))
125
#define TOP_ENTRIES		(MAX_DOMAIN_PAGES / P2M_ENTRIES_PER_PAGE)
126

127
/* Placeholder for holes in the address space */
128
static unsigned long p2m_missing[P2M_ENTRIES_PER_PAGE] __page_aligned_data =
129 130 131
		{ [ 0 ... P2M_ENTRIES_PER_PAGE-1 ] = ~0UL };

 /* Array of pointers to pages containing p2m entries */
132
static unsigned long *p2m_top[TOP_ENTRIES] __page_aligned_data =
133
		{ [ 0 ... TOP_ENTRIES - 1] = &p2m_missing[0] };
134

J
Jeremy Fitzhardinge 已提交
135
/* Arrays of p2m arrays expressed in mfns used for save/restore */
136
static unsigned long p2m_top_mfn[TOP_ENTRIES] __page_aligned_bss;
J
Jeremy Fitzhardinge 已提交
137

138 139
static unsigned long p2m_top_mfn_list[TOP_ENTRIES / P2M_ENTRIES_PER_PAGE]
	__page_aligned_bss;
J
Jeremy Fitzhardinge 已提交
140

141 142
static inline unsigned p2m_top_index(unsigned long pfn)
{
143
	BUG_ON(pfn >= MAX_DOMAIN_PAGES);
144 145 146 147 148 149 150 151
	return pfn / P2M_ENTRIES_PER_PAGE;
}

static inline unsigned p2m_index(unsigned long pfn)
{
	return pfn % P2M_ENTRIES_PER_PAGE;
}

J
Jeremy Fitzhardinge 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
/* Build the parallel p2m_top_mfn structures */
void xen_setup_mfn_list_list(void)
{
	unsigned pfn, idx;

	for(pfn = 0; pfn < MAX_DOMAIN_PAGES; pfn += P2M_ENTRIES_PER_PAGE) {
		unsigned topidx = p2m_top_index(pfn);

		p2m_top_mfn[topidx] = virt_to_mfn(p2m_top[topidx]);
	}

	for(idx = 0; idx < ARRAY_SIZE(p2m_top_mfn_list); idx++) {
		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 */
176 177 178
void __init xen_build_dynamic_phys_to_machine(void)
{
	unsigned long *mfn_list = (unsigned long *)xen_start_info->mfn_list;
179
	unsigned long max_pfn = min(MAX_DOMAIN_PAGES, xen_start_info->nr_pages);
J
Jeremy Fitzhardinge 已提交
180
	unsigned pfn;
181

182
	for(pfn = 0; pfn < max_pfn; pfn += P2M_ENTRIES_PER_PAGE) {
183 184 185 186 187 188 189 190 191 192
		unsigned topidx = p2m_top_index(pfn);

		p2m_top[topidx] = &mfn_list[pfn];
	}
}

unsigned long get_phys_to_machine(unsigned long pfn)
{
	unsigned topidx, idx;

193 194 195
	if (unlikely(pfn >= MAX_DOMAIN_PAGES))
		return INVALID_P2M_ENTRY;

196 197 198 199
	topidx = p2m_top_index(pfn);
	idx = p2m_index(pfn);
	return p2m_top[topidx][idx];
}
I
Ingo Molnar 已提交
200
EXPORT_SYMBOL_GPL(get_phys_to_machine);
201

J
Jeremy Fitzhardinge 已提交
202
static void alloc_p2m(unsigned long **pp, unsigned long *mfnp)
203 204 205 206 207 208 209 210 211 212
{
	unsigned long *p;
	unsigned i;

	p = (void *)__get_free_page(GFP_KERNEL | __GFP_NOFAIL);
	BUG_ON(p == NULL);

	for(i = 0; i < P2M_ENTRIES_PER_PAGE; i++)
		p[i] = INVALID_P2M_ENTRY;

213
	if (cmpxchg(pp, p2m_missing, p) != p2m_missing)
214
		free_page((unsigned long)p);
J
Jeremy Fitzhardinge 已提交
215 216
	else
		*mfnp = virt_to_mfn(p);
217 218 219 220 221 222 223 224
}

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);
225 226 227 228 229
		return;
	}

	if (unlikely(pfn >= MAX_DOMAIN_PAGES)) {
		BUG_ON(mfn != INVALID_P2M_ENTRY);
230 231 232 233
		return;
	}

	topidx = p2m_top_index(pfn);
234
	if (p2m_top[topidx] == p2m_missing) {
235 236 237
		/* no need to allocate a page to store an invalid entry */
		if (mfn == INVALID_P2M_ENTRY)
			return;
J
Jeremy Fitzhardinge 已提交
238
		alloc_p2m(&p2m_top[topidx], &p2m_top_mfn[topidx]);
239 240 241 242 243 244
	}

	idx = p2m_index(pfn);
	p2m_top[topidx][idx] = mfn;
}

245
xmaddr_t arbitrary_virt_to_machine(void *vaddr)
J
Jeremy Fitzhardinge 已提交
246
{
247
	unsigned long address = (unsigned long)vaddr;
248
	unsigned int level;
249
	pte_t *pte = lookup_address(address, &level);
250
	unsigned offset = address & ~PAGE_MASK;
J
Jeremy Fitzhardinge 已提交
251 252 253

	BUG_ON(pte == NULL);

254
	return XMADDR(((phys_addr_t)pte_mfn(*pte) << PAGE_SHIFT) + offset);
J
Jeremy Fitzhardinge 已提交
255 256 257 258 259 260
}

void make_lowmem_page_readonly(void *vaddr)
{
	pte_t *pte, ptev;
	unsigned long address = (unsigned long)vaddr;
261
	unsigned int level;
J
Jeremy Fitzhardinge 已提交
262

263
	pte = lookup_address(address, &level);
J
Jeremy Fitzhardinge 已提交
264 265 266 267 268 269 270 271 272 273 274 275
	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;
276
	unsigned int level;
J
Jeremy Fitzhardinge 已提交
277

278
	pte = lookup_address(address, &level);
J
Jeremy Fitzhardinge 已提交
279 280 281 282 283 284 285 286 287
	BUG_ON(pte == NULL);

	ptev = pte_mkwrite(*pte);

	if (HYPERVISOR_update_va_mapping(address, ptev, 0))
		BUG();
}


288
static bool xen_page_pinned(void *ptr)
289 290 291 292 293 294
{
	struct page *page = virt_to_page(ptr);

	return PagePinned(page);
}

295
static void xen_extend_mmu_update(const struct mmu_update *update)
J
Jeremy Fitzhardinge 已提交
296
{
J
Jeremy Fitzhardinge 已提交
297 298
	struct multicall_space mcs;
	struct mmu_update *u;
J
Jeremy Fitzhardinge 已提交
299

300 301
	mcs = xen_mc_extend_args(__HYPERVISOR_mmu_update, sizeof(*u));

J
Jeremy Fitzhardinge 已提交
302 303 304 305
	if (mcs.mc != NULL) {
		ADD_STATS(mmu_update_extended, 1);
		ADD_STATS(mmu_update_histo[mcs.mc->args[1]], -1);

306
		mcs.mc->args[1]++;
J
Jeremy Fitzhardinge 已提交
307 308 309 310 311 312 313

		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);
314 315
		mcs = __xen_mc_entry(sizeof(*u));
		MULTI_mmu_update(mcs.mc, mcs.args, 1, NULL, DOMID_SELF);
J
Jeremy Fitzhardinge 已提交
316
		ADD_STATS(mmu_update_histo[1], 1);
317
	}
J
Jeremy Fitzhardinge 已提交
318 319

	u = mcs.args;
320 321 322 323 324 325 326 327 328 329 330
	*u = *update;
}

void xen_set_pmd_hyper(pmd_t *ptr, pmd_t val)
{
	struct mmu_update u;

	preempt_disable();

	xen_mc_batch();

331 332
	/* ptr may be ioremapped for 64-bit pagetable setup */
	u.ptr = arbitrary_virt_to_machine(ptr).maddr;
333
	u.val = pmd_val_ma(val);
334
	xen_extend_mmu_update(&u);
J
Jeremy Fitzhardinge 已提交
335

J
Jeremy Fitzhardinge 已提交
336 337
	ADD_STATS(pmd_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);

J
Jeremy Fitzhardinge 已提交
338 339 340
	xen_mc_issue(PARAVIRT_LAZY_MMU);

	preempt_enable();
J
Jeremy Fitzhardinge 已提交
341 342
}

343 344
void xen_set_pmd(pmd_t *ptr, pmd_t val)
{
J
Jeremy Fitzhardinge 已提交
345 346
	ADD_STATS(pmd_update, 1);

347 348
	/* If page is not pinned, we can just update the entry
	   directly */
349
	if (!xen_page_pinned(ptr)) {
350 351 352 353
		*ptr = val;
		return;
	}

J
Jeremy Fitzhardinge 已提交
354 355
	ADD_STATS(pmd_update_pinned, 1);

356 357 358
	xen_set_pmd_hyper(ptr, val);
}

J
Jeremy Fitzhardinge 已提交
359 360 361 362 363 364
/*
 * 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)
{
J
Jeremy Fitzhardinge 已提交
365
	set_pte_vaddr(vaddr, mfn_pte(mfn, flags));
J
Jeremy Fitzhardinge 已提交
366 367 368 369 370
}

void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
		    pte_t *ptep, pte_t pteval)
{
371 372 373 374
	/* updates to init_mm may be done without lock */
	if (mm == &init_mm)
		preempt_disable();

J
Jeremy Fitzhardinge 已提交
375 376 377 378 379
	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);

J
Jeremy Fitzhardinge 已提交
380
	if (mm == current->mm || mm == &init_mm) {
381
		if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
J
Jeremy Fitzhardinge 已提交
382 383 384 385
			struct multicall_space mcs;
			mcs = xen_mc_entry(0);

			MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);
J
Jeremy Fitzhardinge 已提交
386
			ADD_STATS(set_pte_at_batched, 1);
J
Jeremy Fitzhardinge 已提交
387
			xen_mc_issue(PARAVIRT_LAZY_MMU);
388
			goto out;
J
Jeremy Fitzhardinge 已提交
389 390
		} else
			if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)
391
				goto out;
J
Jeremy Fitzhardinge 已提交
392 393
	}
	xen_set_pte(ptep, pteval);
394 395 396 397

out:
	if (mm == &init_mm)
		preempt_enable();
J
Jeremy Fitzhardinge 已提交
398 399
}

400
pte_t xen_ptep_modify_prot_start(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
J
Jeremy Fitzhardinge 已提交
401
{
402 403 404 405 406 407 408
	/* 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)
{
409
	struct mmu_update u;
410

411
	xen_mc_batch();
J
Jeremy Fitzhardinge 已提交
412

413 414
	u.ptr = virt_to_machine(ptep).maddr | MMU_PT_UPDATE_PRESERVE_AD;
	u.val = pte_val_ma(pte);
415
	xen_extend_mmu_update(&u);
J
Jeremy Fitzhardinge 已提交
416

J
Jeremy Fitzhardinge 已提交
417 418 419
	ADD_STATS(prot_commit, 1);
	ADD_STATS(prot_commit_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);

420
	xen_mc_issue(PARAVIRT_LAZY_MMU);
J
Jeremy Fitzhardinge 已提交
421 422
}

J
Jeremy Fitzhardinge 已提交
423 424
/* Assume pteval_t is equivalent to all the other *val_t types. */
static pteval_t pte_mfn_to_pfn(pteval_t val)
J
Jeremy Fitzhardinge 已提交
425
{
J
Jeremy Fitzhardinge 已提交
426
	if (val & _PAGE_PRESENT) {
427
		unsigned long mfn = (val & PTE_PFN_MASK) >> PAGE_SHIFT;
J
Jeremy Fitzhardinge 已提交
428
		pteval_t flags = val & PTE_FLAGS_MASK;
429
		val = ((pteval_t)mfn_to_pfn(mfn) << PAGE_SHIFT) | flags;
J
Jeremy Fitzhardinge 已提交
430
	}
J
Jeremy Fitzhardinge 已提交
431

J
Jeremy Fitzhardinge 已提交
432
	return val;
J
Jeremy Fitzhardinge 已提交
433 434
}

J
Jeremy Fitzhardinge 已提交
435
static pteval_t pte_pfn_to_mfn(pteval_t val)
J
Jeremy Fitzhardinge 已提交
436
{
J
Jeremy Fitzhardinge 已提交
437
	if (val & _PAGE_PRESENT) {
438
		unsigned long pfn = (val & PTE_PFN_MASK) >> PAGE_SHIFT;
J
Jeremy Fitzhardinge 已提交
439
		pteval_t flags = val & PTE_FLAGS_MASK;
440
		val = ((pteval_t)pfn_to_mfn(pfn) << PAGE_SHIFT) | flags;
J
Jeremy Fitzhardinge 已提交
441 442
	}

J
Jeremy Fitzhardinge 已提交
443
	return val;
J
Jeremy Fitzhardinge 已提交
444 445
}

J
Jeremy Fitzhardinge 已提交
446
pteval_t xen_pte_val(pte_t pte)
J
Jeremy Fitzhardinge 已提交
447
{
J
Jeremy Fitzhardinge 已提交
448
	return pte_mfn_to_pfn(pte.pte);
J
Jeremy Fitzhardinge 已提交
449 450 451 452
}

pgdval_t xen_pgd_val(pgd_t pgd)
{
J
Jeremy Fitzhardinge 已提交
453
	return pte_mfn_to_pfn(pgd.pgd);
J
Jeremy Fitzhardinge 已提交
454 455 456 457
}

pte_t xen_make_pte(pteval_t pte)
{
J
Jeremy Fitzhardinge 已提交
458 459
	pte = pte_pfn_to_mfn(pte);
	return native_make_pte(pte);
J
Jeremy Fitzhardinge 已提交
460 461 462 463
}

pgd_t xen_make_pgd(pgdval_t pgd)
{
J
Jeremy Fitzhardinge 已提交
464 465
	pgd = pte_pfn_to_mfn(pgd);
	return native_make_pgd(pgd);
J
Jeremy Fitzhardinge 已提交
466 467 468 469
}

pmdval_t xen_pmd_val(pmd_t pmd)
{
J
Jeremy Fitzhardinge 已提交
470
	return pte_mfn_to_pfn(pmd.pmd);
J
Jeremy Fitzhardinge 已提交
471
}
472

473
void xen_set_pud_hyper(pud_t *ptr, pud_t val)
474
{
475
	struct mmu_update u;
476

J
Jeremy Fitzhardinge 已提交
477 478
	preempt_disable();

479 480
	xen_mc_batch();

481 482
	/* ptr may be ioremapped for 64-bit pagetable setup */
	u.ptr = arbitrary_virt_to_machine(ptr).maddr;
483
	u.val = pud_val_ma(val);
484
	xen_extend_mmu_update(&u);
J
Jeremy Fitzhardinge 已提交
485

J
Jeremy Fitzhardinge 已提交
486 487
	ADD_STATS(pud_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);

J
Jeremy Fitzhardinge 已提交
488 489 490
	xen_mc_issue(PARAVIRT_LAZY_MMU);

	preempt_enable();
491 492
}

493 494
void xen_set_pud(pud_t *ptr, pud_t val)
{
J
Jeremy Fitzhardinge 已提交
495 496
	ADD_STATS(pud_update, 1);

497 498
	/* If page is not pinned, we can just update the entry
	   directly */
499
	if (!xen_page_pinned(ptr)) {
500 501 502 503
		*ptr = val;
		return;
	}

J
Jeremy Fitzhardinge 已提交
504 505
	ADD_STATS(pud_update_pinned, 1);

506 507 508
	xen_set_pud_hyper(ptr, val);
}

509 510
void xen_set_pte(pte_t *ptep, pte_t pte)
{
J
Jeremy Fitzhardinge 已提交
511 512 513 514
	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);

515
#ifdef CONFIG_X86_PAE
516 517 518
	ptep->pte_high = pte.pte_high;
	smp_wmb();
	ptep->pte_low = pte.pte_low;
519 520 521
#else
	*ptep = pte;
#endif
522 523
}

524
#ifdef CONFIG_X86_PAE
J
Jeremy Fitzhardinge 已提交
525 526
void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
{
527
	set_64bit((u64 *)ptep, native_pte_val(pte));
J
Jeremy Fitzhardinge 已提交
528 529 530 531 532 533 534 535 536 537 538
}

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)
{
539
	set_pmd(pmdp, __pmd(0));
J
Jeremy Fitzhardinge 已提交
540
}
541
#endif	/* CONFIG_X86_PAE */
J
Jeremy Fitzhardinge 已提交
542

543
pmd_t xen_make_pmd(pmdval_t pmd)
J
Jeremy Fitzhardinge 已提交
544
{
J
Jeremy Fitzhardinge 已提交
545
	pmd = pte_pfn_to_mfn(pmd);
J
Jeremy Fitzhardinge 已提交
546
	return native_make_pmd(pmd);
J
Jeremy Fitzhardinge 已提交
547 548
}

549 550 551 552 553 554 555 556 557 558 559 560 561
#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);
}

562
pgd_t *xen_get_user_pgd(pgd_t *pgd)
563
{
564 565 566
	pgd_t *pgd_page = (pgd_t *)(((unsigned long)pgd) & PAGE_MASK);
	unsigned offset = pgd - pgd_page;
	pgd_t *user_ptr = NULL;
567

568 569 570 571 572 573
	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;
	}
574

575 576 577 578 579 580
	return user_ptr;
}

static void __xen_set_pgd_hyper(pgd_t *ptr, pgd_t val)
{
	struct mmu_update u;
581 582 583

	u.ptr = virt_to_machine(ptr).maddr;
	u.val = pgd_val_ma(val);
584
	xen_extend_mmu_update(&u);
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
}

/*
 * 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);
601 602 603 604 605 606 607 608

	xen_mc_issue(PARAVIRT_LAZY_MMU);

	preempt_enable();
}

void xen_set_pgd(pgd_t *ptr, pgd_t val)
{
609 610
	pgd_t *user_ptr = xen_get_user_pgd(ptr);

J
Jeremy Fitzhardinge 已提交
611 612
	ADD_STATS(pgd_update, 1);

613 614
	/* If page is not pinned, we can just update the entry
	   directly */
615
	if (!xen_page_pinned(ptr)) {
616
		*ptr = val;
617
		if (user_ptr) {
618
			WARN_ON(xen_page_pinned(user_ptr));
619 620
			*user_ptr = val;
		}
621 622 623
		return;
	}

J
Jeremy Fitzhardinge 已提交
624 625 626
	ADD_STATS(pgd_update_pinned, 1);
	ADD_STATS(pgd_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);

627 628 629 630 631 632 633 634 635
	/* 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);
636 637 638
}
#endif	/* PAGETABLE_LEVELS == 4 */

639
/*
640 641 642 643 644 645 646 647 648 649 650 651 652 653
 * (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.
 */
654 655 656
static int xen_pgd_walk(struct mm_struct *mm,
			int (*func)(struct mm_struct *mm, struct page *,
				    enum pt_level),
657
			unsigned long limit)
J
Jeremy Fitzhardinge 已提交
658
{
659
	pgd_t *pgd = mm->pgd;
660
	int flush = 0;
661 662 663
	unsigned hole_low, hole_high;
	unsigned pgdidx_limit, pudidx_limit, pmdidx_limit;
	unsigned pgdidx, pudidx, pmdidx;
664

665 666 667
	/* The limit is the last byte to be touched */
	limit--;
	BUG_ON(limit >= FIXADDR_TOP);
J
Jeremy Fitzhardinge 已提交
668 669

	if (xen_feature(XENFEAT_auto_translated_physmap))
670 671
		return 0;

672 673 674 675 676
	/*
	 * 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.
	 */
677
	hole_low = pgd_index(USER_LIMIT);
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
	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++) {
693
		pud_t *pud;
J
Jeremy Fitzhardinge 已提交
694

695 696
		if (pgdidx >= hole_low && pgdidx < hole_high)
			continue;
697

698
		if (!pgd_val(pgd[pgdidx]))
J
Jeremy Fitzhardinge 已提交
699
			continue;
700

701
		pud = pud_offset(&pgd[pgdidx], 0);
J
Jeremy Fitzhardinge 已提交
702 703

		if (PTRS_PER_PUD > 1) /* not folded */
704
			flush |= (*func)(mm, virt_to_page(pud), PT_PUD);
705

706
		for (pudidx = 0; pudidx < PTRS_PER_PUD; pudidx++) {
707 708
			pmd_t *pmd;

709 710 711
			if (pgdidx == pgdidx_limit &&
			    pudidx > pudidx_limit)
				goto out;
J
Jeremy Fitzhardinge 已提交
712

713
			if (pud_none(pud[pudidx]))
J
Jeremy Fitzhardinge 已提交
714
				continue;
715

716
			pmd = pmd_offset(&pud[pudidx], 0);
J
Jeremy Fitzhardinge 已提交
717 718

			if (PTRS_PER_PMD > 1) /* not folded */
719
				flush |= (*func)(mm, virt_to_page(pmd), PT_PMD);
720

721 722 723 724 725 726 727
			for (pmdidx = 0; pmdidx < PTRS_PER_PMD; pmdidx++) {
				struct page *pte;

				if (pgdidx == pgdidx_limit &&
				    pudidx == pudidx_limit &&
				    pmdidx > pmdidx_limit)
					goto out;
J
Jeremy Fitzhardinge 已提交
728

729
				if (pmd_none(pmd[pmdidx]))
J
Jeremy Fitzhardinge 已提交
730 731
					continue;

732
				pte = pmd_page(pmd[pmdidx]);
733
				flush |= (*func)(mm, pte, PT_PTE);
J
Jeremy Fitzhardinge 已提交
734 735 736
			}
		}
	}
737

738
out:
739 740
	/* Do the top level last, so that the callbacks can use it as
	   a cue to do final things like tlb flushes. */
741
	flush |= (*func)(mm, virt_to_page(pgd), PT_PGD);
742 743

	return flush;
J
Jeremy Fitzhardinge 已提交
744 745
}

746 747
/* If we're using split pte locks, then take the page's lock and
   return a pointer to it.  Otherwise return NULL. */
748
static spinlock_t *xen_pte_lock(struct page *page, struct mm_struct *mm)
749 750 751
{
	spinlock_t *ptl = NULL;

752
#if USE_SPLIT_PTLOCKS
753
	ptl = __pte_lockptr(page);
754
	spin_lock_nest_lock(ptl, &mm->page_table_lock);
755 756 757 758 759
#endif

	return ptl;
}

760
static void xen_pte_unlock(void *v)
761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777
{
	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);
}

778 779
static int xen_pin_page(struct mm_struct *mm, struct page *page,
			enum pt_level level)
780
{
781
	unsigned pgfl = TestSetPagePinned(page);
782 783 784 785 786 787 788 789 790 791 792 793
	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);
794
		spinlock_t *ptl;
795 796 797

		flush = 0;

798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817
		/*
		 * 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.
		 */
818 819
		ptl = NULL;
		if (level == PT_PTE)
820
			ptl = xen_pte_lock(page, mm);
821

822 823
		MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
					pfn_pte(pfn, PAGE_KERNEL_RO),
824 825
					level == PT_PGD ? UVMF_TLB_FLUSH : 0);

826
		if (ptl) {
827 828 829 830
			xen_do_pin(MMUEXT_PIN_L1_TABLE, pfn);

			/* Queue a deferred unlock for when this batch
			   is completed. */
831
			xen_mc_callback(xen_pte_unlock, ptl);
832
		}
833 834 835 836
	}

	return flush;
}
J
Jeremy Fitzhardinge 已提交
837

838 839 840
/* 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. */
841
static void __xen_pgd_pin(struct mm_struct *mm, pgd_t *pgd)
J
Jeremy Fitzhardinge 已提交
842
{
843
	xen_mc_batch();
J
Jeremy Fitzhardinge 已提交
844

845
	if (xen_pgd_walk(mm, xen_pin_page, USER_LIMIT)) {
J
Jeremy Fitzhardinge 已提交
846 847
		/* re-enable interrupts for kmap_flush_unused */
		xen_mc_issue(0);
848
		kmap_flush_unused();
N
Nick Piggin 已提交
849
		vm_unmap_aliases();
J
Jeremy Fitzhardinge 已提交
850 851
		xen_mc_batch();
	}
852

853 854 855 856 857 858 859
#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) {
860
			xen_pin_page(mm, virt_to_page(user_pgd), PT_PGD);
861 862 863 864
			xen_do_pin(MMUEXT_PIN_L4_TABLE, PFN_DOWN(__pa(user_pgd)));
		}
	}
#else /* CONFIG_X86_32 */
865 866
#ifdef CONFIG_X86_PAE
	/* Need to make sure unshared kernel PMD is pinnable */
867 868
	xen_pin_page(mm, virt_to_page(pgd_page(pgd[pgd_index(TASK_SIZE)])),
		     PT_PMD);
869
#endif
870
	xen_do_pin(MMUEXT_PIN_L3_TABLE, PFN_DOWN(__pa(pgd)));
871
#endif /* CONFIG_X86_64 */
872
	xen_mc_issue(0);
J
Jeremy Fitzhardinge 已提交
873 874
}

875 876 877 878 879
static void xen_pgd_pin(struct mm_struct *mm)
{
	__xen_pgd_pin(mm, mm->pgd);
}

880 881 882 883 884
/*
 * 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).
885 886 887 888
 *
 * 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.
889 890 891 892 893
 */
void xen_mm_pin_all(void)
{
	unsigned long flags;
	struct page *page;
894

895
	spin_lock_irqsave(&pgd_lock, flags);
896

897 898
	list_for_each_entry(page, &pgd_list, lru) {
		if (!PagePinned(page)) {
899
			__xen_pgd_pin(&init_mm, (pgd_t *)page_address(page));
900 901 902 903 904
			SetPageSavePinned(page);
		}
	}

	spin_unlock_irqrestore(&pgd_lock, flags);
J
Jeremy Fitzhardinge 已提交
905 906
}

907 908 909 910 911
/*
 * 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.
 */
912 913
static __init int xen_mark_pinned(struct mm_struct *mm, struct page *page,
				  enum pt_level level)
J
Jeremy Fitzhardinge 已提交
914
{
915 916 917
	SetPagePinned(page);
	return 0;
}
J
Jeremy Fitzhardinge 已提交
918

919 920
void __init xen_mark_init_mm_pinned(void)
{
921
	xen_pgd_walk(&init_mm, xen_mark_pinned, FIXADDR_TOP);
922
}
J
Jeremy Fitzhardinge 已提交
923

924 925
static int xen_unpin_page(struct mm_struct *mm, struct page *page,
			  enum pt_level level)
926
{
927
	unsigned pgfl = TestClearPagePinned(page);
J
Jeremy Fitzhardinge 已提交
928

929 930 931
	if (pgfl && !PageHighMem(page)) {
		void *pt = lowmem_page_address(page);
		unsigned long pfn = page_to_pfn(page);
932 933 934
		spinlock_t *ptl = NULL;
		struct multicall_space mcs;

935 936 937 938 939 940 941
		/*
		 * 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.
		 */
942
		if (level == PT_PTE) {
943
			ptl = xen_pte_lock(page, mm);
944

945 946
			if (ptl)
				xen_do_pin(MMUEXT_UNPIN_TABLE, pfn);
947 948 949
		}

		mcs = __xen_mc_entry(0);
950 951 952

		MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
					pfn_pte(pfn, PAGE_KERNEL),
953 954 955 956
					level == PT_PGD ? UVMF_TLB_FLUSH : 0);

		if (ptl) {
			/* unlock when batch completed */
957
			xen_mc_callback(xen_pte_unlock, ptl);
958
		}
959 960 961
	}

	return 0;		/* never need to flush on unpin */
J
Jeremy Fitzhardinge 已提交
962 963
}

964
/* Release a pagetables pages back as normal RW */
965
static void __xen_pgd_unpin(struct mm_struct *mm, pgd_t *pgd)
966 967 968
{
	xen_mc_batch();

969
	xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(pgd)));
970

971 972 973 974 975 976
#ifdef CONFIG_X86_64
	{
		pgd_t *user_pgd = xen_get_user_pgd(pgd);

		if (user_pgd) {
			xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(user_pgd)));
977
			xen_unpin_page(mm, virt_to_page(user_pgd), PT_PGD);
978 979 980 981
		}
	}
#endif

982 983
#ifdef CONFIG_X86_PAE
	/* Need to make sure unshared kernel PMD is unpinned */
984 985
	xen_unpin_page(mm, virt_to_page(pgd_page(pgd[pgd_index(TASK_SIZE)])),
		       PT_PMD);
986
#endif
987

988
	xen_pgd_walk(mm, xen_unpin_page, USER_LIMIT);
989 990 991

	xen_mc_issue(0);
}
J
Jeremy Fitzhardinge 已提交
992

993 994 995 996 997
static void xen_pgd_unpin(struct mm_struct *mm)
{
	__xen_pgd_unpin(mm, mm->pgd);
}

998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
/*
 * 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));
1012
			__xen_pgd_unpin(&init_mm, (pgd_t *)page_address(page));
1013 1014 1015 1016 1017 1018 1019
			ClearPageSavePinned(page);
		}
	}

	spin_unlock_irqrestore(&pgd_lock, flags);
}

J
Jeremy Fitzhardinge 已提交
1020 1021
void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
{
1022
	spin_lock(&next->page_table_lock);
1023
	xen_pgd_pin(next);
1024
	spin_unlock(&next->page_table_lock);
J
Jeremy Fitzhardinge 已提交
1025 1026 1027 1028
}

void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
{
1029
	spin_lock(&mm->page_table_lock);
1030
	xen_pgd_pin(mm);
1031
	spin_unlock(&mm->page_table_lock);
J
Jeremy Fitzhardinge 已提交
1032 1033 1034
}


J
Jeremy Fitzhardinge 已提交
1035 1036 1037 1038 1039 1040
#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;
1041
	struct mm_struct *active_mm;
J
Jeremy Fitzhardinge 已提交
1042

1043 1044 1045 1046 1047 1048 1049
#ifdef CONFIG_X86_64
	active_mm = read_pda(active_mm);
#else
	active_mm = __get_cpu_var(cpu_tlbstate).active_mm;
#endif

	if (active_mm == mm)
J
Jeremy Fitzhardinge 已提交
1050
		leave_mm(smp_processor_id());
1051 1052 1053 1054 1055 1056 1057

	/* If this cpu still has a stale cr3 reference, then make sure
	   it has been flushed. */
	if (x86_read_percpu(xen_current_cr3) == __pa(mm->pgd)) {
		load_cr3(swapper_pg_dir);
		arch_flush_lazy_cpu_mode();
	}
J
Jeremy Fitzhardinge 已提交
1058
}
J
Jeremy Fitzhardinge 已提交
1059

1060
static void xen_drop_mm_ref(struct mm_struct *mm)
J
Jeremy Fitzhardinge 已提交
1061
{
1062 1063 1064
	cpumask_t mask;
	unsigned cpu;

J
Jeremy Fitzhardinge 已提交
1065 1066 1067 1068 1069
	if (current->active_mm == mm) {
		if (current->mm == mm)
			load_cr3(swapper_pg_dir);
		else
			leave_mm(smp_processor_id());
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
		arch_flush_lazy_cpu_mode();
	}

	/* Get the "official" set of cpus referring to our pagetable. */
	mask = mm->cpu_vm_mask;

	/* 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))
			cpu_set(cpu, mask);
J
Jeremy Fitzhardinge 已提交
1084 1085
	}

1086
	if (!cpus_empty(mask))
1087
		smp_call_function_mask(mask, drop_other_mm_ref, mm, 1);
J
Jeremy Fitzhardinge 已提交
1088 1089
}
#else
1090
static void xen_drop_mm_ref(struct mm_struct *mm)
J
Jeremy Fitzhardinge 已提交
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
{
	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 */
1114
	xen_drop_mm_ref(mm);
J
Jeremy Fitzhardinge 已提交
1115
	put_cpu();
J
Jeremy Fitzhardinge 已提交
1116

1117
	spin_lock(&mm->page_table_lock);
1118 1119

	/* pgd may not be pinned in the error exit path of execve */
1120
	if (xen_page_pinned(mm->pgd))
1121
		xen_pgd_unpin(mm);
1122

1123
	spin_unlock(&mm->page_table_lock);
J
Jeremy Fitzhardinge 已提交
1124
}
J
Jeremy Fitzhardinge 已提交
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187

#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 */