arch/x86/mm/pageattr.c

   1 /*
   2  * Copyright 2002 Andi Kleen, SuSE Labs.
   3  * Thanks to Ben LaHaise for precious feedback.
   4  */
   5 #include <linux/highmem.h>
   6 #include <linux/bootmem.h>
   7 #include <linux/module.h>
   8 #include <linux/sched.h>
   9 #include <linux/slab.h>
  10 #include <linux/mm.h>
  11 #include <linux/interrupt.h>
  12
  13 #include <asm/e820.h>
  14 #include <asm/processor.h>
  15 #include <asm/tlbflush.h>
  16 #include <asm/sections.h>
  17 #include <asm/uaccess.h>
  18 #include <asm/pgalloc.h>
  19
  20 /*
  21  * The current flushing context - we pass it instead of 5 arguments:
  22  */
  23 struct cpa_data {
  24         unsigned long   vaddr;
  25         pgprot_t        mask_set;
  26         pgprot_t        mask_clr;
  27         int             numpages;
  28         int             flushtlb;
  29 };
  30
  31 static inline int
  32 within(unsigned long addr, unsigned long start, unsigned long end)
  33 {
  34         return addr >= start && addr < end;
  35 }
  36
  37 /*
  38  * Flushing functions
  39  */
  40
  41 /**
  42  * clflush_cache_range - flush a cache range with clflush
  43  * @addr:       virtual start address
  44  * @size:       number of bytes to flush
  45  *
  46  * clflush is an unordered instruction which needs fencing with mfence
  47  * to avoid ordering issues.
  48  */
  49 void clflush_cache_range(void *vaddr, unsigned int size)
  50 {
  51         void *vend = vaddr + size - 1;
  52
  53         mb();
  54
  55         for (; vaddr < vend; vaddr += boot_cpu_data.x86_clflush_size)
  56                 clflush(vaddr);
  57         /*
  58          * Flush any possible final partial cacheline:
  59          */
  60         clflush(vend);
  61
  62         mb();
  63 }
  64
  65 static void __cpa_flush_all(void *arg)
  66 {
  67         unsigned long cache = (unsigned long)arg;
  68
  69         /*
  70          * Flush all to work around Errata in early athlons regarding
  71          * large page flushing.
  72          */
  73         __flush_tlb_all();
  74
  75         if (cache && boot_cpu_data.x86_model >= 4)
  76                 wbinvd();
  77 }
  78
  79 static void cpa_flush_all(unsigned long cache)
  80 {
  81         BUG_ON(irqs_disabled());
  82
  83         on_each_cpu(__cpa_flush_all, (void *) cache, 1, 1);
  84 }
  85
  86 static void __cpa_flush_range(void *arg)
  87 {
  88         /*
  89          * We could optimize that further and do individual per page
  90          * tlb invalidates for a low number of pages. Caveat: we must
  91          * flush the high aliases on 64bit as well.
  92          */
  93         __flush_tlb_all();
  94 }
  95
  96 static void cpa_flush_range(unsigned long start, int numpages, int cache)
  97 {
  98         unsigned int i, level;
  99         unsigned long addr;
 100
 101         BUG_ON(irqs_disabled());
 102         WARN_ON(PAGE_ALIGN(start) != start);
 103
 104         on_each_cpu(__cpa_flush_range, NULL, 1, 1);
 105
 106         if (!cache)
 107                 return;
 108
 109         /*
 110          * We only need to flush on one CPU,
 111          * clflush is a MESI-coherent instruction that
 112          * will cause all other CPUs to flush the same
 113          * cachelines:
 114          */
 115         for (i = 0, addr = start; i < numpages; i++, addr += PAGE_SIZE) {
 116                 pte_t *pte = lookup_address(addr, &level);
 117
 118                 /*
 119                  * Only flush present addresses:
 120                  */
 121                 if (pte && (pte_val(*pte) & _PAGE_PRESENT))
 122                         clflush_cache_range((void *) addr, PAGE_SIZE);
 123         }
 124 }
 125
 126 #define HIGH_MAP_START  __START_KERNEL_map
 127 #define HIGH_MAP_END    (__START_KERNEL_map + KERNEL_TEXT_SIZE)
 128
 129
 130 /*
 131  * Converts a virtual address to a X86-64 highmap address
 132  */
 133 static unsigned long virt_to_highmap(void *address)
 134 {
 135 #ifdef CONFIG_X86_64
 136         return __pa((unsigned long)address) + HIGH_MAP_START - phys_base;
 137 #else
 138         return (unsigned long)address;
 139 #endif
 140 }
 141
 142 /*
 143  * Certain areas of memory on x86 require very specific protection flags,
 144  * for example the BIOS area or kernel text. Callers don't always get this
 145  * right (again, ioremap() on BIOS memory is not uncommon) so this function
 146  * checks and fixes these known static required protection bits.
 147  */
 148 static inline pgprot_t static_protections(pgprot_t prot, unsigned long address)
 149 {
 150         pgprot_t forbidden = __pgprot(0);
 151
 152         /*
 153          * The BIOS area between 640k and 1Mb needs to be executable for
 154          * PCI BIOS based config access (CONFIG_PCI_GOBIOS) support.
 155          */
 156         if (within(__pa(address), BIOS_BEGIN, BIOS_END))
 157                 pgprot_val(forbidden) |= _PAGE_NX;
 158
 159         /*
 160          * The kernel text needs to be executable for obvious reasons
 161          * Does not cover __inittext since that is gone later on
 162          */
 163         if (within(address, (unsigned long)_text, (unsigned long)_etext))
 164                 pgprot_val(forbidden) |= _PAGE_NX;
 165         /*
 166          * Do the same for the x86-64 high kernel mapping
 167          */
 168         if (within(address, virt_to_highmap(_text), virt_to_highmap(_etext)))
 169                 pgprot_val(forbidden) |= _PAGE_NX;
 170
 171         /* The .rodata section needs to be read-only */
 172         if (within(address, (unsigned long)__start_rodata,
 173                                 (unsigned long)__end_rodata))
 174                 pgprot_val(forbidden) |= _PAGE_RW;
 175         /*
 176          * Do the same for the x86-64 high kernel mapping
 177          */
 178         if (within(address, virt_to_highmap(__start_rodata),
 179                                 virt_to_highmap(__end_rodata)))
 180                 pgprot_val(forbidden) |= _PAGE_RW;
 181
 182         prot = __pgprot(pgprot_val(prot) & ~pgprot_val(forbidden));
 183
 184         return prot;
 185 }
 186
 187 /*
 188  * Lookup the page table entry for a virtual address. Return a pointer
 189  * to the entry and the level of the mapping.
 190  *
 191  * Note: We return pud and pmd either when the entry is marked large
 192  * or when the present bit is not set. Otherwise we would return a
 193  * pointer to a nonexisting mapping.
 194  */
 195 pte_t *lookup_address(unsigned long address, unsigned int *level)
 196 {
 197         pgd_t *pgd = pgd_offset_k(address);
 198         pud_t *pud;
 199         pmd_t *pmd;
 200
 201         *level = PG_LEVEL_NONE;
 202
 203         if (pgd_none(*pgd))
 204                 return NULL;
 205
 206         pud = pud_offset(pgd, address);
 207         if (pud_none(*pud))
 208                 return NULL;
 209
 210         *level = PG_LEVEL_1G;
 211         if (pud_large(*pud) || !pud_present(*pud))
 212                 return (pte_t *)pud;
 213
 214         pmd = pmd_offset(pud, address);
 215         if (pmd_none(*pmd))
 216                 return NULL;
 217
 218         *level = PG_LEVEL_2M;
 219         if (pmd_large(*pmd) || !pmd_present(*pmd))
 220                 return (pte_t *)pmd;
 221
 222         *level = PG_LEVEL_4K;
 223
 224         return pte_offset_kernel(pmd, address);
 225 }
 226
 227 /*
 228  * Set the new pmd in all the pgds we know about:
 229  */
 230 static void __set_pmd_pte(pte_t *kpte, unsigned long address, pte_t pte)
 231 {
 232         /* change init_mm */
 233         set_pte_atomic(kpte, pte);
 234 #ifdef CONFIG_X86_32
 235         if (!SHARED_KERNEL_PMD) {
 236                 struct page *page;
 237
 238                 list_for_each_entry(page, &pgd_list, lru) {
 239                         pgd_t *pgd;
 240                         pud_t *pud;
 241                         pmd_t *pmd;
 242
 243                         pgd = (pgd_t *)page_address(page) + pgd_index(address);
 244                         pud = pud_offset(pgd, address);
 245                         pmd = pmd_offset(pud, address);
 246                         set_pte_atomic((pte_t *)pmd, pte);
 247                 }
 248         }
 249 #endif
 250 }
 251
 252 static int
 253 try_preserve_large_page(pte_t *kpte, unsigned long address,
 254                         struct cpa_data *cpa)
 255 {
 256         unsigned long nextpage_addr, numpages, pmask, psize, flags;
 257         pte_t new_pte, old_pte, *tmp;
 258         pgprot_t old_prot, new_prot;
 259         int do_split = 1;
 260         unsigned int level;
 261
 262         spin_lock_irqsave(&pgd_lock, flags);
 263         /*
 264          * Check for races, another CPU might have split this page
 265          * up already:
 266          */
 267         tmp = lookup_address(address, &level);
 268         if (tmp != kpte)
 269                 goto out_unlock;
 270
 271         switch (level) {
 272         case PG_LEVEL_2M:
 273                 psize = PMD_PAGE_SIZE;
 274                 pmask = PMD_PAGE_MASK;
 275                 break;
 276 #ifdef CONFIG_X86_64
 277         case PG_LEVEL_1G:
 278                 psize = PMD_PAGE_SIZE;
 279                 pmask = PMD_PAGE_MASK;
 280                 break;
 281 #endif
 282         default:
 283                 do_split = -EINVAL;
 284                 goto out_unlock;
 285         }
 286
 287         /*
 288          * Calculate the number of pages, which fit into this large
 289          * page starting at address:
 290          */
 291         nextpage_addr = (address + psize) & pmask;
 292         numpages = (nextpage_addr - address) >> PAGE_SHIFT;
 293         if (numpages < cpa->numpages)
 294                 cpa->numpages = numpages;
 295
 296         /*
 297          * We are safe now. Check whether the new pgprot is the same:
 298          */
 299         old_pte = *kpte;
 300         old_prot = new_prot = pte_pgprot(old_pte);
 301
 302         pgprot_val(new_prot) &= ~pgprot_val(cpa->mask_clr);
 303         pgprot_val(new_prot) |= pgprot_val(cpa->mask_set);
 304         new_prot = static_protections(new_prot, address);
 305
 306         /*
 307          * If there are no changes, return. maxpages has been updated
 308          * above:
 309          */
 310         if (pgprot_val(new_prot) == pgprot_val(old_prot)) {
 311                 do_split = 0;
 312                 goto out_unlock;
 313         }
 314
 315         /*
 316          * We need to change the attributes. Check, whether we can
 317          * change the large page in one go. We request a split, when
 318          * the address is not aligned and the number of pages is
 319          * smaller than the number of pages in the large page. Note
 320          * that we limited the number of possible pages already to
 321          * the number of pages in the large page.
 322          */
 323         if (address == (nextpage_addr - psize) && cpa->numpages == numpages) {
 324                 /*
 325                  * The address is aligned and the number of pages
 326                  * covers the full page.
 327                  */
 328                 new_pte = pfn_pte(pte_pfn(old_pte), canon_pgprot(new_prot));
 329                 __set_pmd_pte(kpte, address, new_pte);
 330                 cpa->flushtlb = 1;
 331                 do_split = 0;
 332         }
 333
 334 out_unlock:
 335         spin_unlock_irqrestore(&pgd_lock, flags);
 336
 337         return do_split;
 338 }
 339
 340 static LIST_HEAD(page_pool);
 341 static unsigned long pool_size, pool_pages, pool_low;
 342 static unsigned long pool_used, pool_failed, pool_refill;
 343
 344 static void cpa_fill_pool(void)
 345 {
 346         struct page *p;
 347         gfp_t gfp = GFP_KERNEL;
 348
 349         /* Do not allocate from interrupt context */
 350         if (in_irq() || irqs_disabled())
 351                 return;
 352         /*
 353          * Check unlocked. I does not matter when we have one more
 354          * page in the pool. The bit lock avoids recursive pool
 355          * allocations:
 356          */
 357         if (pool_pages >= pool_size || test_and_set_bit_lock(0, &pool_refill))
 358                 return;
 359
 360 #ifdef CONFIG_DEBUG_PAGEALLOC
 361         /*
 362          * We could do:
 363          * gfp = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
 364          * but this fails on !PREEMPT kernels
 365          */
 366         gfp =  GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN;
 367 #endif
 368
 369         while (pool_pages < pool_size) {
 370                 p = alloc_pages(gfp, 0);
 371                 if (!p) {
 372                         pool_failed++;
 373                         break;
 374                 }
 375                 spin_lock_irq(&pgd_lock);
 376                 list_add(&p->lru, &page_pool);
 377                 pool_pages++;
 378                 spin_unlock_irq(&pgd_lock);
 379         }
 380         clear_bit_unlock(0, &pool_refill);
 381 }
 382
 383 #define SHIFT_MB                (20 - PAGE_SHIFT)
 384 #define ROUND_MB_GB             ((1 << 10) - 1)
 385 #define SHIFT_MB_GB             10
 386 #define POOL_PAGES_PER_GB       16
 387
 388 void __init cpa_init(void)
 389 {
 390         struct sysinfo si;
 391         unsigned long gb;
 392
 393         si_meminfo(&si);
 394         /*
 395          * Calculate the number of pool pages:
 396          *
 397          * Convert totalram (nr of pages) to MiB and round to the next
 398          * GiB. Shift MiB to Gib and multiply the result by
 399          * POOL_PAGES_PER_GB:
 400          */
 401         gb = ((si.totalram >> SHIFT_MB) + ROUND_MB_GB) >> SHIFT_MB_GB;
 402         pool_size = POOL_PAGES_PER_GB * gb;
 403         pool_low = pool_size;
 404
 405         cpa_fill_pool();
 406         printk(KERN_DEBUG
 407                "CPA: page pool initialized %lu of %lu pages preallocated\n",
 408                pool_pages, pool_size);
 409 }
 410
 411 static int split_large_page(pte_t *kpte, unsigned long address)
 412 {
 413         unsigned long flags, pfn, pfninc = 1;
 414         unsigned int i, level;
 415         pte_t *pbase, *tmp;
 416         pgprot_t ref_prot;
 417         struct page *base;
 418
 419         /*
 420          * Get a page from the pool. The pool list is protected by the
 421          * pgd_lock, which we have to take anyway for the split
 422          * operation:
 423          */
 424         spin_lock_irqsave(&pgd_lock, flags);
 425         if (list_empty(&page_pool)) {
 426                 spin_unlock_irqrestore(&pgd_lock, flags);
 427                 return -ENOMEM;
 428         }
 429
 430         base = list_first_entry(&page_pool, struct page, lru);
 431         list_del(&base->lru);
 432         pool_pages--;
 433
 434         if (pool_pages < pool_low)
 435                 pool_low = pool_pages;
 436
 437         /*
 438          * Check for races, another CPU might have split this page
 439          * up for us already:
 440          */
 441         tmp = lookup_address(address, &level);
 442         if (tmp != kpte)
 443                 goto out_unlock;
 444
 445         pbase = (pte_t *)page_address(base);
 446 #ifdef CONFIG_X86_32
 447         paravirt_alloc_pt(&init_mm, page_to_pfn(base));
 448 #endif
 449         ref_prot = pte_pgprot(pte_clrhuge(*kpte));
 450
 451 #ifdef CONFIG_X86_64
 452         if (level == PG_LEVEL_1G) {
 453                 pfninc = PMD_PAGE_SIZE >> PAGE_SHIFT;
 454                 pgprot_val(ref_prot) |= _PAGE_PSE;
 455         }
 456 #endif
 457
 458         /*
 459          * Get the target pfn from the original entry:
 460          */
 461         pfn = pte_pfn(*kpte);
 462         for (i = 0; i < PTRS_PER_PTE; i++, pfn += pfninc)
 463                 set_pte(&pbase[i], pfn_pte(pfn, ref_prot));
 464
 465         /*
 466          * Install the new, split up pagetable. Important details here:
 467          *
 468          * On Intel the NX bit of all levels must be cleared to make a
 469          * page executable. See section 4.13.2 of Intel 64 and IA-32
 470          * Architectures Software Developer's Manual).
 471          *
 472          * Mark the entry present. The current mapping might be
 473          * set to not present, which we preserved above.
 474          */
 475         ref_prot = pte_pgprot(pte_mkexec(pte_clrhuge(*kpte)));
 476         pgprot_val(ref_prot) |= _PAGE_PRESENT;
 477         __set_pmd_pte(kpte, address, mk_pte(base, ref_prot));
 478         base = NULL;
 479
 480 out_unlock:
 481         /*
 482          * If we dropped out via the lookup_address check under
 483          * pgd_lock then stick the page back into the pool:
 484          */
 485         if (base) {
 486                 list_add(&base->lru, &page_pool);
 487                 pool_pages++;
 488         } else
 489                 pool_used++;
 490         spin_unlock_irqrestore(&pgd_lock, flags);
 491
 492         return 0;
 493 }
 494
 495 static int __change_page_attr(unsigned long address, struct cpa_data *cpa)
 496 {
 497         int do_split, err;
 498         unsigned int level;
 499         struct page *kpte_page;
 500         pte_t *kpte;
 501
 502 repeat:
 503         kpte = lookup_address(address, &level);
 504         if (!kpte)
 505                 return -EINVAL;
 506
 507         kpte_page = virt_to_page(kpte);
 508         BUG_ON(PageLRU(kpte_page));
 509         BUG_ON(PageCompound(kpte_page));
 510
 511         if (level == PG_LEVEL_4K) {
 512                 pte_t new_pte, old_pte = *kpte;
 513                 pgprot_t new_prot = pte_pgprot(old_pte);
 514
 515                 if(!pte_val(old_pte)) {
 516                         printk(KERN_WARNING "CPA: called for zero pte. "
 517                                "vaddr = %lx cpa->vaddr = %lx\n", address,
 518                                 cpa->vaddr);
 519                         WARN_ON(1);
 520                         return -EINVAL;
 521                 }
 522
 523                 pgprot_val(new_prot) &= ~pgprot_val(cpa->mask_clr);
 524                 pgprot_val(new_prot) |= pgprot_val(cpa->mask_set);
 525
 526                 new_prot = static_protections(new_prot, address);
 527
 528                 /*
 529                  * We need to keep the pfn from the existing PTE,
 530                  * after all we're only going to change it's attributes
 531                  * not the memory it points to
 532                  */
 533                 new_pte = pfn_pte(pte_pfn(old_pte), canon_pgprot(new_prot));
 534
 535                 /*
 536                  * Do we really change anything ?
 537                  */
 538                 if (pte_val(old_pte) != pte_val(new_pte)) {
 539                         set_pte_atomic(kpte, new_pte);
 540                         cpa->flushtlb = 1;
 541                 }
 542                 cpa->numpages = 1;
 543                 return 0;
 544         }
 545
 546         /*
 547          * Check, whether we can keep the large page intact
 548          * and just change the pte:
 549          */
 550         do_split = try_preserve_large_page(kpte, address, cpa);
 551         /*
 552          * When the range fits into the existing large page,
 553          * return. cp->numpages and cpa->tlbflush have been updated in
 554          * try_large_page:
 555          */
 556         if (do_split <= 0)
 557                 return do_split;
 558
 559         /*
 560          * We have to split the large page:
 561          */
 562         err = split_large_page(kpte, address);
 563         if (!err) {
 564                 cpa->flushtlb = 1;
 565                 goto repeat;
 566         }
 567
 568         return err;
 569 }
 570
 571 /**
 572  * change_page_attr_addr - Change page table attributes in linear mapping
 573  * @address: Virtual address in linear mapping.
 574  * @prot:    New page table attribute (PAGE_*)
 575  *
 576  * Change page attributes of a page in the direct mapping. This is a variant
 577  * of change_page_attr() that also works on memory holes that do not have
 578  * mem_map entry (pfn_valid() is false).
 579  *
 580  * See change_page_attr() documentation for more details.
 581  *
 582  * Modules and drivers should use the set_memory_* APIs instead.
 583  */
 584 static int change_page_attr_addr(struct cpa_data *cpa)
 585 {
 586         int err;
 587         unsigned long address = cpa->vaddr;
 588
 589 #ifdef CONFIG_X86_64
 590         unsigned long phys_addr = __pa(address);
 591
 592         /*
 593          * If we are inside the high mapped kernel range, then we
 594          * fixup the low mapping first. __va() returns the virtual
 595          * address in the linear mapping:
 596          */
 597         if (within(address, HIGH_MAP_START, HIGH_MAP_END))
 598                 address = (unsigned long) __va(phys_addr);
 599 #endif
 600
 601         err = __change_page_attr(address, cpa);
 602         if (err)
 603                 return err;
 604
 605 #ifdef CONFIG_X86_64
 606         /*
 607          * If the physical address is inside the kernel map, we need
 608          * to touch the high mapped kernel as well:
 609          */
 610         if (within(phys_addr, 0, KERNEL_TEXT_SIZE)) {
 611                 /*
 612                  * Calc the high mapping address. See __phys_addr()
 613                  * for the non obvious details.
 614                  *
 615                  * Note that NX and other required permissions are
 616                  * checked in static_protections().
 617                  */
 618                 address = phys_addr + HIGH_MAP_START - phys_base;
 619
 620                 /*
 621                  * Our high aliases are imprecise, because we check
 622                  * everything between 0 and KERNEL_TEXT_SIZE, so do
 623                  * not propagate lookup failures back to users:
 624                  */
 625                 __change_page_attr(address, cpa);
 626         }
 627 #endif
 628         return err;
 629 }
 630
 631 static int __change_page_attr_set_clr(struct cpa_data *cpa)
 632 {
 633         int ret, numpages = cpa->numpages;
 634
 635         while (numpages) {
 636                 /*
 637                  * Store the remaining nr of pages for the large page
 638                  * preservation check.
 639                  */
 640                 cpa->numpages = numpages;
 641                 ret = change_page_attr_addr(cpa);
 642                 if (ret)
 643                         return ret;
 644
 645                 /*
 646                  * Adjust the number of pages with the result of the
 647                  * CPA operation. Either a large page has been
 648                  * preserved or a single page update happened.
 649                  */
 650                 BUG_ON(cpa->numpages > numpages);
 651                 numpages -= cpa->numpages;
 652                 cpa->vaddr += cpa->numpages * PAGE_SIZE;
 653         }
 654         return 0;
 655 }
 656
 657 static inline int cache_attr(pgprot_t attr)
 658 {
 659         return pgprot_val(attr) &
 660                 (_PAGE_PAT | _PAGE_PAT_LARGE | _PAGE_PWT | _PAGE_PCD);
 661 }
 662
 663 static int change_page_attr_set_clr(unsigned long addr, int numpages,
 664                                     pgprot_t mask_set, pgprot_t mask_clr)
 665 {
 666         struct cpa_data cpa;
 667         int ret, cache;
 668
 669         /*
 670          * Check, if we are requested to change a not supported
 671          * feature:
 672          */
 673         mask_set = canon_pgprot(mask_set);
 674         mask_clr = canon_pgprot(mask_clr);
 675         if (!pgprot_val(mask_set) && !pgprot_val(mask_clr))
 676                 return 0;
 677
 678         cpa.vaddr = addr;
 679         cpa.numpages = numpages;
 680         cpa.mask_set = mask_set;
 681         cpa.mask_clr = mask_clr;
 682         cpa.flushtlb = 0;
 683
 684         ret = __change_page_attr_set_clr(&cpa);
 685
 686         /*
 687          * Check whether we really changed something:
 688          */
 689         if (!cpa.flushtlb)
 690                 goto out;
 691
 692         /*
 693          * No need to flush, when we did not set any of the caching
 694          * attributes:
 695          */
 696         cache = cache_attr(mask_set);
 697
 698         /*
 699          * On success we use clflush, when the CPU supports it to
 700          * avoid the wbindv. If the CPU does not support it and in the
 701          * error case we fall back to cpa_flush_all (which uses
 702          * wbindv):
 703          */
 704         if (!ret && cpu_has_clflush)
 705                 cpa_flush_range(addr, numpages, cache);
 706         else
 707                 cpa_flush_all(cache);
 708
 709 out:
 710         cpa_fill_pool();
 711         return ret;
 712 }
 713
 714 static inline int change_page_attr_set(unsigned long addr, int numpages,
 715                                        pgprot_t mask)
 716 {
 717         return change_page_attr_set_clr(addr, numpages, mask, __pgprot(0));
 718 }
 719
 720 static inline int change_page_attr_clear(unsigned long addr, int numpages,
 721                                          pgprot_t mask)
 722 {
 723         return change_page_attr_set_clr(addr, numpages, __pgprot(0), mask);
 724 }
 725
 726 int set_memory_uc(unsigned long addr, int numpages)
 727 {
 728         return change_page_attr_set(addr, numpages,
 729                                     __pgprot(_PAGE_PCD | _PAGE_PWT));
 730 }
 731 EXPORT_SYMBOL(set_memory_uc);
 732
 733 int set_memory_wb(unsigned long addr, int numpages)
 734 {
 735         return change_page_attr_clear(addr, numpages,
 736                                       __pgprot(_PAGE_PCD | _PAGE_PWT));
 737 }
 738 EXPORT_SYMBOL(set_memory_wb);
 739
 740 int set_memory_x(unsigned long addr, int numpages)
 741 {
 742         return change_page_attr_clear(addr, numpages, __pgprot(_PAGE_NX));
 743 }
 744 EXPORT_SYMBOL(set_memory_x);
 745
 746 int set_memory_nx(unsigned long addr, int numpages)
 747 {
 748         return change_page_attr_set(addr, numpages, __pgprot(_PAGE_NX));
 749 }
 750 EXPORT_SYMBOL(set_memory_nx);
 751
 752 int set_memory_ro(unsigned long addr, int numpages)
 753 {
 754         return change_page_attr_clear(addr, numpages, __pgprot(_PAGE_RW));
 755 }
 756
 757 int set_memory_rw(unsigned long addr, int numpages)
 758 {
 759         return change_page_attr_set(addr, numpages, __pgprot(_PAGE_RW));
 760 }
 761
 762 int set_memory_np(unsigned long addr, int numpages)
 763 {
 764         return change_page_attr_clear(addr, numpages, __pgprot(_PAGE_PRESENT));
 765 }
 766
 767 int set_pages_uc(struct page *page, int numpages)
 768 {
 769         unsigned long addr = (unsigned long)page_address(page);
 770
 771         return set_memory_uc(addr, numpages);
 772 }
 773 EXPORT_SYMBOL(set_pages_uc);
 774
 775 int set_pages_wb(struct page *page, int numpages)
 776 {
 777         unsigned long addr = (unsigned long)page_address(page);
 778
 779         return set_memory_wb(addr, numpages);
 780 }
 781 EXPORT_SYMBOL(set_pages_wb);
 782
 783 int set_pages_x(struct page *page, int numpages)
 784 {
 785         unsigned long addr = (unsigned long)page_address(page);
 786
 787         return set_memory_x(addr, numpages);
 788 }
 789 EXPORT_SYMBOL(set_pages_x);
 790
 791 int set_pages_nx(struct page *page, int numpages)
 792 {
 793         unsigned long addr = (unsigned long)page_address(page);
 794
 795         return set_memory_nx(addr, numpages);
 796 }
 797 EXPORT_SYMBOL(set_pages_nx);
 798
 799 int set_pages_ro(struct page *page, int numpages)
 800 {
 801         unsigned long addr = (unsigned long)page_address(page);
 802
 803         return set_memory_ro(addr, numpages);
 804 }
 805
 806 int set_pages_rw(struct page *page, int numpages)
 807 {
 808         unsigned long addr = (unsigned long)page_address(page);
 809
 810         return set_memory_rw(addr, numpages);
 811 }
 812
 813 #ifdef CONFIG_DEBUG_PAGEALLOC
 814
 815 static int __set_pages_p(struct page *page, int numpages)
 816 {
 817         struct cpa_data cpa = { .vaddr = (unsigned long) page_address(page),
 818                                 .numpages = numpages,
 819                                 .mask_set = __pgprot(_PAGE_PRESENT | _PAGE_RW),
 820                                 .mask_clr = __pgprot(0)};
 821
 822         return __change_page_attr_set_clr(&cpa);
 823 }
 824
 825 static int __set_pages_np(struct page *page, int numpages)
 826 {
 827         struct cpa_data cpa = { .vaddr = (unsigned long) page_address(page),
 828                                 .numpages = numpages,
 829                                 .mask_set = __pgprot(0),
 830                                 .mask_clr = __pgprot(_PAGE_PRESENT | _PAGE_RW)};
 831
 832         return __change_page_attr_set_clr(&cpa);
 833 }
 834
 835 void kernel_map_pages(struct page *page, int numpages, int enable)
 836 {
 837         if (PageHighMem(page))
 838                 return;
 839         if (!enable) {
 840                 debug_check_no_locks_freed(page_address(page),
 841                                            numpages * PAGE_SIZE);
 842         }
 843
 844         /*
 845          * If page allocator is not up yet then do not call c_p_a():
 846          */
 847         if (!debug_pagealloc_enabled)
 848                 return;
 849
 850         /*
 851          * The return value is ignored - the calls cannot fail,
 852          * large pages are disabled at boot time:
 853          */
 854         if (enable)
 855                 __set_pages_p(page, numpages);
 856         else
 857                 __set_pages_np(page, numpages);
 858
 859         /*
 860          * We should perform an IPI and flush all tlbs,
 861          * but that can deadlock->flush only current cpu:
 862          */
 863         __flush_tlb_all();
 864
 865         /*
 866          * Try to refill the page pool here. We can do this only after
 867          * the tlb flush.
 868          */
 869         cpa_fill_pool();
 870 }
 871 #endif
 872
 873 /*
 874  * The testcases use internal knowledge of the implementation that shouldn't
 875  * be exposed to the rest of the kernel. Include these directly here.
 876  */
 877 #ifdef CONFIG_CPA_DEBUG
 878 #include "pageattr-test.c"
 879 #endif