mmu.c 23.8 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 44 45 46
#include <linux/bug.h>

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

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

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

58
#include "multicalls.h"
J
Jeremy Fitzhardinge 已提交
59 60
#include "mmu.h"

61 62 63 64 65 66 67
/*
 * 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)


68
#define P2M_ENTRIES_PER_PAGE	(PAGE_SIZE / sizeof(unsigned long))
69
#define TOP_ENTRIES		(MAX_DOMAIN_PAGES / P2M_ENTRIES_PER_PAGE)
70

71
/* Placeholder for holes in the address space */
72
static unsigned long p2m_missing[P2M_ENTRIES_PER_PAGE] __page_aligned_data =
73 74 75
		{ [ 0 ... P2M_ENTRIES_PER_PAGE-1 ] = ~0UL };

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

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

82 83
static unsigned long p2m_top_mfn_list[TOP_ENTRIES / P2M_ENTRIES_PER_PAGE]
	__page_aligned_bss;
J
Jeremy Fitzhardinge 已提交
84

85 86
static inline unsigned p2m_top_index(unsigned long pfn)
{
87
	BUG_ON(pfn >= MAX_DOMAIN_PAGES);
88 89 90 91 92 93 94 95
	return pfn / P2M_ENTRIES_PER_PAGE;
}

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

J
Jeremy Fitzhardinge 已提交
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
/* 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 */
120 121 122
void __init xen_build_dynamic_phys_to_machine(void)
{
	unsigned long *mfn_list = (unsigned long *)xen_start_info->mfn_list;
123
	unsigned long max_pfn = min(MAX_DOMAIN_PAGES, xen_start_info->nr_pages);
J
Jeremy Fitzhardinge 已提交
124
	unsigned pfn;
125

126
	for(pfn = 0; pfn < max_pfn; pfn += P2M_ENTRIES_PER_PAGE) {
127 128 129 130 131 132 133 134 135 136
		unsigned topidx = p2m_top_index(pfn);

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

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

137 138 139
	if (unlikely(pfn >= MAX_DOMAIN_PAGES))
		return INVALID_P2M_ENTRY;

140 141 142 143
	topidx = p2m_top_index(pfn);
	idx = p2m_index(pfn);
	return p2m_top[topidx][idx];
}
I
Ingo Molnar 已提交
144
EXPORT_SYMBOL_GPL(get_phys_to_machine);
145

J
Jeremy Fitzhardinge 已提交
146
static void alloc_p2m(unsigned long **pp, unsigned long *mfnp)
147 148 149 150 151 152 153 154 155 156
{
	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;

157
	if (cmpxchg(pp, p2m_missing, p) != p2m_missing)
158
		free_page((unsigned long)p);
J
Jeremy Fitzhardinge 已提交
159 160
	else
		*mfnp = virt_to_mfn(p);
161 162 163 164 165 166 167 168
}

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);
169 170 171 172 173
		return;
	}

	if (unlikely(pfn >= MAX_DOMAIN_PAGES)) {
		BUG_ON(mfn != INVALID_P2M_ENTRY);
174 175 176 177
		return;
	}

	topidx = p2m_top_index(pfn);
178
	if (p2m_top[topidx] == p2m_missing) {
179 180 181
		/* no need to allocate a page to store an invalid entry */
		if (mfn == INVALID_P2M_ENTRY)
			return;
J
Jeremy Fitzhardinge 已提交
182
		alloc_p2m(&p2m_top[topidx], &p2m_top_mfn[topidx]);
183 184 185 186 187 188
	}

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

189
xmaddr_t arbitrary_virt_to_machine(void *vaddr)
J
Jeremy Fitzhardinge 已提交
190
{
191
	unsigned long address = (unsigned long)vaddr;
192
	unsigned int level;
193
	pte_t *pte = lookup_address(address, &level);
194
	unsigned offset = address & ~PAGE_MASK;
J
Jeremy Fitzhardinge 已提交
195 196 197

	BUG_ON(pte == NULL);

198
	return XMADDR(((phys_addr_t)pte_mfn(*pte) << PAGE_SHIFT) + offset);
J
Jeremy Fitzhardinge 已提交
199 200 201 202 203 204
}

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

207
	pte = lookup_address(address, &level);
J
Jeremy Fitzhardinge 已提交
208 209 210 211 212 213 214 215 216 217 218 219
	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;
220
	unsigned int level;
J
Jeremy Fitzhardinge 已提交
221

