mmu.c 29.9 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
/* Build the parallel p2m_top_mfn structures */
void xen_setup_mfn_list_list(void)
{
	unsigned pfn, idx;

T
Tej 已提交
157
	for (pfn = 0; pfn < MAX_DOMAIN_PAGES; pfn += P2M_ENTRIES_PER_PAGE) {
J
Jeremy Fitzhardinge 已提交
158 159 160 161 162
		unsigned topidx = p2m_top_index(pfn);

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

T
Tej 已提交
163
	for (idx = 0; idx < ARRAY_SIZE(p2m_top_mfn_list); idx++) {
J
Jeremy Fitzhardinge 已提交
164 165 166 167 168 169 170 171 172 173 174 175
		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

T
Tej 已提交
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
{
	unsigned long *p;
	unsigned i;

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

T
Tej 已提交
210
	for (i = 0; i < P2M_ENTRIES_PER_PAGE; i++)
211 212
		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 250
	pte_t *pte;
	unsigned offset;
J
Jeremy Fitzhardinge 已提交
251

252 253 254 255 256 257 258 259
	/*
	 * 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 */
J
Jeremy Fitzhardinge 已提交
260

261 262 263
	pte = lookup_address(address, &level);
	BUG_ON(pte == NULL);
	offset = address & ~PAGE_MASK;
264
	return XMADDR(((phys_addr_t)pte_mfn(*pte) << PAGE_SHIFT) + offset);
J
Jeremy Fitzhardinge 已提交
265 266 267 268 269 270
}

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

273
	pte = lookup_address(address, &level);
J
Jeremy Fitzhardinge 已提交
274 275 276 277 278 279 280 281 282 283 284 285
	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;
286
	unsigned int level;
J
Jeremy Fitzhardinge 已提交
287

288
	pte = lookup_address(address, &level);
J
Jeremy Fitzhardinge 已提交
289 290 291 292 293 294 295 296 297
	BUG_ON(pte == NULL);

	ptev = pte_mkwrite(*pte);

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


298
static bool xen_page_pinned(void *ptr)
299 300 301 302 303 304
{
	struct page *page = virt_to_page(ptr);

	return PagePinned(page);
}

305
static void xen_extend_mmu_update(const struct mmu_update *update)
J
Jeremy Fitzhardinge 已提交
306
{
J
Jeremy Fitzhardinge 已提交
307 308
	struct multicall_space mcs;
	struct mmu_update *u;
J
Jeremy Fitzhardinge 已提交
309

310 311
	mcs = xen_mc_extend_args(__HYPERVISOR_mmu_update, sizeof(*u));

J
Jeremy Fitzhardinge 已提交
312 313 314 315
	if (mcs.mc != NULL) {
		ADD_STATS(mmu_update_extended, 1);
		ADD_STATS(mmu_update_histo[mcs.mc->args[1]], -1);

316
		mcs.mc->args[1]++;
J
Jeremy Fitzhardinge 已提交
317 318 319 320 321 322 323

		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);
324 325
		mcs = __xen_mc_entry(sizeof(*u));
		MULTI_mmu_update(mcs.mc, mcs.args, 1, NULL, DOMID_SELF);
J
Jeremy Fitzhardinge 已提交
326
		ADD_STATS(mmu_update_histo[1], 1);
327
	}
J
Jeremy Fitzhardinge 已提交
328 329

	u = mcs.args;
330 331 332 333 334 335 336 337 338 339 340
	*u = *update;
}

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

	preempt_disable();

	xen_mc_batch();

341 342
	/* ptr may be ioremapped for 64-bit pagetable setup */
	u.ptr = arbitrary_virt_to_machine(ptr).maddr;
343
	u.val = pmd_val_ma(val);
344
	xen_extend_mmu_update(&u);
J
Jeremy Fitzhardinge 已提交
345

J
Jeremy Fitzhardinge 已提交
346 347
	ADD_STATS(pmd_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);

J
Jeremy Fitzhardinge 已提交
348 349 350
	xen_mc_issue(PARAVIRT_LAZY_MMU);

	preempt_enable();
J
Jeremy Fitzhardinge 已提交
351 352
}

353 354
void xen_set_pmd(pmd_t *ptr, pmd_t val)
{
J
Jeremy Fitzhardinge 已提交
355 356
	ADD_STATS(pmd_update, 1);

357 358
	/* If page is not pinned, we can just update the entry
	   directly */
359
	if (!xen_page_pinned(ptr)) {
360 361 362 363
		*ptr = val;
		return;
	}

J
Jeremy Fitzhardinge 已提交
364 365
	ADD_STATS(pmd_update_pinned, 1);

366 367 368
	xen_set_pmd_hyper(ptr, val);
}

J
Jeremy Fitzhardinge 已提交
369 370 371 372 373 374
/*
 * 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 已提交
375
	set_pte_vaddr(vaddr, mfn_pte(mfn, flags));
J
Jeremy Fitzhardinge 已提交
376 377 378 379 380
}

void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
		    pte_t *ptep, pte_t pteval)
{
381 382 383 384
	/* updates to init_mm may be done without lock */
	if (mm == &init_mm)
		preempt_disable();

J
Jeremy Fitzhardinge 已提交
385 386 387 388 389
	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 已提交
390
	if (mm == current->mm || mm == &init_mm) {
391
		if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
J
Jeremy Fitzhardinge 已提交
392 393 394 395
			struct multicall_space mcs;
			mcs = xen_mc_entry(0);

			MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);
J
Jeremy Fitzhardinge 已提交
396
			ADD_STATS(set_pte_at_batched, 1);
J
Jeremy Fitzhardinge 已提交
397
			xen_mc_issue(PARAVIRT_LAZY_MMU);
398
			goto out;
J
Jeremy Fitzhardinge 已提交
399 400
		} else
			if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)
