arch/x86/mm/pat.c

   1 /*
   2  * Handle caching attributes in page tables (PAT)
   3  *
   4  * Authors: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
   5  *          Suresh B Siddha <suresh.b.siddha@intel.com>
   6  *
   7  * Loosely based on earlier PAT patchset from Eric Biederman and Andi Kleen.
   8  */
   9
  10 #include <linux/seq_file.h>
  11 #include <linux/bootmem.h>
  12 #include <linux/debugfs.h>
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/gfp.h>
  16 #include <linux/mm.h>
  17 #include <linux/fs.h>
  18
  19 #include <asm/cacheflush.h>
  20 #include <asm/processor.h>
  21 #include <asm/tlbflush.h>
  22 #include <asm/pgtable.h>
  23 #include <asm/fcntl.h>
  24 #include <asm/e820.h>
  25 #include <asm/mtrr.h>
  26 #include <asm/page.h>
  27 #include <asm/msr.h>
  28 #include <asm/pat.h>
  29 #include <asm/io.h>
  30
  31 #ifdef CONFIG_X86_PAT
  32 int __read_mostly pat_enabled = 1;
  33
  34 void __cpuinit pat_disable(const char *reason)
  35 {
  36         pat_enabled = 0;
  37         printk(KERN_INFO "%s\n", reason);
  38 }
  39
  40 static int __init nopat(char *str)
  41 {
  42         pat_disable("PAT support disabled.");
  43         return 0;
  44 }
  45 early_param("nopat", nopat);
  46 #else
  47 static inline void pat_disable(const char *reason)
  48 {
  49         (void)reason;
  50 }
  51 #endif
  52
  53
  54 static int debug_enable;
  55
  56 static int __init pat_debug_setup(char *str)
  57 {
  58         debug_enable = 1;
  59         return 0;
  60 }
  61 __setup("debugpat", pat_debug_setup);
  62
  63 #define dprintk(fmt, arg...) \
  64         do { if (debug_enable) printk(KERN_INFO fmt, ##arg); } while (0)
  65
  66
  67 static u64 __read_mostly boot_pat_state;
  68
  69 enum {
  70         PAT_UC = 0,             /* uncached */
  71         PAT_WC = 1,             /* Write combining */
  72         PAT_WT = 4,             /* Write Through */
  73         PAT_WP = 5,             /* Write Protected */
  74         PAT_WB = 6,             /* Write Back (default) */
  75         PAT_UC_MINUS = 7,       /* UC, but can be overriden by MTRR */
  76 };
  77
  78 #define PAT(x, y)       ((u64)PAT_ ## y << ((x)*8))
  79
  80 void pat_init(void)
  81 {
  82         u64 pat;
  83
  84         if (!pat_enabled)
  85                 return;
  86
  87         if (!cpu_has_pat) {
  88                 if (!boot_pat_state) {
  89                         pat_disable("PAT not supported by CPU.");
  90                         return;
  91                 } else {
  92                         /*
  93                          * If this happens we are on a secondary CPU, but
  94                          * switched to PAT on the boot CPU. We have no way to
  95                          * undo PAT.
  96                          */
  97                         printk(KERN_ERR "PAT enabled, "
  98                                "but not supported by secondary CPU\n");
  99                         BUG();
 100                 }
 101         }
 102
 103         /* Set PWT to Write-Combining. All other bits stay the same */
 104         /*
 105          * PTE encoding used in Linux:
 106          *      PAT
 107          *      |PCD
 108          *      ||PWT
 109          *      |||
 110          *      000 WB          _PAGE_CACHE_WB
 111          *      001 WC          _PAGE_CACHE_WC
 112          *      010 UC-         _PAGE_CACHE_UC_MINUS
 113          *      011 UC          _PAGE_CACHE_UC
 114          * PAT bit unused
 115          */
 116         pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
 117               PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, UC);
 118
 119         /* Boot CPU check */
 120         if (!boot_pat_state)
 121                 rdmsrl(MSR_IA32_CR_PAT, boot_pat_state);
 122
 123         wrmsrl(MSR_IA32_CR_PAT, pat);
 124         printk(KERN_INFO "x86 PAT enabled: cpu %d, old 0x%Lx, new 0x%Lx\n",
 125                smp_processor_id(), boot_pat_state, pat);
 126 }
 127
 128 #undef PAT
 129
 130 static char *cattr_name(unsigned long flags)
 131 {
 132         switch (flags & _PAGE_CACHE_MASK) {
 133         case _PAGE_CACHE_UC:            return "uncached";
 134         case _PAGE_CACHE_UC_MINUS:      return "uncached-minus";
 135         case _PAGE_CACHE_WB:            return "write-back";
 136         case _PAGE_CACHE_WC:            return "write-combining";
 137         default:                        return "broken";
 138         }
 139 }
 140
 141 /*
 142  * The global memtype list keeps track of memory type for specific
 143  * physical memory areas. Conflicting memory types in different
 144  * mappings can cause CPU cache corruption. To avoid this we keep track.
 145  *
 146  * The list is sorted based on starting address and can contain multiple
 147  * entries for each address (this allows reference counting for overlapping
 148  * areas). All the aliases have the same cache attributes of course.
 149  * Zero attributes are represented as holes.
 150  *
 151  * Currently the data structure is a list because the number of mappings
 152  * are expected to be relatively small. If this should be a problem
 153  * it could be changed to a rbtree or similar.
 154  *
 155  * memtype_lock protects the whole list.
 156  */
 157
 158 struct memtype {
 159         u64                     start;
 160         u64                     end;
 161         unsigned long           type;
 162         struct list_head        nd;
 163 };
 164
 165 static LIST_HEAD(memtype_list);
 166 static DEFINE_SPINLOCK(memtype_lock);   /* protects memtype list */
 167
 168 /*
 169  * Does intersection of PAT memory type and MTRR memory type and returns
 170  * the resulting memory type as PAT understands it.
 171  * (Type in pat and mtrr will not have same value)
 172  * The intersection is based on "Effective Memory Type" tables in IA-32
 173  * SDM vol 3a
 174  */
 175 static unsigned long pat_x_mtrr_type(u64 start, u64 end, unsigned long req_type)
 176 {
 177         /*
 178          * Look for MTRR hint to get the effective type in case where PAT
 179          * request is for WB.
 180          */
 181         if (req_type == _PAGE_CACHE_WB) {
 182                 u8 mtrr_type;
 183
 184                 mtrr_type = mtrr_type_lookup(start, end);
 185                 if (mtrr_type != MTRR_TYPE_WRBACK)
 186                         return _PAGE_CACHE_UC_MINUS;
 187
 188                 return _PAGE_CACHE_WB;
 189         }
 190
 191         return req_type;
 192 }
 193
 194 static int
 195 chk_conflict(struct memtype *new, struct memtype *entry, unsigned long *type)
 196 {
 197         if (new->type != entry->type) {
 198                 if (type) {
 199                         new->type = entry->type;
 200                         *type = entry->type;
 201                 } else
 202                         goto conflict;
 203         }
 204
 205          /* check overlaps with more than one entry in the list */
 206         list_for_each_entry_continue(entry, &memtype_list, nd) {
 207                 if (new->end <= entry->start)
 208                         break;
 209                 else if (new->type != entry->type)
 210                         goto conflict;
 211         }
 212         return 0;
 213
 214  conflict:
 215         printk(KERN_INFO "%s:%d conflicting memory types "
 216                "%Lx-%Lx %s<->%s\n", current->comm, current->pid, new->start,
 217                new->end, cattr_name(new->type), cattr_name(entry->type));
 218         return -EBUSY;
 219 }
 220
 221 static struct memtype *cached_entry;
 222 static u64 cached_start;
 223
 224 static int pat_pagerange_is_ram(unsigned long start, unsigned long end)
 225 {
 226         int ram_page = 0, not_rampage = 0;
 227         unsigned long page_nr;
 228
 229         for (page_nr = (start >> PAGE_SHIFT); page_nr < (end >> PAGE_SHIFT);
 230              ++page_nr) {
 231                 /*
 232                  * For legacy reasons, physical address range in the legacy ISA
 233                  * region is tracked as non-RAM. This will allow users of
 234                  * /dev/mem to map portions of legacy ISA region, even when
 235                  * some of those portions are listed(or not even listed) with
 236                  * different e820 types(RAM/reserved/..)
 237                  */
 238                 if (page_nr >= (ISA_END_ADDRESS >> PAGE_SHIFT) &&
 239                     page_is_ram(page_nr))
 240                         ram_page = 1;
 241                 else
 242                         not_rampage = 1;
 243
 244                 if (ram_page == not_rampage)
 245                         return -1;
 246         }
 247
 248         return ram_page;
 249 }
 250
 251 /*
 252  * For RAM pages, mark the pages as non WB memory type using
 253  * PageNonWB (PG_arch_1). We allow only one set_memory_uc() or
 254  * set_memory_wc() on a RAM page at a time before marking it as WB again.
 255  * This is ok, because only one driver will be owning the page and
 256  * doing set_memory_*() calls.
 257  *
 258  * For now, we use PageNonWB to track that the RAM page is being mapped
 259  * as non WB. In future, we will have to use one more flag
 260  * (or some other mechanism in page_struct) to distinguish between
 261  * UC and WC mapping.
 262  */
 263 static int reserve_ram_pages_type(u64 start, u64 end, unsigned long req_type,
 264                                   unsigned long *new_type)
 265 {
 266         struct page *page;
 267         u64 pfn, end_pfn;
 268
 269         for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
 270                 page = pfn_to_page(pfn);
 271                 if (page_mapped(page) || PageNonWB(page))
 272                         goto out;
 273
 274                 SetPageNonWB(page);
 275         }
 276         return 0;
 277
 278 out:
 279         end_pfn = pfn;
 280         for (pfn = (start >> PAGE_SHIFT); pfn < end_pfn; ++pfn) {
 281                 page = pfn_to_page(pfn);
 282                 ClearPageNonWB(page);
 283         }
 284
 285         return -EINVAL;
 286 }
 287
 288 static int free_ram_pages_type(u64 start, u64 end)
 289 {
 290         struct page *page;
 291         u64 pfn, end_pfn;
 292
 293         for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
 294                 page = pfn_to_page(pfn);
 295                 if (page_mapped(page) || !PageNonWB(page))
 296                         goto out;
 297
 298                 ClearPageNonWB(page);
 299         }
 300         return 0;
 301
 302 out:
 303         end_pfn = pfn;
 304         for (pfn = (start >> PAGE_SHIFT); pfn < end_pfn; ++pfn) {
 305                 page = pfn_to_page(pfn);
 306                 SetPageNonWB(page);
 307         }
 308         return -EINVAL;
 309 }
 310
 311 /*
 312  * req_type typically has one of the:
 313  * - _PAGE_CACHE_WB
 314  * - _PAGE_CACHE_WC
 315  * - _PAGE_CACHE_UC_MINUS
 316  * - _PAGE_CACHE_UC
 317  *
 318  * req_type will have a special case value '-1', when requester want to inherit
 319  * the memory type from mtrr (if WB), existing PAT, defaulting to UC_MINUS.
 320  *
 321  * If new_type is NULL, function will return an error if it cannot reserve the
 322  * region with req_type. If new_type is non-NULL, function will return
 323  * available type in new_type in case of no error. In case of any error
 324  * it will return a negative return value.
 325  */
 326 int reserve_memtype(u64 start, u64 end, unsigned long req_type,
 327                     unsigned long *new_type)
 328 {
 329         struct memtype *new, *entry;
 330         unsigned long actual_type;
 331         struct list_head *where;
 332         int is_range_ram;
 333         int err = 0;
 334
 335         BUG_ON(start >= end); /* end is exclusive */
 336
 337         if (!pat_enabled) {
 338                 /* This is identical to page table setting without PAT */
 339                 if (new_type) {
 340                         if (req_type == -1)
 341                                 *new_type = _PAGE_CACHE_WB;
 342                         else
 343                                 *new_type = req_type & _PAGE_CACHE_MASK;
 344                 }
 345                 return 0;
 346         }
 347
 348         /* Low ISA region is always mapped WB in page table. No need to track */
 349         if (is_ISA_range(start, end - 1)) {
 350                 if (new_type)
 351                         *new_type = _PAGE_CACHE_WB;
 352                 return 0;
 353         }
 354
 355         /*
 356          * Call mtrr_lookup to get the type hint. This is an
 357          * optimization for /dev/mem mmap'ers into WB memory (BIOS
 358          * tools and ACPI tools). Use WB request for WB memory and use
 359          * UC_MINUS otherwise.
 360          */
 361         actual_type = pat_x_mtrr_type(start, end, req_type & _PAGE_CACHE_MASK);
 362
 363         if (new_type)
 364                 *new_type = actual_type;
 365
 366         is_range_ram = pat_pagerange_is_ram(start, end);
 367         if (is_range_ram == 1)
 368                 return reserve_ram_pages_type(start, end, req_type,
 369                                               new_type);
 370         else if (is_range_ram < 0)
 371                 return -EINVAL;
 372
 373         new  = kmalloc(sizeof(struct memtype), GFP_KERNEL);
 374         if (!new)
 375                 return -ENOMEM;
 376
 377         new->start      = start;
 378         new->end        = end;
 379         new->type       = actual_type;
 380
 381         spin_lock(&memtype_lock);
 382
 383         if (cached_entry && start >= cached_start)
 384                 entry = cached_entry;
 385         else
 386                 entry = list_entry(&memtype_list, struct memtype, nd);
 387
 388         /* Search for existing mapping that overlaps the current range */
 389         where = NULL;
 390         list_for_each_entry_continue(entry, &memtype_list, nd) {
 391                 if (end <= entry->start) {
 392                         where = entry->nd.prev;
 393                         cached_entry = list_entry(where, struct memtype, nd);
 394                         break;
 395                 } else if (start <= entry->start) { /* end > entry->start */
 396                         err = chk_conflict(new, entry, new_type);
 397                         if (!err) {
 398                                 dprintk("Overlap at 0x%Lx-0x%Lx\n",
 399                                         entry->start, entry->end);
 400                                 where = entry->nd.prev;
 401                                 cached_entry = list_entry(where,
 402                                                         struct memtype, nd);
 403                         }
 404                         break;
 405                 } else if (start < entry->end) { /* start > entry->start */
 406                         err = chk_conflict(new, entry, new_type);
 407                         if (!err) {
 408                                 dprintk("Overlap at 0x%Lx-0x%Lx\n",
 409                                         entry->start, entry->end);
 410                                 cached_entry = list_entry(entry->nd.prev,
 411                                                         struct memtype, nd);
 412
 413                                 /*
 414                                  * Move to right position in the linked
 415                                  * list to add this new entry
 416                                  */
 417                                 list_for_each_entry_continue(entry,
 418                                                         &memtype_list, nd) {
 419                                         if (start <= entry->start) {
 420                                                 where = entry->nd.prev;
 421                                                 break;
 422                                         }
 423                                 }
 424                         }
 425                         break;
 426                 }
 427         }
 428
 429         if (err) {
 430                 printk(KERN_INFO "reserve_memtype failed 0x%Lx-0x%Lx, "
 431                        "track %s, req %s\n",
 432                        start, end, cattr_name(new->type), cattr_name(req_type));
 433                 kfree(new);
 434                 spin_unlock(&memtype_lock);
 435
 436                 return err;
 437         }
 438
 439         cached_start = start;
 440
 441         if (where)
 442                 list_add(&new->nd, where);
 443         else
 444                 list_add_tail(&new->nd, &memtype_list);
 445
 446         spin_unlock(&memtype_lock);
 447
 448         dprintk("reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s, ret %s\n",
 449                 start, end, cattr_name(new->type), cattr_name(req_type),
 450                 new_type ? cattr_name(*new_type) : "-");
 451
 452         return err;
 453 }
 454
 455 int free_memtype(u64 start, u64 end)
 456 {
 457         struct memtype *entry;
 458         int err = -EINVAL;
 459         int is_range_ram;
 460
 461         if (!pat_enabled)
 462                 return 0;
 463
 464         /* Low ISA region is always mapped WB. No need to track */
 465         if (is_ISA_range(start, end - 1))
 466                 return 0;
 467
 468         is_range_ram = pat_pagerange_is_ram(start, end);
 469         if (is_range_ram == 1)
 470                 return free_ram_pages_type(start, end);
 471         else if (is_range_ram < 0)
 472                 return -EINVAL;
 473
 474         spin_lock(&memtype_lock);
 475         list_for_each_entry(entry, &memtype_list, nd) {
 476                 if (entry->start == start && entry->end == end) {
 477                         if (cached_entry == entry || cached_start == start)
 478                                 cached_entry = NULL;
 479
 480                         list_del(&entry->nd);
 481                         kfree(entry);
 482                         err = 0;
 483                         break;
 484                 }
 485         }
 486         spin_unlock(&memtype_lock);
 487
 488         if (err) {
 489                 printk(KERN_INFO "%s:%d freeing invalid memtype %Lx-%Lx\n",
 490                         current->comm, current->pid, start, end);
 491         }
 492
 493         dprintk("free_memtype request 0x%Lx-0x%Lx\n", start, end);
 494
 495         return err;
 496 }
 497
 498
 499 pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
 500                                 unsigned long size, pgprot_t vma_prot)
 501 {
 502         return vma_prot;
 503 }
 504
 505 #ifdef CONFIG_STRICT_DEVMEM
 506 /* This check is done in drivers/char/mem.c in case of STRICT_DEVMEM*/
 507 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
 508 {
 509         return 1;
 510 }
 511 #else
 512 /* This check is needed to avoid cache aliasing when PAT is enabled */
 513 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
 514 {
 515         u64 from = ((u64)pfn) << PAGE_SHIFT;
 516         u64 to = from + size;
 517         u64 cursor = from;
 518
 519         if (!pat_enabled)
 520                 return 1;
 521
 522         while (cursor < to) {
 523                 if (!devmem_is_allowed(pfn)) {
 524                         printk(KERN_INFO
 525                 "Program %s tried to access /dev/mem between %Lx->%Lx.\n",
 526                                 current->comm, from, to);
 527                         return 0;
 528                 }
 529                 cursor += PAGE_SIZE;
 530                 pfn++;
 531         }
 532         return 1;
 533 }
 534 #endif /* CONFIG_STRICT_DEVMEM */
 535
 536 int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
 537                                 unsigned long size, pgprot_t *vma_prot)
 538 {
 539         unsigned long flags = _PAGE_CACHE_WB;
 540
 541         if (!range_is_allowed(pfn, size))
 542                 return 0;
 543
 544         if (file->f_flags & O_SYNC) {
 545                 flags = _PAGE_CACHE_UC_MINUS;
 546         }
 547
 548 #ifdef CONFIG_X86_32
 549         /*
 550          * On the PPro and successors, the MTRRs are used to set
 551          * memory types for physical addresses outside main memory,
 552          * so blindly setting UC or PWT on those pages is wrong.
 553          * For Pentiums and earlier, the surround logic should disable
 554          * caching for the high addresses through the KEN pin, but
 555          * we maintain the tradition of paranoia in this code.
 556          */
 557         if (!pat_enabled &&
 558             !(boot_cpu_has(X86_FEATURE_MTRR) ||
 559               boot_cpu_has(X86_FEATURE_K6_MTRR) ||
 560               boot_cpu_has(X86_FEATURE_CYRIX_ARR) ||
 561               boot_cpu_has(X86_FEATURE_CENTAUR_MCR)) &&
 562             (pfn << PAGE_SHIFT) >= __pa(high_memory)) {
 563                 flags = _PAGE_CACHE_UC;
 564         }
 565 #endif
 566
 567         *vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |
 568                              flags);
 569         return 1;
 570 }
 571
 572 /*
 573  * Change the memory type for the physial address range in kernel identity
 574  * mapping space if that range is a part of identity map.
 575  */
 576 int kernel_map_sync_memtype(u64 base, unsigned long size, unsigned long flags)
 577 {
 578         unsigned long id_sz;
 579
 580         if (!pat_enabled || base >= __pa(high_memory))
 581                 return 0;
 582
 583         id_sz = (__pa(high_memory) < base + size) ?
 584                                 __pa(high_memory) - base :
 585                                 size;
 586
 587         if (ioremap_change_attr((unsigned long)__va(base), id_sz, flags) < 0) {
 588                 printk(KERN_INFO
 589                         "%s:%d ioremap_change_attr failed %s "
 590                         "for %Lx-%Lx\n",
 591                         current->comm, current->pid,
 592                         cattr_name(flags),
 593                         base, (unsigned long long)(base + size));
 594                 return -EINVAL;
 595         }
 596         return 0;
 597 }
 598
 599 /*
 600  * Internal interface to reserve a range of physical memory with prot.
 601  * Reserved non RAM regions only and after successful reserve_memtype,
 602  * this func also keeps identity mapping (if any) in sync with this new prot.
 603  */
 604 static int reserve_pfn_range(u64 paddr, unsigned long size, pgprot_t *vma_prot,
 605                                 int strict_prot)
 606 {
 607         int is_ram = 0;
 608         int ret;
 609         unsigned long want_flags = (pgprot_val(*vma_prot) & _PAGE_CACHE_MASK);
 610         unsigned long flags = want_flags;
 611
 612         is_ram = pat_pagerange_is_ram(paddr, paddr + size);
 613
 614         /*
 615          * reserve_pfn_range() doesn't support RAM pages. Maintain the current
 616          * behavior with RAM pages by returning success.
 617          */
 618         if (is_ram != 0)
 619                 return 0;
 620
 621         ret = reserve_memtype(paddr, paddr + size, want_flags, &flags);
 622         if (ret)
 623                 return ret;
 624
 625         if (flags != want_flags) {
 626                 if (strict_prot || !is_new_memtype_allowed(want_flags, flags)) {
 627                         free_memtype(paddr, paddr + size);
 628                         printk(KERN_ERR "%s:%d map pfn expected mapping type %s"
 629                                 " for %Lx-%Lx, got %s\n",
 630                                 current->comm, current->pid,
 631                                 cattr_name(want_flags),
 632                                 (unsigned long long)paddr,
 633                                 (unsigned long long)(paddr + size),
 634                                 cattr_name(flags));
 635                         return -EINVAL;
 636                 }
 637                 /*
 638                  * We allow returning different type than the one requested in
 639                  * non strict case.
 640                  */
 641                 *vma_prot = __pgprot((pgprot_val(*vma_prot) &
 642                                       (~_PAGE_CACHE_MASK)) |
 643                                      flags);
 644         }
 645
 646         if (kernel_map_sync_memtype(paddr, size, flags) < 0) {
 647                 free_memtype(paddr, paddr + size);
 648                 return -EINVAL;
 649         }
 650         return 0;
 651 }
 652
 653 /*
 654  * Internal interface to free a range of physical memory.
 655  * Frees non RAM regions only.
 656  */
 657 static void free_pfn_range(u64 paddr, unsigned long size)
 658 {
 659         int is_ram;
 660
 661         is_ram = pat_pagerange_is_ram(paddr, paddr + size);
 662         if (is_ram == 0)
 663                 free_memtype(paddr, paddr + size);
 664 }
 665
 666 /*
 667  * track_pfn_vma_copy is called when vma that is covering the pfnmap gets
 668  * copied through copy_page_range().
 669  *
 670  * If the vma has a linear pfn mapping for the entire range, we get the prot
 671  * from pte and reserve the entire vma range with single reserve_pfn_range call.
 672  * Otherwise, we reserve the entire vma range, my ging through the PTEs page
 673  * by page to get physical address and protection.
 674  */
 675 int track_pfn_vma_copy(struct vm_area_struct *vma)
 676 {
 677         int retval = 0;
 678         unsigned long i, j;
 679         resource_size_t paddr;
 680         unsigned long prot;
 681         unsigned long vma_start = vma->vm_start;
 682         unsigned long vma_end = vma->vm_end;
 683         unsigned long vma_size = vma_end - vma_start;
 684         pgprot_t pgprot;
 685
 686         if (!pat_enabled)
 687                 return 0;
 688
 689         if (is_linear_pfn_mapping(vma)) {
 690                 /*
 691                  * reserve the whole chunk covered by vma. We need the
 692                  * starting address and protection from pte.
 693                  */
 694                 if (follow_phys(vma, vma_start, 0, &prot, &paddr)) {
 695                         WARN_ON_ONCE(1);
 696                         return -EINVAL;
 697                 }
 698                 pgprot = __pgprot(prot);
 699                 return reserve_pfn_range(paddr, vma_size, &pgprot, 1);
 700         }
 701
 702         /* reserve entire vma page by page, using pfn and prot from pte */
 703         for (i = 0; i < vma_size; i += PAGE_SIZE) {
 704                 if (follow_phys(vma, vma_start + i, 0, &prot, &paddr))
 705                         continue;
 706
 707                 pgprot = __pgprot(prot);
 708                 retval = reserve_pfn_range(paddr, PAGE_SIZE, &pgprot, 1);
 709                 if (retval)
 710                         goto cleanup_ret;
 711         }
 712         return 0;
 713
 714 cleanup_ret:
 715         /* Reserve error: Cleanup partial reservation and return error */
 716         for (j = 0; j < i; j += PAGE_SIZE) {
 717                 if (follow_phys(vma, vma_start + j, 0, &prot, &paddr))
 718                         continue;
 719
 720                 free_pfn_range(paddr, PAGE_SIZE);
 721         }
 722
 723         return retval;
 724 }
 725
 726 /*
 727  * track_pfn_vma_new is called when a _new_ pfn mapping is being established
 728  * for physical range indicated by pfn and size.
 729  *
 730  * prot is passed in as a parameter for the new mapping. If the vma has a
 731  * linear pfn mapping for the entire range reserve the entire vma range with
 732  * single reserve_pfn_range call.
 733  * Otherwise, we look t the pfn and size and reserve only the specified range
 734  * page by page.
 735  *
 736  * Note that this function can be called with caller trying to map only a
 737  * subrange/page inside the vma.
 738  */
 739 int track_pfn_vma_new(struct vm_area_struct *vma, pgprot_t *prot,
 740                         unsigned long pfn, unsigned long size)
 741 {
 742         int retval = 0;
 743         unsigned long i, j;
 744         resource_size_t base_paddr;
 745         resource_size_t paddr;
 746         unsigned long vma_start = vma->vm_start;
 747         unsigned long vma_end = vma->vm_end;
 748         unsigned long vma_size = vma_end - vma_start;
 749
 750         if (!pat_enabled)
 751                 return 0;
 752
 753         if (is_linear_pfn_mapping(vma)) {
 754                 /* reserve the whole chunk starting from vm_pgoff */
 755                 paddr = (resource_size_t)vma->vm_pgoff << PAGE_SHIFT;
 756                 return reserve_pfn_range(paddr, vma_size, prot, 0);
 757         }
 758
 759         /* reserve page by page using pfn and size */
 760         base_paddr = (resource_size_t)pfn << PAGE_SHIFT;
 761         for (i = 0; i < size; i += PAGE_SIZE) {
 762                 paddr = base_paddr + i;
 763                 retval = reserve_pfn_range(paddr, PAGE_SIZE, prot, 0);
 764                 if (retval)
 765                         goto cleanup_ret;
 766         }
 767         return 0;
 768
 769 cleanup_ret:
 770         /* Reserve error: Cleanup partial reservation and return error */
 771         for (j = 0; j < i; j += PAGE_SIZE) {
 772                 paddr = base_paddr + j;
 773                 free_pfn_range(paddr, PAGE_SIZE);
 774         }
 775
 776         return retval;
 777 }
 778
 779 /*
 780  * untrack_pfn_vma is called while unmapping a pfnmap for a region.
 781  * untrack can be called for a specific region indicated by pfn and size or
 782  * can be for the entire vma (in which case size can be zero).
 783  */
 784 void untrack_pfn_vma(struct vm_area_struct *vma, unsigned long pfn,
 785                         unsigned long size)
 786 {
 787         unsigned long i;
 788         resource_size_t paddr;
 789         unsigned long prot;
 790         unsigned long vma_start = vma->vm_start;
 791         unsigned long vma_end = vma->vm_end;
 792         unsigned long vma_size = vma_end - vma_start;
 793
 794         if (!pat_enabled)
 795                 return;
 796
 797         if (is_linear_pfn_mapping(vma)) {
 798                 /* free the whole chunk starting from vm_pgoff */
 799                 paddr = (resource_size_t)vma->vm_pgoff << PAGE_SHIFT;
 800                 free_pfn_range(paddr, vma_size);
 801                 return;
 802         }
 803
 804         if (size != 0 && size != vma_size) {
 805                 /* free page by page, using pfn and size */
 806                 paddr = (resource_size_t)pfn << PAGE_SHIFT;
 807                 for (i = 0; i < size; i += PAGE_SIZE) {
 808                         paddr = paddr + i;
 809                         free_pfn_range(paddr, PAGE_SIZE);
 810                 }
 811         } else {
 812                 /* free entire vma, page by page, using the pfn from pte */
 813                 for (i = 0; i < vma_size; i += PAGE_SIZE) {
 814                         if (follow_phys(vma, vma_start + i, 0, &prot, &paddr))
 815                                 continue;
 816
 817                         free_pfn_range(paddr, PAGE_SIZE);
 818                 }
 819         }
 820 }
 821
 822 pgprot_t pgprot_writecombine(pgprot_t prot)
 823 {
 824         if (pat_enabled)
 825                 return __pgprot(pgprot_val(prot) | _PAGE_CACHE_WC);
 826         else
 827                 return pgprot_noncached(prot);
 828 }
 829 EXPORT_SYMBOL_GPL(pgprot_writecombine);
 830
 831 #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_X86_PAT)
 832
 833 /* get Nth element of the linked list */
 834 static struct memtype *memtype_get_idx(loff_t pos)
 835 {
 836         struct memtype *list_node, *print_entry;
 837         int i = 1;
 838
 839         print_entry  = kmalloc(sizeof(struct memtype), GFP_KERNEL);
 840         if (!print_entry)
 841                 return NULL;
 842
 843         spin_lock(&memtype_lock);
 844         list_for_each_entry(list_node, &memtype_list, nd) {
 845                 if (pos == i) {
 846                         *print_entry = *list_node;
 847                         spin_unlock(&memtype_lock);
 848                         return print_entry;
 849                 }
 850                 ++i;
 851         }
 852         spin_unlock(&memtype_lock);
 853         kfree(print_entry);
 854
 855         return NULL;
 856 }
 857
 858 static void *memtype_seq_start(struct seq_file *seq, loff_t *pos)
 859 {
 860         if (*pos == 0) {
 861                 ++*pos;
 862                 seq_printf(seq, "PAT memtype list:\n");
 863         }
 864
 865         return memtype_get_idx(*pos);
 866 }
 867
 868 static void *memtype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 869 {
 870         ++*pos;
 871         return memtype_get_idx(*pos);
 872 }
 873
 874 static void memtype_seq_stop(struct seq_file *seq, void *v)
 875 {
 876 }
 877
 878 static int memtype_seq_show(struct seq_file *seq, void *v)
 879 {
 880         struct memtype *print_entry = (struct memtype *)v;
 881
 882         seq_printf(seq, "%s @ 0x%Lx-0x%Lx\n", cattr_name(print_entry->type),
 883                         print_entry->start, print_entry->end);
 884         kfree(print_entry);
 885
 886         return 0;
 887 }
 888
 889 static struct seq_operations memtype_seq_ops = {
 890         .start = memtype_seq_start,
 891         .next  = memtype_seq_next,
 892         .stop  = memtype_seq_stop,
 893         .show  = memtype_seq_show,
 894 };
 895
 896 static int memtype_seq_open(struct inode *inode, struct file *file)
 897 {
 898         return seq_open(file, &memtype_seq_ops);
 899 }
 900
 901 static const struct file_operations memtype_fops = {
 902         .open    = memtype_seq_open,
 903         .read    = seq_read,
 904         .llseek  = seq_lseek,
 905         .release = seq_release,
 906 };
 907
 908 static int __init pat_memtype_list_init(void)
 909 {
 910         debugfs_create_file("pat_memtype_list", S_IRUSR, arch_debugfs_dir,
 911                                 NULL, &memtype_fops);
 912         return 0;
 913 }
 914
 915 late_initcall(pat_memtype_list_init);
 916
 917 #endif /* CONFIG_DEBUG_FS && CONFIG_X86_PAT */