222
	pte = lookup_address(address, &level);
J
Jeremy Fitzhardinge 已提交
223 224 225 226 227 228 229 230 231
	BUG_ON(pte == NULL);

	ptev = pte_mkwrite(*pte);

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


232 233 234 235 236 237 238
static bool page_pinned(void *ptr)
{
	struct page *page = virt_to_page(ptr);

	return PagePinned(page);
}

239
static void extend_mmu_update(const struct mmu_update *update)
J
Jeremy Fitzhardinge 已提交
240
{
J
Jeremy Fitzhardinge 已提交
241 242
	struct multicall_space mcs;
	struct mmu_update *u;
J
Jeremy Fitzhardinge 已提交
243

244 245 246 247 248 249 250 251
	mcs = xen_mc_extend_args(__HYPERVISOR_mmu_update, sizeof(*u));

	if (mcs.mc != NULL)
		mcs.mc->args[1]++;
	else {
		mcs = __xen_mc_entry(sizeof(*u));
		MULTI_mmu_update(mcs.mc, mcs.args, 1, NULL, DOMID_SELF);
	}
J
Jeremy Fitzhardinge 已提交
252 253

	u = mcs.args;
254 255 256 257 258 259 260 261 262 263 264
	*u = *update;
}

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

	preempt_disable();

	xen_mc_batch();

265 266
	/* ptr may be ioremapped for 64-bit pagetable setup */
	u.ptr = arbitrary_virt_to_machine(ptr).maddr;
267 268
	u.val = pmd_val_ma(val);
	extend_mmu_update(&u);
J
Jeremy Fitzhardinge 已提交
269 270 271 272

	xen_mc_issue(PARAVIRT_LAZY_MMU);

	preempt_enable();
J
Jeremy Fitzhardinge 已提交
273 274
}

275 276 277 278 279 280 281 282 283 284 285 286
void xen_set_pmd(pmd_t *ptr, pmd_t val)
{
	/* If page is not pinned, we can just update the entry
	   directly */
	if (!page_pinned(ptr)) {
		*ptr = val;
		return;
	}

	xen_set_pmd_hyper(ptr, val);
}

J
Jeremy Fitzhardinge 已提交
287 288 289 290 291 292
/*
 * 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 已提交
293
	set_pte_vaddr(vaddr, mfn_pte(mfn, flags));
J
Jeremy Fitzhardinge 已提交
294 295 296 297 298
}

void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
		    pte_t *ptep, pte_t pteval)
{
299 300 301 302
	/* updates to init_mm may be done without lock */
	if (mm == &init_mm)
		preempt_disable();

J
Jeremy Fitzhardinge 已提交
303
	if (mm == current->mm || mm == &init_mm) {
304
		if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
J
Jeremy Fitzhardinge 已提交
305 306 307 308 309
			struct multicall_space mcs;
			mcs = xen_mc_entry(0);

			MULTI_update_va_mapping(mcs.mc, addr, pteval, 0);
			xen_mc_issue(PARAVIRT_LAZY_MMU);
310
			goto out;
J
Jeremy Fitzhardinge 已提交
311 312
		} else
			if (HYPERVISOR_update_va_mapping(addr, pteval, 0) == 0)
313
				goto out;
J
Jeremy Fitzhardinge 已提交
314 315
	}
	xen_set_pte(ptep, pteval);
316 317 318 319

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