401
				goto out;
J
Jeremy Fitzhardinge 已提交
402 403
	}
	xen_set_pte(ptep, pteval);
404 405 406 407

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

T
Tej 已提交
410 411
pte_t xen_ptep_modify_prot_start(struct mm_struct *mm,
				 unsigned long addr, pte_t *ptep)
J
Jeremy Fitzhardinge 已提交
412
{
413 414 415 416 417 418 419
	/* 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)
{
420
	struct mmu_update u;
421

422
	xen_mc_batch();
J
Jeremy Fitzhardinge 已提交
423

424
	u.ptr = arbitrary_virt_to_machine(ptep).maddr | MMU_PT_UPDATE_PRESERVE_AD;
425
	u.val = pte_val_ma(pte);
426
	xen_extend_mmu_update(&u);
J
Jeremy Fitzhardinge 已提交
427

J
Jeremy Fitzhardinge 已提交
428 429 430
	ADD_STATS(prot_commit, 1);
	ADD_STATS(prot_commit_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);

431
	xen_mc_issue(PARAVIRT_LAZY_MMU);
J
Jeremy Fitzhardinge 已提交
432 433
}

J
Jeremy Fitzhardinge 已提交
434 435
/* 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 已提交
436
{
J
Jeremy Fitzhardinge 已提交
437
	if (val & _PAGE_PRESENT) {
438
		unsigned long mfn = (val & PTE_PFN_MASK) >> PAGE_SHIFT;
J
Jeremy Fitzhardinge 已提交
439
		pteval_t flags = val & PTE_FLAGS_MASK;
440
		val = ((pteval_t)mfn_to_pfn(mfn) << PAGE_SHIFT) | flags;
J
Jeremy Fitzhardinge 已提交
441
	}
J
Jeremy Fitzhardinge 已提交
442

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

J
Jeremy Fitzhardinge 已提交
446
static pteval_t pte_pfn_to_mfn(pteval_t val)
J
Jeremy Fitzhardinge 已提交
447
{
J
Jeremy Fitzhardinge 已提交
448
	if (val & _PAGE_PRESENT) {
449
		unsigned long pfn = (val & PTE_PFN_MASK) >> PAGE_SHIFT;
J
Jeremy Fitzhardinge 已提交
450
		pteval_t flags = val & PTE_FLAGS_MASK;
451
		val = ((pteval_t)pfn_to_mfn(pfn) << PAGE_SHIFT) | flags;
J
Jeremy Fitzhardinge 已提交
452 453
	}

J
Jeremy Fitzhardinge 已提交
454
	return val;
J
Jeremy Fitzhardinge 已提交
455 456
}

J
Jeremy Fitzhardinge 已提交
457
pteval_t xen_pte_val(pte_t pte)
J
Jeremy Fitzhardinge 已提交
458
{
J
Jeremy Fitzhardinge 已提交
459
	return pte_mfn_to_pfn(pte.pte);
J
Jeremy Fitzhardinge 已提交
460 461 462 463
}

pgdval_t xen_pgd_val(pgd_t pgd)
{
J
Jeremy Fitzhardinge 已提交
464
	return pte_mfn_to_pfn(pgd.pgd);
J
Jeremy Fitzhardinge 已提交
465 466 467 468
}

pte_t xen_make_pte(pteval_t pte)
{
J
Jeremy Fitzhardinge 已提交
469 470
	pte = pte_pfn_to_mfn(pte);
	return native_make_pte(pte);
J
Jeremy Fitzhardinge 已提交
471 472 473 474
}

pgd_t xen_make_pgd(pgdval_t pgd)
{
J
Jeremy Fitzhardinge 已提交
475 476
	pgd = pte_pfn_to_mfn(pgd);
	return native_make_pgd(pgd);
J
Jeremy Fitzhardinge 已提交
477 478 479 480
}

pmdval_t xen_pmd_val(pmd_t pmd)
{
J
Jeremy Fitzhardinge 已提交
481
	return pte_mfn_to_pfn(pmd.pmd);
J
Jeremy Fitzhardinge 已提交
482
}
483

484
void xen_set_pud_hyper(pud_t *ptr, pud_t val)
485
{
486
	struct mmu_update u;
487

J
Jeremy Fitzhardinge 已提交
488 489
	preempt_disable();

490 491
	xen_mc_batch();

492 493
	/* ptr may be ioremapped for 64-bit pagetable setup */
	u.ptr = arbitrary_virt_to_machine(ptr).maddr;
494
	u.val = pud_val_ma(val);
495
	xen_extend_mmu_update(&u);
J
Jeremy Fitzhardinge 已提交
496

J
Jeremy Fitzhardinge 已提交
497 498
	ADD_STATS(pud_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);

J
Jeremy Fitzhardinge 已提交
499 500 501
	xen_mc_issue(PARAVIRT_LAZY_MMU);

	preempt_enable();
502 503
}

