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/mm.h>
  11 #include <linux/kernel.h>
  12 #include <linux/gfp.h>
  13 #include <linux/fs.h>
  14 #include <linux/bootmem.h>
  15 #include <linux/debugfs.h>
  16 #include <linux/seq_file.h>
  17
  18 #include <asm/msr.h>
  19 #include <asm/tlbflush.h>
  20 #include <asm/processor.h>
  21 #include <asm/page.h>
  22 #include <asm/pgtable.h>
  23 #include <asm/pat.h>
  24 #include <asm/e820.h>
  25 #include <asm/cacheflush.h>
  26 #include <asm/fcntl.h>
  27 #include <asm/mtrr.h>
  28 #include <asm/io.h>
  29
  30 #ifdef CONFIG_X86_PAT
  31 int __read_mostly pat_enabled = 1;
  32
  33 void __cpuinit pat_disable(char *reason)
  34 {
  35         pat_enabled = 0;
  36         printk(KERN_INFO "%s\n", reason);
  37 }
  38
  39 static int __init nopat(char *str)
  40 {
  41         pat_disable("PAT support disabled.");
  42         return 0;
  43 }
  44 early_param("nopat", nopat);
  45 #endif
  46
  47
  48 static int debug_enable;
  49 static int __init pat_debug_setup(char *str)
  50 {
  51         debug_enable = 1;
  52         return 0;
  53 }
  54 __setup("debugpat", pat_debug_setup);
  55
  56 #define dprintk(fmt, arg...) \
  57         do { if (debug_enable) printk(KERN_INFO fmt, ##arg); } while (0)
  58
  59
  60 static u64 __read_mostly boot_pat_state;
  61
  62 enum {
  63         PAT_UC = 0,             /* uncached */
  64         PAT_WC = 1,             /* Write combining */
  65         PAT_WT = 4,             /* Write Through */
  66         PAT_WP = 5,             /* Write Protected */
  67         PAT_WB = 6,             /* Write Back (default) */
  68         PAT_UC_MINUS = 7,       /* UC, but can be overriden by MTRR */
  69 };
  70
  71 #define PAT(x, y)       ((u64)PAT_ ## y << ((x)*8))
  72
  73 void pat_init(void)
  74 {
  75         u64 pat;
  76
  77         if (!pat_enabled)
  78                 return;
  79
  80         /* Paranoia check. */
  81         if (!cpu_has_pat && boot_pat_state) {
  82                 /*
  83                  * If this happens we are on a secondary CPU, but
  84                  * switched to PAT on the boot CPU. We have no way to
  85                  * undo PAT.
  86                  */
  87                 printk(KERN_ERR "PAT enabled, "
  88                        "but not supported by secondary CPU\n");
  89                 BUG();
  90         }
  91
  92         /* Set PWT to Write-Combining. All other bits stay the same */
  93         /*
  94          * PTE encoding used in Linux:
  95          *      PAT
  96          *      |PCD
  97          *      ||PWT
  98          *      |||
  99          *      000 WB          _PAGE_CACHE_WB
 100          *      001 WC          _PAGE_CACHE_WC
 101          *      010 UC-         _PAGE_CACHE_UC_MINUS
 102          *      011 UC          _PAGE_CACHE_UC
 103          * PAT bit unused
 104          */
 105         pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
 106               PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, UC);
 107
 108         /* Boot CPU check */
 109         if (!boot_pat_state)
 110                 rdmsrl(MSR_IA32_CR_PAT, boot_pat_state);
 111
 112         wrmsrl(MSR_IA32_CR_PAT, pat);
 113         printk(KERN_INFO "x86 PAT enabled: cpu %d, old 0x%Lx, new 0x%Lx\n",
 114                smp_processor_id(), boot_pat_state, pat);
 115 }
 116
 117 #undef PAT
 118
 119 static char *cattr_name(unsigned long flags)
 120 {
 121         switch (flags & _PAGE_CACHE_MASK) {
 122         case _PAGE_CACHE_UC:            return "uncached";
 123         case _PAGE_CACHE_UC_MINUS:      return "uncached-minus";
 124         case _PAGE_CACHE_WB:            return "write-back";
 125         case _PAGE_CACHE_WC:            return "write-combining";
 126         default:                        return "broken";
 127         }
 128 }
 129
 130 /*
 131  * The global memtype list keeps track of memory type for specific
 132  * physical memory areas. Conflicting memory types in different
 133  * mappings can cause CPU cache corruption. To avoid this we keep track.
 134  *
 135  * The list is sorted based on starting address and can contain multiple
 136  * entries for each address (this allows reference counting for overlapping
 137  * areas). All the aliases have the same cache attributes of course.
 138  * Zero attributes are represented as holes.
 139  *
 140  * Currently the data structure is a list because the number of mappings
 141  * are expected to be relatively small. If this should be a problem
 142  * it could be changed to a rbtree or similar.
 143  *
 144  * memtype_lock protects the whole list.
 145  */
 146
 147 struct memtype {
 148         u64 start;
 149         u64 end;
 150         unsigned long type;
 151         struct list_head nd;
 152 };
 153
 154 static LIST_HEAD(memtype_list);
 155 static DEFINE_SPINLOCK(memtype_lock);   /* protects memtype list */
 156
 157 /*
 158  * Does intersection of PAT memory type and MTRR memory type and returns
 159  * the resulting memory type as PAT understands it.
 160  * (Type in pat and mtrr will not have same value)
 161  * The intersection is based on "Effective Memory Type" tables in IA-32
 162  * SDM vol 3a
 163  */
 164 static unsigned long pat_x_mtrr_type(u64 start, u64 end, unsigned long req_type)
 165 {
 166         /*
 167          * Look for MTRR hint to get the effective type in case where PAT
 168          * request is for WB.
 169          */
 170         if (req_type == _PAGE_CACHE_WB) {
 171                 u8 mtrr_type;
 172
 173                 mtrr_type = mtrr_type_lookup(start, end);
 174                 if (mtrr_type == MTRR_TYPE_UNCACHABLE)
 175                         return _PAGE_CACHE_UC;
 176                 if (mtrr_type == MTRR_TYPE_WRCOMB)
 177                         return _PAGE_CACHE_WC;
 178         }
 179
 180         return req_type;
 181 }
 182
 183 static int chk_conflict(struct memtype *new, struct memtype *entry,
 184                         unsigned long *type)
 185 {
 186         if (new->type != entry->type) {
 187                 if (type) {
 188                         new->type = entry->type;
 189                         *type = entry->type;
 190                 } else
 191                         goto conflict;
 192         }
 193
 194          /* check overlaps with more than one entry in the list */
 195         list_for_each_entry_continue(entry, &memtype_list, nd) {
 196                 if (new->end <= entry->start)
 197                         break;
 198                 else if (new->type != entry->type)
 199                         goto conflict;
 200         }
 201         return 0;
 202
 203  conflict:
 204         printk(KERN_INFO "%s:%d conflicting memory types "
 205                "%Lx-%Lx %s<->%s\n", current->comm, current->pid, new->start,
 206                new->end, cattr_name(new->type), cattr_name(entry->type));
 207         return -EBUSY;
 208 }
 209
 210 /*
 211  * req_type typically has one of the:
 212  * - _PAGE_CACHE_WB
 213  * - _PAGE_CACHE_WC
 214  * - _PAGE_CACHE_UC_MINUS
 215  * - _PAGE_CACHE_UC
 216  *
 217  * req_type will have a special case value '-1', when requester want to inherit
 218  * the memory type from mtrr (if WB), existing PAT, defaulting to UC_MINUS.
 219  *
 220  * If new_type is NULL, function will return an error if it cannot reserve the
 221  * region with req_type. If new_type is non-NULL, function will return
 222  * available type in new_type in case of no error. In case of any error
 223  * it will return a negative return value.
 224  */
 225 int reserve_memtype(u64 start, u64 end, unsigned long req_type,
 226                         unsigned long *new_type)
 227 {
 228         struct memtype *new, *entry;
 229         unsigned long actual_type;
 230         struct list_head *where;
 231         int err = 0;
 232
 233         BUG_ON(start >= end); /* end is exclusive */
 234
 235         if (!pat_enabled) {
 236                 /* This is identical to page table setting without PAT */
 237                 if (new_type) {
 238                         if (req_type == -1)
 239                                 *new_type = _PAGE_CACHE_WB;
 240                         else
 241                                 *new_type = req_type & _PAGE_CACHE_MASK;
 242                 }
 243                 return 0;
 244         }
 245
 246         /* Low ISA region is always mapped WB in page table. No need to track */
 247         if (is_ISA_range(start, end - 1)) {
 248                 if (new_type)
 249                         *new_type = _PAGE_CACHE_WB;
 250                 return 0;
 251         }
 252
 253         if (req_type == -1) {
 254                 /*
 255                  * Call mtrr_lookup to get the type hint. This is an
 256                  * optimization for /dev/mem mmap'ers into WB memory (BIOS
 257                  * tools and ACPI tools). Use WB request for WB memory and use
 258                  * UC_MINUS otherwise.
 259                  */
 260                 u8 mtrr_type = mtrr_type_lookup(start, end);
 261
 262                 if (mtrr_type == MTRR_TYPE_WRBACK)
 263                         actual_type = _PAGE_CACHE_WB;
 264                 else
 265                         actual_type = _PAGE_CACHE_UC_MINUS;
 266         } else
 267                 actual_type = pat_x_mtrr_type(start, end,
 268                                               req_type & _PAGE_CACHE_MASK);
 269
 270         new  = kmalloc(sizeof(struct memtype), GFP_KERNEL);
 271         if (!new)
 272                 return -ENOMEM;
 273
 274         new->start = start;
 275         new->end = end;
 276         new->type = actual_type;
 277
 278         if (new_type)
 279                 *new_type = actual_type;
 280
 281         spin_lock(&memtype_lock);
 282
 283         /* Search for existing mapping that overlaps the current range */
 284         where = NULL;
 285         list_for_each_entry(entry, &memtype_list, nd) {
 286                 if (end <= entry->start) {
 287                         where = entry->nd.prev;
 288                         break;
 289                 } else if (start <= entry->start) { /* end > entry->start */
 290                         err = chk_conflict(new, entry, new_type);
 291                         if (!err) {
 292                                 dprintk("Overlap at 0x%Lx-0x%Lx\n",
 293                                         entry->start, entry->end);
 294                                 where = entry->nd.prev;
 295                         }
 296                         break;
 297                 } else if (start < entry->end) { /* start > entry->start */
 298                         err = chk_conflict(new, entry, new_type);
 299                         if (!err) {
 300                                 dprintk("Overlap at 0x%Lx-0x%Lx\n",
 301                                         entry->start, entry->end);
 302                                 where = &entry->nd;
 303                         }
 304                         break;
 305                 }
 306         }
 307
 308         if (err) {
 309                 printk(KERN_INFO "reserve_memtype failed 0x%Lx-0x%Lx, "
 310                        "track %s, req %s\n",
 311                        start, end, cattr_name(new->type), cattr_name(req_type));
 312                 kfree(new);
 313                 spin_unlock(&memtype_lock);
 314                 return err;
 315         }
 316
 317         if (where)
 318                 list_add(&new->nd, where);
 319         else
 320                 list_add_tail(&new->nd, &memtype_list);
 321
 322         spin_unlock(&memtype_lock);
 323
 324         dprintk("reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s, ret %s\n",
 325                 start, end, cattr_name(new->type), cattr_name(req_type),
 326                 new_type ? cattr_name(*new_type) : "-");
 327
 328         return err;
 329 }
 330
 331 int free_memtype(u64 start, u64 end)
 332 {
 333         struct memtype *entry;
 334         int err = -EINVAL;
 335
 336         if (!pat_enabled)
 337                 return 0;
 338
 339         /* Low ISA region is always mapped WB. No need to track */
 340         if (is_ISA_range(start, end - 1))
 341                 return 0;
 342
 343         spin_lock(&memtype_lock);
 344         list_for_each_entry(entry, &memtype_list, nd) {
 345                 if (entry->start == start && entry->end == end) {
 346                         list_del(&entry->nd);
 347                         kfree(entry);
 348                         err = 0;
 349                         break;
 350                 }
 351         }
 352         spin_unlock(&memtype_lock);
 353
 354         if (err) {
 355                 printk(KERN_INFO "%s:%d freeing invalid memtype %Lx-%Lx\n",
 356                         current->comm, current->pid, start, end);
 357         }
 358
 359         dprintk("free_memtype request 0x%Lx-0x%Lx\n", start, end);
 360         return err;
 361 }
 362
 363
 364 /*
 365  * /dev/mem mmap interface. The memtype used for mapping varies:
 366  * - Use UC for mappings with O_SYNC flag
 367  * - Without O_SYNC flag, if there is any conflict in reserve_memtype,
 368  *   inherit the memtype from existing mapping.
 369  * - Else use UC_MINUS memtype (for backward compatibility with existing
 370  *   X drivers.
 371  */
 372 pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
 373                                 unsigned long size, pgprot_t vma_prot)
 374 {
 375         return vma_prot;
 376 }
 377
 378 #ifdef CONFIG_STRICT_DEVMEM
 379 /* This check is done in drivers/char/mem.c in case of STRICT_DEVMEM*/
 380 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
 381 {
 382         return 1;
 383 }
 384 #else
 385 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
 386 {
 387         u64 from = ((u64)pfn) << PAGE_SHIFT;
 388         u64 to = from + size;
 389         u64 cursor = from;
 390
 391         while (cursor < to) {
 392                 if (!devmem_is_allowed(pfn)) {
 393                         printk(KERN_INFO
 394                 "Program %s tried to access /dev/mem between %Lx->%Lx.\n",
 395                                 current->comm, from, to);
 396                         return 0;
 397                 }
 398                 cursor += PAGE_SIZE;
 399                 pfn++;
 400         }
 401         return 1;
 402 }
 403 #endif /* CONFIG_STRICT_DEVMEM */
 404
 405 int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
 406                                 unsigned long size, pgprot_t *vma_prot)
 407 {
 408         u64 offset = ((u64) pfn) << PAGE_SHIFT;
 409         unsigned long flags = _PAGE_CACHE_UC_MINUS;
 410         int retval;
 411
 412         if (!range_is_allowed(pfn, size))
 413                 return 0;
 414
 415         if (file->f_flags & O_SYNC) {
 416                 flags = _PAGE_CACHE_UC;
 417         }
 418
 419 #ifdef CONFIG_X86_32
 420         /*
 421          * On the PPro and successors, the MTRRs are used to set
 422          * memory types for physical addresses outside main memory,
 423          * so blindly setting UC or PWT on those pages is wrong.
 424          * For Pentiums and earlier, the surround logic should disable
 425          * caching for the high addresses through the KEN pin, but
 426          * we maintain the tradition of paranoia in this code.
 427          */
 428         if (!pat_enabled &&
 429             !(boot_cpu_has(X86_FEATURE_MTRR) ||
 430               boot_cpu_has(X86_FEATURE_K6_MTRR) ||
 431               boot_cpu_has(X86_FEATURE_CYRIX_ARR) ||
 432               boot_cpu_has(X86_FEATURE_CENTAUR_MCR)) &&
 433             (pfn << PAGE_SHIFT) >= __pa(high_memory)) {
 434                 flags = _PAGE_CACHE_UC;
 435         }
 436 #endif
 437
 438         /*
 439          * With O_SYNC, we can only take UC mapping. Fail if we cannot.
 440          * Without O_SYNC, we want to get
 441          * - WB for WB-able memory and no other conflicting mappings
 442          * - UC_MINUS for non-WB-able memory with no other conflicting mappings
 443          * - Inherit from confliting mappings otherwise
 444          */
 445         if (flags != _PAGE_CACHE_UC_MINUS) {
 446                 retval = reserve_memtype(offset, offset + size, flags, NULL);
 447         } else {
 448                 retval = reserve_memtype(offset, offset + size, -1, &flags);
 449         }
 450
 451         if (retval < 0)
 452                 return 0;
 453
 454         if (((pfn < max_low_pfn_mapped) ||
 455              (pfn >= (1UL<<(32 - PAGE_SHIFT)) && pfn < max_pfn_mapped)) &&
 456             ioremap_change_attr((unsigned long)__va(offset), size, flags) < 0) {
 457                 free_memtype(offset, offset + size);
 458                 printk(KERN_INFO
 459                 "%s:%d /dev/mem ioremap_change_attr failed %s for %Lx-%Lx\n",
 460                         current->comm, current->pid,
 461                         cattr_name(flags),
 462                         offset, (unsigned long long)(offset + size));
 463                 return 0;
 464         }
 465
 466         *vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |
 467                              flags);
 468         return 1;
 469 }
 470
 471 void map_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)
 472 {
 473         u64 addr = (u64)pfn << PAGE_SHIFT;
 474         unsigned long flags;
 475         unsigned long want_flags = (pgprot_val(vma_prot) & _PAGE_CACHE_MASK);
 476
 477         reserve_memtype(addr, addr + size, want_flags, &flags);
 478         if (flags != want_flags) {
 479                 printk(KERN_INFO
 480                 "%s:%d /dev/mem expected mapping type %s for %Lx-%Lx, got %s\n",
 481                         current->comm, current->pid,
 482                         cattr_name(want_flags),
 483                         addr, (unsigned long long)(addr + size),
 484                         cattr_name(flags));
 485         }
 486 }
 487
 488 void unmap_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)
 489 {
 490         u64 addr = (u64)pfn << PAGE_SHIFT;
 491
 492         free_memtype(addr, addr + size);
 493 }
 494
 495 #if defined(CONFIG_DEBUG_FS)
 496
 497 /* get Nth element of the linked list */
 498 static struct memtype *memtype_get_idx(loff_t pos)
 499 {
 500         struct memtype *list_node, *print_entry;
 501         int i = 1;
 502
 503         print_entry  = kmalloc(sizeof(struct memtype), GFP_KERNEL);
 504         if (!print_entry)
 505                 return NULL;
 506
 507         spin_lock(&memtype_lock);
 508         list_for_each_entry(list_node, &memtype_list, nd) {
 509                 if (pos == i) {
 510                         *print_entry = *list_node;
 511                         spin_unlock(&memtype_lock);
 512                         return print_entry;
 513                 }
 514                 ++i;
 515         }
 516         spin_unlock(&memtype_lock);
 517         kfree(print_entry);
 518         return NULL;
 519 }
 520
 521 static void *memtype_seq_start(struct seq_file *seq, loff_t *pos)
 522 {
 523         if (*pos == 0) {
 524                 ++*pos;
 525                 seq_printf(seq, "PAT memtype list:\n");
 526         }
 527
 528         return memtype_get_idx(*pos);
 529 }
 530
 531 static void *memtype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 532 {
 533         ++*pos;
 534         return memtype_get_idx(*pos);
 535 }
 536
 537 static void memtype_seq_stop(struct seq_file *seq, void *v)
 538 {
 539 }
 540
 541 static int memtype_seq_show(struct seq_file *seq, void *v)
 542 {
 543         struct memtype *print_entry = (struct memtype *)v;
 544
 545         seq_printf(seq, "%s @ 0x%Lx-0x%Lx\n", cattr_name(print_entry->type),
 546                         print_entry->start, print_entry->end);
 547         kfree(print_entry);
 548         return 0;
 549 }
 550
 551 static struct seq_operations memtype_seq_ops = {
 552         .start = memtype_seq_start,
 553         .next  = memtype_seq_next,
 554         .stop  = memtype_seq_stop,
 555         .show  = memtype_seq_show,
 556 };
 557
 558 static int memtype_seq_open(struct inode *inode, struct file *file)
 559 {
 560         return seq_open(file, &memtype_seq_ops);
 561 }
 562
 563 static const struct file_operations memtype_fops = {
 564         .open    = memtype_seq_open,
 565         .read    = seq_read,
 566         .llseek  = seq_lseek,
 567         .release = seq_release,
 568 };
 569
 570 static int __init pat_memtype_list_init(void)
 571 {
 572         debugfs_create_file("pat_memtype_list", S_IRUSR, arch_debugfs_dir,
 573                                 NULL, &memtype_fops);
 574         return 0;
 575 }
 576
 577 late_initcall(pat_memtype_list_init);
 578
 579 #endif /* CONFIG_DEBUG_FS */