322
pte_t xen_ptep_modify_prot_start(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
J
Jeremy Fitzhardinge 已提交
323
{
324 325 326 327 328 329 330
	/* 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)
{
331
	struct mmu_update u;
332

333
	xen_mc_batch();
J
Jeremy Fitzhardinge 已提交
334

335 336 337
	u.ptr = virt_to_machine(ptep).maddr | MMU_PT_UPDATE_PRESERVE_AD;
	u.val = pte_val_ma(pte);
	extend_mmu_update(&u);
J
Jeremy Fitzhardinge 已提交
338

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

J
Jeremy Fitzhardinge 已提交
342 343
/* 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 已提交
344
{
J
Jeremy Fitzhardinge 已提交
345
	if (val & _PAGE_PRESENT) {
346
		unsigned long mfn = (val & PTE_PFN_MASK) >> PAGE_SHIFT;
J
Jeremy Fitzhardinge 已提交
347
		pteval_t flags = val & PTE_FLAGS_MASK;
348
		val = ((pteval_t)mfn_to_pfn(mfn) << PAGE_SHIFT) | flags;
J
Jeremy Fitzhardinge 已提交
349
	}
J
Jeremy Fitzhardinge 已提交
350

J
Jeremy Fitzhardinge 已提交
351
	return val;
J
Jeremy Fitzhardinge 已提交
352 353
}

J
Jeremy Fitzhardinge 已提交
354
static pteval_t pte_pfn_to_mfn(pteval_t val)
J
Jeremy Fitzhardinge 已提交
355
{
J
Jeremy Fitzhardinge 已提交
356
	if (val & _PAGE_PRESENT) {
357
		unsigned long pfn = (val & PTE_PFN_MASK) >> PAGE_SHIFT;
J
Jeremy Fitzhardinge 已提交
358
		pteval_t flags = val & PTE_FLAGS_MASK;
359
		val = ((pteval_t)pfn_to_mfn(pfn) << PAGE_SHIFT) | flags;
J
Jeremy Fitzhardinge 已提交
360 361
	}

J
Jeremy Fitzhardinge 已提交
362
	return val;
J
Jeremy Fitzhardinge 已提交
363 364
}

J
Jeremy Fitzhardinge 已提交
365
pteval_t xen_pte_val(pte_t pte)
J
Jeremy Fitzhardinge 已提交
366
{
J
Jeremy Fitzhardinge 已提交
367
	return pte_mfn_to_pfn(pte.pte);
J
Jeremy Fitzhardinge 已提交
368 369 370 371
}

pgdval_t xen_pgd_val(pgd_t pgd)
{
J
Jeremy Fitzhardinge 已提交
372
	return pte_mfn_to_pfn(pgd.pgd);
J
Jeremy Fitzhardinge 已提交
373 374 375 376
}

pte_t xen_make_pte(pteval_t pte)
{
J
Jeremy Fitzhardinge 已提交
377 378
	pte = pte_pfn_to_mfn(pte);
	return native_make_pte(pte);
J
Jeremy Fitzhardinge 已提交
379 380 381 382
}

pgd_t xen_make_pgd(pgdval_t pgd)
{
J
Jeremy Fitzhardinge 已提交
383 384
	pgd = pte_pfn_to_mfn(pgd);
	return native_make_pgd(pgd);
J
Jeremy Fitzhardinge 已提交
385 386 387 388
}

pmdval_t xen_pmd_val(pmd_t pmd)
{
J
Jeremy Fitzhardinge 已提交
389
	return pte_mfn_to_pfn(pmd.pmd);
J
Jeremy Fitzhardinge 已提交
390
}
391

392
void xen_set_pud_hyper(pud_t *ptr, pud_t val)
393
{
394
	struct mmu_update u;
395

J
Jeremy Fitzhardinge 已提交
396 397
	preempt_disable();

398 399
	xen_mc_batch();

400 401
	/* ptr may be ioremapped for 64-bit pagetable setup */
	u.ptr = arbitrary_virt_to_machine(ptr).maddr;
402 403
	u.val = pud_val_ma(val);
	extend_mmu_update(&u);
J
Jeremy Fitzhardinge 已提交
404 405 406 407

	xen_mc_issue(PARAVIRT_LAZY_MMU);

	preempt_enable();
408 409
}

410 411 412 413 414 415 416 417 418 419 420 421
void xen_set_pud(pud_t *ptr, pud_t val)
{
	/* If page is not pinned, we can just update the entry
	   directly */
	if (!page_pinned(ptr)) {
		*ptr = val;
		return;
	}

	xen_set_pud_hyper(ptr, val);
}

422 423
void xen_set_pte(pte_t *ptep, pte_t pte)
{
424
#ifdef CONFIG_X86_PAE
425 426 427
	ptep->pte_high = pte.pte_high;
	smp_wmb();
	ptep->pte_low = pte.pte_low;
428 429 430
#else
	*ptep = pte;
#endif
431 432
}

433
#ifdef CONFIG_X86_PAE
J
Jeremy Fitzhardinge 已提交
434 435
void xen_set_pte_atomic(pte_t *ptep, pte_t pte)
{
436
	set_64bit((u64 *)ptep, native_pte_val(pte));
J
Jeremy Fitzhardinge 已提交
437 438 439 440 441 442 443 444 445 446 447
}

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)
{
448
	set_pmd(pmdp, __pmd(0));
J
Jeremy Fitzhardinge 已提交
449
}
450
#endif	/* CONFIG_X86_PAE */
J
Jeremy Fitzhardinge 已提交
451