504 505
void xen_set_pud(pud_t *ptr, pud_t val)
{
J
Jeremy Fitzhardinge 已提交
506 507
	ADD_STATS(pud_update, 1);

508 509
	/* If page is not pinned, we can just update the entry
	   directly */
510
	if (!xen_page_pinned(ptr)) {
511 512 513 514
		*ptr = val;
		return;
	}

J
Jeremy Fitzhardinge 已提交
515 516
	ADD_STATS(pud_update_pinned, 1);

517 518 519
	xen_set_pud_hyper(ptr, val);
}

520 521
void xen_set_pte(pte_t *ptep, pte_t pte)
{
J
Jeremy Fitzhardinge 已提交
522 523 524 525
	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);

526
#ifdef CONFIG_X86_PAE
527 528 529
	ptep->pte_high = pte.pte_high;
	smp_wmb();
	ptep->pte_low = pte.pte_low;
530 531 532
#else
	*ptep = pte;
#endif
533 534
}

535
#ifdef CONFIG_X86_PAE
J
Jeremy Fitzhardinge 已提交
536 537
void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
{
538
	set_64bit((u64 *)ptep, native_pte_val(pte));
J
Jeremy Fitzhardinge 已提交
539 540 541 542 543 544 545 546 547 548 549
}

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)
{
550
	set_pmd(pmdp, __pmd(0));
J
Jeremy Fitzhardinge 已提交
551
}
552
#endif	/* CONFIG_X86_PAE */
J
Jeremy Fitzhardinge 已提交
553