452
pmd_t xen_make_pmd(pmdval_t pmd)
J
Jeremy Fitzhardinge 已提交
453
{
J
Jeremy Fitzhardinge 已提交
454
	pmd = pte_pfn_to_mfn(pmd);
J
Jeremy Fitzhardinge 已提交
455
	return native_make_pmd(pmd);
J
Jeremy Fitzhardinge 已提交
456 457
}

458 459 460 461 462 463 464 465 466 467 468 469 470
#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);
}

471
pgd_t *xen_get_user_pgd(pgd_t *pgd)
472
{
473 474 475
	pgd_t *pgd_page = (pgd_t *)(((unsigned long)pgd) & PAGE_MASK);
	unsigned offset = pgd - pgd_page;
	pgd_t *user_ptr = NULL;
476

477 478 479 480 481 482
	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;
	}
483

484 485 486 487 488 489
	return user_ptr;
}

static void __xen_set_pgd_hyper(pgd_t *ptr, pgd_t val)
{
	struct mmu_update u;
490 491 492 493

	u.ptr = virt_to_machine(ptr).maddr;
	u.val = pgd_val_ma(val);
	extend_mmu_update(&u);
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
}

/*
 * 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);
510 511 512 513 514 515 516 517

	xen_mc_issue(PARAVIRT_LAZY_MMU);

	preempt_enable();
}

void xen_set_pgd(pgd_t *ptr, pgd_t val)
{
518 519
	pgd_t *user_ptr = xen_get_user_pgd(ptr);

520 521 522 523
	/* If page is not pinned, we can just update the entry
	   directly */
	if (!page_pinned(ptr)) {
		*ptr = val;
524 525 526 527
		if (user_ptr) {
			WARN_ON(page_pinned(user_ptr));
			*user_ptr = val;
		}
528 529 530
		return;
	}

531 532 533 534 535 536 537 538 539
	/* 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);
540 541 542
}
#endif	/* PAGETABLE_LEVELS == 4 */

543
/*
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
 * (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.
 */
static int pgd_walk(pgd_t *pgd, int (*func)(struct page *, enum pt_level),
559
		    unsigned long limit)
J
Jeremy Fitzhardinge 已提交
560
{
561
	int flush = 0;
562 563 564
	unsigned hole_low, hole_high;
	unsigned pgdidx_limit, pudidx_limit, pmdidx_limit;
	unsigned pgdidx, pudidx, pmdidx;
565

566 567 568
	/* The limit is the last byte to be touched */
	limit--;
	BUG_ON(limit >= FIXADDR_TOP);
J
Jeremy Fitzhardinge 已提交
569 570

	if (xen_feature(XENFEAT_auto_translated_physmap))
571 572
		return 0;

573 574 575 576 577
	/*
	 * 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.
	 */
578
	hole_low = pgd_index(USER_LIMIT);
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
	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++) {
594
		pud_t *pud;
J
Jeremy Fitzhardinge 已提交
595

596 597
		if (pgdidx >= hole_low && pgdidx < hole_high)
			continue;
598

599
		if (!pgd_val(pgd[pgdidx]))
J
Jeremy Fitzhardinge 已提交
600
			continue;
601

602
		pud = pud_offset(&pgd[pgdidx], 0);
J
Jeremy Fitzhardinge 已提交
603 604

		if (PTRS_PER_PUD > 1) /* not folded */
605
			flush |= (*func)(virt_to_page(pud), PT_PUD);
606

607
		for (pudidx = 0; pudidx < PTRS_PER_PUD; pudidx++) {
608 609
			pmd_t *pmd;

610 611 612
			if (pgdidx == pgdidx_limit &&
			    pudidx > pudidx_limit)
				goto out;
J
Jeremy Fitzhardinge 已提交
613

614
			if (pud_none(pud[pudidx]))
J
Jeremy Fitzhardinge 已提交
615
				continue;
616

617
			pmd = pmd_offset(&pud[pudidx], 0);
J
Jeremy Fitzhardinge 已提交
618 619

			if (PTRS_PER_PMD > 1) /* not folded */
620
				flush |= (*func)(virt_to_page(pmd), PT_PMD);
621

622 623 624 625 626 627 628
			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 已提交
629

630
				if (pmd_none(pmd[pmdidx]))
J
Jeremy Fitzhardinge 已提交
631 632
					continue;

633 634
				pte = pmd_page(pmd[pmdidx]);
				flush |= (*func)(pte, PT_PTE);
J
Jeremy Fitzhardinge 已提交
635 636 637
			}
		}
	}
638

639
out:
640 641 642
	/* Do the top level last, so that the callbacks can use it as
	   a cue to do final things like tlb flushes. */
	flush |= (*func)(virt_to_page(pgd), PT_PGD);
643 644

	return flush;
J
Jeremy Fitzhardinge 已提交
645 646
}

647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
static spinlock_t *lock_pte(struct page *page)
{
	spinlock_t *ptl = NULL;

#if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
	ptl = __pte_lockptr(page);
	spin_lock(ptl);
#endif

	return ptl;
}

static void do_unlock(void *v)
{
	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);
}

static int pin_page(struct page *page, enum pt_level level)
678
{
679
	unsigned pgfl = TestSetPagePinned(page);
680 681 682 683 684 685 686 687 688 689 690 691
	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);
692
		spinlock_t *ptl;
693 694 695

		flush = 0;

696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
		/*
		 * 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.
		 */
716 717 718 719
		ptl = NULL;
		if (level == PT_PTE)
			ptl = lock_pte(page);

720 721
		MULTI_update_va_mapping(mcs.mc, (unsigned long)pt,
					pfn_pte(pfn, PAGE_KERNEL_RO),
722 723
					level == PT_PGD ? UVMF_TLB_FLUSH : 0);

724
		if (ptl) {
725 726 727 728 729 730
			xen_do_pin(MMUEXT_PIN_L1_TABLE, pfn);

			/* Queue a deferred unlock for when this batch
			   is completed. */
			xen_mc_callback(do_unlock, ptl);
		}
731 732 733 734
	}

	return flush;
}
J
Jeremy Fitzhardinge 已提交
735

736 737 738
/* 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. */
J
Jeremy Fitzhardinge 已提交
739 740
void xen_pgd_pin(pgd_t *pgd)
{
741
	xen_mc_batch();
J
Jeremy Fitzhardinge 已提交
742

743
	if (pgd_walk(pgd, pin_page, USER_LIMIT)) {
J
Jeremy Fitzhardinge 已提交
744 745
		/* re-enable interrupts for kmap_flush_unused */
		xen_mc_issue(0);
746
		kmap_flush_unused();
J
Jeremy Fitzhardinge 已提交
747 748
		xen_mc_batch();
	}
749

750 751 752 753 754 755 756 757 758 759 760 761
#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) {
			pin_page(virt_to_page(user_pgd), PT_PGD);
			xen_do_pin(MMUEXT_PIN_L4_TABLE, PFN_DOWN(__pa(user_pgd)));
		}
	}
#else /* CONFIG_X86_32 */
762 763 764 765
#ifdef CONFIG_X86_PAE
	/* Need to make sure unshared kernel PMD is pinnable */
	pin_page(virt_to_page(pgd_page(pgd[pgd_index(TASK_SIZE)])), PT_PMD);
#endif
766
	xen_do_pin(MMUEXT_PIN_L3_TABLE, PFN_DOWN(__pa(pgd)));
767
#endif /* CONFIG_X86_64 */
768
	xen_mc_issue(0);
J
Jeremy Fitzhardinge 已提交
769 770
}

771 772 773 774 775 776 777 778 779 780
/*
 * 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).
 */
void xen_mm_pin_all(void)
{
	unsigned long flags;
	struct page *page;
781

782
	spin_lock_irqsave(&pgd_lock, flags);
783

784 785 786 787 788 789 790 791
	list_for_each_entry(page, &pgd_list, lru) {
		if (!PagePinned(page)) {
			xen_pgd_pin((pgd_t *)page_address(page));
			SetPageSavePinned(page);
		}
	}

	spin_unlock_irqrestore(&pgd_lock, flags);
J
Jeremy Fitzhardinge 已提交
792 793
}

794 795 796 797 798
/*
 * 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.
 */
799
static __init int mark_pinned(struct page *page, enum pt_level level)
J
Jeremy Fitzhardinge 已提交
800
{
801 802 803
	SetPagePinned(page);
	return 0;
}
J
Jeremy Fitzhardinge 已提交
804

805 806 807 808
void __init xen_mark_init_mm_pinned(void)
{
	pgd_walk(init_mm.pgd, mark_pinned, FIXADDR_TOP);
}
J
Jeremy Fitzhardinge 已提交
809