554
pmd_t xen_make_pmd(pmdval_t pmd)
J
Jeremy Fitzhardinge 已提交
555
{
J
Jeremy Fitzhardinge 已提交
556
	pmd = pte_pfn_to_mfn(pmd);
J
Jeremy Fitzhardinge 已提交
557
	return native_make_pmd(pmd);
J
Jeremy Fitzhardinge 已提交
558 559
}

560 561 562 563 564 565 566 567 568 569 570 571 572
#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);
}

573
pgd_t *xen_get_user_pgd(pgd_t *pgd)
574
{
575 576 577
	pgd_t *pgd_page = (pgd_t *)(((unsigned long)pgd) & PAGE_MASK);
	unsigned offset = pgd - pgd_page;
	pgd_t *user_ptr = NULL;
578

579 580 581 582 583 584
	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;
	}
585

586 587 588 589 590 591
	return user_ptr;
}

static void __xen_set_pgd_hyper(pgd_t *ptr, pgd_t val)
{
	struct mmu_update u;
592 593 594

	u.ptr = virt_to_machine(ptr).maddr;
	u.val = pgd_val_ma(val);
595
	xen_extend_mmu_update(&u);
596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
}

/*
 * 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);
612 613 614 615 616 617 618 619

	xen_mc_issue(PARAVIRT_LAZY_MMU);

	preempt_enable();
}

void xen_set_pgd(pgd_t *ptr, pgd_t val)
{
620 621
	pgd_t *user_ptr = xen_get_user_pgd(ptr);

J
Jeremy Fitzhardinge 已提交
622 623
	ADD_STATS(pgd_update, 1);

624 625
	/* If page is not pinned, we can just update the entry
	   directly */
626
	if (!xen_page_pinned(ptr)) {
627
		*ptr = val;
628
		if (user_ptr) {
629
			WARN_ON(xen_page_pinned(user_ptr));
630 631
			*user_ptr = val;
		}
632 633 634
		return;
	}

J
Jeremy Fitzhardinge 已提交
635 636 637
	ADD_STATS(pgd_update_pinned, 1);
	ADD_STATS(pgd_update_batched, paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU);

638 639 640 641 642 643 644 645 646
	/* 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);
647 648 649
}
#endif	/* PAGETABLE_LEVELS == 4 */

650
/*
651 652 653 654 655 656 657 658 659 660 661 662 663 664
 * (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.
 */
I
Ian Campbell 已提交
665 666 667 668
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)
J
Jeremy Fitzhardinge 已提交
669
{
670
	int flush = 0;
671 672 673
	unsigned hole_low, hole_high;
	unsigned pgdidx_limit, pudidx_limit, pmdidx_limit;
	unsigned pgdidx, pudidx, pmdidx;
674

675 676 677
	/* The limit is the last byte to be touched */
	limit--;
	BUG_ON(limit >= FIXADDR_TOP);
J
Jeremy Fitzhardinge 已提交
678 679

	if (xen_feature(XENFEAT_auto_translated_physmap))
680 681
		return 0;

682 683 684 685 686
	/*
	 * 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.
	 */
687
	hole_low = pgd_index(USER_LIMIT);
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
	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++) {
703
		pud_t *pud;
J
Jeremy Fitzhardinge 已提交
704

705 706
		if (pgdidx >= hole_low && pgdidx < hole_high)
			continue;
707

708
		if (!pgd_val(pgd[pgdidx]))
J
Jeremy Fitzhardinge 已提交
709
			continue;
710

711
		pud = pud_offset(&pgd[pgdidx], 0);
J
Jeremy Fitzhardinge 已提交
712 713

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

716
		for (pudidx = 0; pudidx < PTRS_PER_PUD; pudidx++) {
717 718
			pmd_t *pmd;

719 720 721
			if (pgdidx == pgdidx_limit &&
			    pudidx > pudidx_limit)
				goto out;
J
Jeremy Fitzhardinge 已提交
722

723
			if (pud_none(pud[pudidx]))
J
Jeremy Fitzhardinge 已提交
724
				continue;
725

726
			pmd = pmd_offset(&pud[pudidx], 0);
J
Jeremy Fitzhardinge 已提交
727 728

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

731 732 733 734 735 736 737
			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 已提交
738

739
				if (pmd_none(pmd[pmdidx]))
J
Jeremy Fitzhardinge 已提交
740 741
					continue;

742
				pte = pmd_page(pmd[pmdidx]);
743
				flush |= (*func)(mm, pte, PT_PTE);
J
Jeremy Fitzhardinge 已提交
744 745 746
			}
		}
	}