810
static int unpin_page(struct page *page, enum pt_level level)
811
{
812
	unsigned pgfl = TestClearPagePinned(page);
J
Jeremy Fitzhardinge 已提交
813

814 815 816
	if (pgfl && !PageHighMem(page)) {
		void *pt = lowmem_page_address(page);
		unsigned long pfn = page_to_pfn(page);
817 818 819
		spinlock_t *ptl = NULL;
		struct multicall_space mcs;

820 821 822 823 824 825 826
		/*
		 * 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.
		 */
827 828 829
		if (level == PT_PTE) {
			ptl = lock_pte(page);

830 831
			if (ptl)
				xen_do_pin(MMUEXT_UNPIN_TABLE, pfn);
832 833 834
		}

		mcs = __xen_mc_entry(0);
835 836 837

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

		if (ptl) {
			/* unlock when batch completed */
			xen_mc_callback(do_unlock, ptl);
		}
844 845 846
	}

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

849 850 851 852 853
/* Release a pagetables pages back as normal RW */
static void xen_pgd_unpin(pgd_t *pgd)
{
	xen_mc_batch();

854
	xen_do_pin(MMUEXT_UNPIN_TABLE, PFN_DOWN(__pa(pgd)));
855

856 857 858 859 860 861 862 863 864 865 866
#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)));
			unpin_page(virt_to_page(user_pgd), PT_PGD);
		}
	}
#endif

867 868
#ifdef CONFIG_X86_PAE
	/* Need to make sure unshared kernel PMD is unpinned */
869
	unpin_page(virt_to_page(pgd_page(pgd[pgd_index(TASK_SIZE)])), PT_PMD);
870
#endif
871 872

	pgd_walk(pgd, unpin_page, USER_LIMIT);
873 874 875

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

877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898
/*
 * 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));
			xen_pgd_unpin((pgd_t *)page_address(page));
			ClearPageSavePinned(page);
		}
	}

	spin_unlock_irqrestore(&pgd_lock, flags);
}

J
Jeremy Fitzhardinge 已提交
899 900
void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
{
901
	spin_lock(&next->page_table_lock);
J
Jeremy Fitzhardinge 已提交
902
	xen_pgd_pin(next->pgd);
903
	spin_unlock(&next->page_table_lock);
J
Jeremy Fitzhardinge 已提交
904 905 906 907
}

void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
{
908
	spin_lock(&mm->page_table_lock);
J
Jeremy Fitzhardinge 已提交
909
	xen_pgd_pin(mm->pgd);
910
	spin_unlock(&mm->page_table_lock);
J
Jeremy Fitzhardinge 已提交
911 912 913
}


J
Jeremy Fitzhardinge 已提交
914 915 916 917 918 919
#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;
920
	struct mm_struct *active_mm;
J
Jeremy Fitzhardinge 已提交
921

922 923 924 925 926 927 928
#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 已提交
929
		leave_mm(smp_processor_id());
930 931 932 933 934 935 936

	/* 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 已提交
937
}
J
Jeremy Fitzhardinge 已提交
938

J
Jeremy Fitzhardinge 已提交
939 940
static void drop_mm_ref(struct mm_struct *mm)
{
941 942 943
	cpumask_t mask;
	unsigned cpu;

J
Jeremy Fitzhardinge 已提交
944 945 946 947 948
	if (current->active_mm == mm) {
		if (current->mm == mm)
			load_cr3(swapper_pg_dir);
		else
			leave_mm(smp_processor_id());
949 950 951 952 953 954 955 956 957 958 959 960 961 962
		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 已提交
963 964
	}

965
	if (!cpus_empty(mask))
966
		smp_call_function_mask(mask, drop_other_mm_ref, mm, 1);
J
Jeremy Fitzhardinge 已提交
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994
}
#else
static void drop_mm_ref(struct mm_struct *mm)
{
	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 */
	drop_mm_ref(mm);
	put_cpu();
J
Jeremy Fitzhardinge 已提交
995

996
	spin_lock(&mm->page_table_lock);
997 998

	/* pgd may not be pinned in the error exit path of execve */
999
	if (page_pinned(mm->pgd))
1000
		xen_pgd_unpin(mm->pgd);
1001

1002
	spin_unlock(&mm->page_table_lock);
J
Jeremy Fitzhardinge 已提交
1003
}