747

748
out:
749 750
	/* Do the top level last, so that the callbacks can use it as
	   a cue to do final things like tlb flushes. */
751
	flush |= (*func)(mm, virt_to_page(pgd), PT_PGD);
752 753

	return flush;
J
Jeremy Fitzhardinge 已提交
754 755
}

I
Ian Campbell 已提交
756 757 758 759 760 761 762 763
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);
}

764 765
/* If we're using split pte locks, then take the page's lock and
   return a pointer to it.  Otherwise return NULL. */
766
static spinlock_t *xen_pte_lock(struct page *page, struct mm_struct *mm)
767 768 769
{
	spinlock_t *ptl = NULL;

770
#if USE_SPLIT_PTLOCKS
771
	ptl = __pte_lockptr(page);
772
	spin_lock_nest_lock(ptl, &mm->page_table_lock);
773 774 775 776 777
#endif

	return ptl;
}

778
static void xen_pte_unlock(void *v)
779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
{
	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);
}

796 797
static int xen_pin_page(struct mm_struct *mm, struct page *page,
			enum pt_level level)
798
{
799
	unsigned pgfl = TestSetPagePinned(page);
800 801 802 803 804 805 806 807 808 809 810 811
	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);
812
		spinlock_t *ptl;
813 814 815

		flush = 0;

816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
		/*
		 * 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.
		 */
836 837
		ptl = NULL;
		if (level == PT_PTE)
838
			ptl = xen_pte_lock(page, mm);
839

840 841
		MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
					pfn_pte(pfn, PAGE_KERNEL_RO),
842 843
					level == PT_PGD ? UVMF_TLB_FLUSH : 0);

844
		if (ptl) {
845 846 847 848
			xen_do_pin(MMUEXT_PIN_L1_TABLE, pfn);

			/* Queue a deferred unlock for when this batch
			   is completed. */
849
			xen_mc_callback(xen_pte_unlock, ptl);
850
		}
851 852 853 854
	}

	return flush;
}
J
Jeremy Fitzhardinge 已提交
855

856 857 858
/* 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. */
859
static void __xen_pgd_pin(struct mm_struct *mm, pgd_t *pgd)
J
Jeremy Fitzhardinge 已提交
860
{
861 862
	vm_unmap_aliases();

863
	xen_mc_batch();
J
Jeremy Fitzhardinge 已提交
864

I
Ian Campbell 已提交
865
	if (__xen_pgd_walk(mm, pgd, xen_pin_page, USER_LIMIT)) {
866
		/* re-enable interrupts for flushing */
J
Jeremy Fitzhardinge 已提交
867
		xen_mc_issue(0);
868

869
		kmap_flush_unused();
870

J
Jeremy Fitzhardinge 已提交
871 872
		xen_mc_batch();
	}
873

874 875 876 877 878 879 880
#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) {
881
			xen_pin_page(mm, virt_to_page(user_pgd), PT_PGD);
T
Tej 已提交
882 883
			xen_do_pin(MMUEXT_PIN_L4_TABLE,
				   PFN_DOWN(__pa(user_pgd)));
884 885 886
		}
	}
#else /* CONFIG_X86_32 */
887 888
#ifdef CONFIG_X86_PAE
	/* Need to make sure unshared kernel PMD is pinnable */
889
	xen_pin_page(mm, pgd_page(pgd[pgd_index(TASK_SIZE)]),
890
		     PT_PMD);
891
#endif
892
	xen_do_pin(MMUEXT_PIN_L3_TABLE, PFN_DOWN(__pa(pgd)));
893
#endif /* CONFIG_X86_64 */
894
	xen_mc_issue(0);
J
Jeremy Fitzhardinge 已提交
895 896
}

897 898 899 900 901
static void xen_pgd_pin(struct mm_struct *mm)
{
	__xen_pgd_pin(mm, mm->pgd);
}

902 903 904 905 906
/*
 * 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).
907 908 909 910
 *
 * 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.
911 912 913 914 915
 */
void xen_mm_pin_all(void)
{
	unsigned long flags;
	struct page *page;
916

917
	spin_lock_irqsave(&pgd_lock, flags);
918

919 920
	list_for_each_entry(page, &pgd_list, lru) {
		if (!PagePinned(page)) {
921
			__xen_pgd_pin(&init_mm, (pgd_t *)page_address(page));
922 923 924 925 926
			SetPageSavePinned(page);
		}
	}

	spin_unlock_irqrestore(&pgd_lock, flags);
J
Jeremy Fitzhardinge 已提交
927 928
}

929 930 931 932 933
/*
 * 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.
 */
934 935
static __init int xen_mark_pinned(struct mm_struct *mm, struct page *page,
				  enum pt_level level)
J
Jeremy Fitzhardinge 已提交
936
{
937 938 939
	SetPagePinned(page);
	return 0;
}
J
Jeremy Fitzhardinge 已提交
940

941 942
void __init xen_mark_init_mm_pinned(void)
{
943
	xen_pgd_walk(&init_mm, xen_mark_pinned, FIXADDR_TOP);
944
}
J
Jeremy Fitzhardinge 已提交
945

946 947
static int xen_unpin_page(struct mm_struct *mm, struct page *page,
			  enum pt_level level)
948
{
949
	unsigned pgfl = TestClearPagePinned(page);
J
Jeremy Fitzhardinge 已提交
950

951 952 953
	if (pgfl && !PageHighMem(page)) {
		void *pt = lowmem_page_address(page);
		unsigned long pfn = page_to_pfn(page);
954 955 956
		spinlock_t *ptl = NULL;
		struct multicall_space mcs;

957 958 959 960 961 962 963
		/*
		 * 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.
		 */
964
		if (level == PT_PTE) {
965
			ptl = xen_pte_lock(page, mm);
966

967 968
			if (ptl)
				xen_do_pin(MMUEXT_UNPIN_TABLE, pfn);
969 970 971
		}

		mcs = __xen_mc_entry(0);
972 973 974

		MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
					pfn_pte(pfn, PAGE_KERNEL),
975 976 977 978
					level == PT_PGD ? UVMF_TLB_FLUSH : 0);

		if (ptl) {
			/* unlock when batch completed */
979
			xen_mc_callback(xen_pte_unlock, ptl);
980
		}
981 982 983
	}

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

986
/* Release a pagetables pages back as normal RW */
987
static void __xen_pgd_unpin(struct mm_struct *mm, pgd_t *pgd)
988 989 990
{
	xen_mc_batch();

991
	xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(pgd)));
992

993 994 995 996 997
#ifdef CONFIG_X86_64
	{
		pgd_t *user_pgd = xen_get_user_pgd(pgd);

		if (user_pgd) {
T
Tej 已提交
998 999
			xen_do_pin(MMUEXT_UNPIN_TABLE,
				   PFN_DOWN(__pa(user_pgd)));
1000
			xen_unpin_page(mm, virt_to_page(user_pgd), PT_PGD);
1001 1002 1003 1004
		}
	}
#endif

1005 1006
#ifdef CONFIG_X86_PAE
	/* Need to make sure unshared kernel PMD is unpinned */
1007
	xen_unpin_page(mm, pgd_page(pgd[pgd_index(TASK_SIZE)]),
1008
		       PT_PMD);
1009
#endif
1010

I
Ian Campbell 已提交
1011
	__xen_pgd_walk(mm, pgd, xen_unpin_page, USER_LIMIT);
1012 1013 1014

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

1016 1017 1018 1019 1020
static void xen_pgd_unpin(struct mm_struct *mm)
{
	__xen_pgd_unpin(mm, mm->pgd);
}

1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
/*
 * 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));
1035
			__xen_pgd_unpin(&init_mm, (pgd_t *)page_address(page));
1036 1037 1038 1039 1040 1041 1042
			ClearPageSavePinned(page);
		}
	}

	spin_unlock_irqrestore(&pgd_lock, flags);
}

J
Jeremy Fitzhardinge 已提交
1043 1044
void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
{
1045
	spin_lock(&next->page_table_lock);
1046
	xen_pgd_pin(next);
1047
	spin_unlock(&next->page_table_lock);
J
Jeremy Fitzhardinge 已提交
1048 1049 1050 1051
}

void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
{
1052
	spin_lock(&mm->page_table_lock);
1053
	xen_pgd_pin(mm);
1054
	spin_unlock(&mm->page_table_lock);
J
Jeremy Fitzhardinge 已提交
1055 1056 1057
}


J
Jeremy Fitzhardinge 已提交
1058 1059 1060 1061 1062 1063
#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;
1064
	struct mm_struct *active_mm;
J
Jeremy Fitzhardinge 已提交
1065

1066
	active_mm = percpu_read(cpu_tlbstate.active_mm);
1067 1068

	if (active_mm == mm)
J
Jeremy Fitzhardinge 已提交
1069
		leave_mm(smp_processor_id());
1070 1071 1072

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

1079
static void xen_drop_mm_ref(struct mm_struct *mm)
J
Jeremy Fitzhardinge 已提交
1080
{
1081
	cpumask_var_t mask;
1082 1083
	unsigned cpu;

J
Jeremy Fitzhardinge 已提交
1084 1085 1086 1087 1088
	if (current->active_mm == mm) {
		if (current->mm == mm)
			load_cr3(swapper_pg_dir);
		else
			leave_mm(smp_processor_id());
1089 1090 1091 1092
		arch_flush_lazy_cpu_mode();
	}

	/* Get the "official" set of cpus referring to our pagetable. */
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
	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);
1103 1104 1105 1106 1107 1108 1109 1110

	/* 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))
1111
			cpumask_set_cpu(cpu, mask);
J
Jeremy Fitzhardinge 已提交
1112 1113
	}

1114 1115 1116
	if (!cpumask_empty(mask))
		smp_call_function_many(mask, drop_other_mm_ref, mm, 1);
	free_cpumask_var(mask);
J
Jeremy Fitzhardinge 已提交
1117 1118
}
#else
1119
static void xen_drop_mm_ref(struct mm_struct *mm)
J
Jeremy Fitzhardinge 已提交
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
{
	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 */
1143
	xen_drop_mm_ref(mm);
J
Jeremy Fitzhardinge 已提交
1144
	put_cpu();
J
Jeremy Fitzhardinge 已提交
1145

1146
	spin_lock(&mm->page_table_lock);
1147 1148

	/* pgd may not be pinned in the error exit path of execve */
1149
	if (xen_page_pinned(mm->pgd))
1150
		xen_pgd_unpin(mm);
1151

1152
	spin_unlock(&mm->page_table_lock);
J
Jeremy Fitzhardinge 已提交
1153
}
J
Jeremy Fitzhardinge 已提交
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 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216

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