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/slab.h>
  16 #include <linux/mm.h>
  17 #include <linux/fs.h>
  18 #include <linux/rbtree.h>
  19
  20 #include <asm/cacheflush.h>
  21 #include <asm/processor.h>
  22 #include <asm/tlbflush.h>
  23 #include <asm/x86_init.h>
  24 #include <asm/pgtable.h>
  25 #include <asm/fcntl.h>
  26 #include <asm/e820.h>
  27 #include <asm/mtrr.h>
  28 #include <asm/page.h>
  29 #include <asm/msr.h>
  30 #include <asm/pat.h>
  31 #include <asm/io.h>
  32
  33 #include "pat_internal.h"
  34 #include "mm_internal.h"
  35
  36 #undef pr_fmt
  37 #define pr_fmt(fmt) "" fmt
  38
  39 static bool boot_cpu_done;
  40
  41 static int __read_mostly __pat_enabled = IS_ENABLED(CONFIG_X86_PAT);
  42
  43 static inline void pat_disable(const char *reason)
  44 {
  45         __pat_enabled = 0;
  46         pr_info("x86/PAT: %s\n", reason);
  47 }
  48
  49 static int __init nopat(char *str)
  50 {
  51         pat_disable("PAT support disabled.");
  52         return 0;
  53 }
  54 early_param("nopat", nopat);
  55
  56 bool pat_enabled(void)
  57 {
  58         return !!__pat_enabled;
  59 }
  60 EXPORT_SYMBOL_GPL(pat_enabled);
  61
  62 int pat_debug_enable;
  63
  64 static int __init pat_debug_setup(char *str)
  65 {
  66         pat_debug_enable = 1;
  67         return 0;
  68 }
  69 __setup("debugpat", pat_debug_setup);
  70
  71 #ifdef CONFIG_X86_PAT
  72 /*
  73  * X86 PAT uses page flags WC and Uncached together to keep track of
  74  * memory type of pages that have backing page struct. X86 PAT supports 3
  75  * different memory types, _PAGE_CACHE_MODE_WB, _PAGE_CACHE_MODE_WC and
  76  * _PAGE_CACHE_MODE_UC_MINUS and fourth state where page's memory type has not
  77  * been changed from its default (value of -1 used to denote this).
  78  * Note we do not support _PAGE_CACHE_MODE_UC here.
  79  */
  80
  81 #define _PGMT_DEFAULT           0
  82 #define _PGMT_WC                (1UL << PG_arch_1)
  83 #define _PGMT_UC_MINUS          (1UL << PG_uncached)
  84 #define _PGMT_WB                (1UL << PG_uncached | 1UL << PG_arch_1)
  85 #define _PGMT_MASK              (1UL << PG_uncached | 1UL << PG_arch_1)
  86 #define _PGMT_CLEAR_MASK        (~_PGMT_MASK)
  87
  88 static inline enum page_cache_mode get_page_memtype(struct page *pg)
  89 {
  90         unsigned long pg_flags = pg->flags & _PGMT_MASK;
  91
  92         if (pg_flags == _PGMT_DEFAULT)
  93                 return -1;
  94         else if (pg_flags == _PGMT_WC)
  95                 return _PAGE_CACHE_MODE_WC;
  96         else if (pg_flags == _PGMT_UC_MINUS)
  97                 return _PAGE_CACHE_MODE_UC_MINUS;
  98         else
  99                 return _PAGE_CACHE_MODE_WB;
 100 }
 101
 102 static inline void set_page_memtype(struct page *pg,
 103                                     enum page_cache_mode memtype)
 104 {
 105         unsigned long memtype_flags;
 106         unsigned long old_flags;
 107         unsigned long new_flags;
 108
 109         switch (memtype) {
 110         case _PAGE_CACHE_MODE_WC:
 111                 memtype_flags = _PGMT_WC;
 112                 break;
 113         case _PAGE_CACHE_MODE_UC_MINUS:
 114                 memtype_flags = _PGMT_UC_MINUS;
 115                 break;
 116         case _PAGE_CACHE_MODE_WB:
 117                 memtype_flags = _PGMT_WB;
 118                 break;
 119         default:
 120                 memtype_flags = _PGMT_DEFAULT;
 121                 break;
 122         }
 123
 124         do {
 125                 old_flags = pg->flags;
 126                 new_flags = (old_flags & _PGMT_CLEAR_MASK) | memtype_flags;
 127         } while (cmpxchg(&pg->flags, old_flags, new_flags) != old_flags);
 128 }
 129 #else
 130 static inline enum page_cache_mode get_page_memtype(struct page *pg)
 131 {
 132         return -1;
 133 }
 134 static inline void set_page_memtype(struct page *pg,
 135                                     enum page_cache_mode memtype)
 136 {
 137 }
 138 #endif
 139
 140 enum {
 141         PAT_UC = 0,             /* uncached */
 142         PAT_WC = 1,             /* Write combining */
 143         PAT_WT = 4,             /* Write Through */
 144         PAT_WP = 5,             /* Write Protected */
 145         PAT_WB = 6,             /* Write Back (default) */
 146         PAT_UC_MINUS = 7,       /* UC, but can be overriden by MTRR */
 147 };
 148
 149 #define CM(c) (_PAGE_CACHE_MODE_ ## c)
 150
 151 static enum page_cache_mode pat_get_cache_mode(unsigned pat_val, char *msg)
 152 {
 153         enum page_cache_mode cache;
 154         char *cache_mode;
 155
 156         switch (pat_val) {
 157         case PAT_UC:       cache = CM(UC);       cache_mode = "UC  "; break;
 158         case PAT_WC:       cache = CM(WC);       cache_mode = "WC  "; break;
 159         case PAT_WT:       cache = CM(WT);       cache_mode = "WT  "; break;
 160         case PAT_WP:       cache = CM(WP);       cache_mode = "WP  "; break;
 161         case PAT_WB:       cache = CM(WB);       cache_mode = "WB  "; break;
 162         case PAT_UC_MINUS: cache = CM(UC_MINUS); cache_mode = "UC- "; break;
 163         default:           cache = CM(WB);       cache_mode = "WB  "; break;
 164         }
 165
 166         memcpy(msg, cache_mode, 4);
 167
 168         return cache;
 169 }
 170
 171 #undef CM
 172
 173 /*
 174  * Update the cache mode to pgprot translation tables according to PAT
 175  * configuration.
 176  * Using lower indices is preferred, so we start with highest index.
 177  */
 178 void pat_init_cache_modes(u64 pat)
 179 {
 180         enum page_cache_mode cache;
 181         char pat_msg[33];
 182         int i;
 183
 184         pat_msg[32] = 0;
 185         for (i = 7; i >= 0; i--) {
 186                 cache = pat_get_cache_mode((pat >> (i * 8)) & 7,
 187                                            pat_msg + 4 * i);
 188                 update_cache_mode_entry(i, cache);
 189         }
 190         pr_info("x86/PAT: Configuration [0-7]: %s\n", pat_msg);
 191 }
 192
 193 #define PAT(x, y)       ((u64)PAT_ ## y << ((x)*8))
 194
 195 static void pat_bsp_init(u64 pat)
 196 {
 197         u64 tmp_pat;
 198
 199         if (!cpu_has_pat) {
 200                 pat_disable("PAT not supported by CPU.");
 201                 return;
 202         }
 203
 204         if (!pat_enabled())
 205                 goto done;
 206
 207         rdmsrl(MSR_IA32_CR_PAT, tmp_pat);
 208         if (!tmp_pat) {
 209                 pat_disable("PAT MSR is 0, disabled.");
 210                 return;
 211         }
 212
 213         wrmsrl(MSR_IA32_CR_PAT, pat);
 214
 215 done:
 216         pat_init_cache_modes(pat);
 217 }
 218
 219 static void pat_ap_init(u64 pat)
 220 {
 221         if (!pat_enabled())
 222                 return;
 223
 224         if (!cpu_has_pat) {
 225                 /*
 226                  * If this happens we are on a secondary CPU, but switched to
 227                  * PAT on the boot CPU. We have no way to undo PAT.
 228                  */
 229                 panic("x86/PAT: PAT enabled, but not supported by secondary CPU\n");
 230         }
 231
 232         wrmsrl(MSR_IA32_CR_PAT, pat);
 233 }
 234
 235 void pat_init(void)
 236 {
 237         u64 pat;
 238         struct cpuinfo_x86 *c = &boot_cpu_data;
 239
 240         if (!pat_enabled()) {
 241                 /*
 242                  * No PAT. Emulate the PAT table that corresponds to the two
 243                  * cache bits, PWT (Write Through) and PCD (Cache Disable). This
 244                  * setup is the same as the BIOS default setup when the system
 245                  * has PAT but the "nopat" boot option has been specified. This
 246                  * emulated PAT table is used when MSR_IA32_CR_PAT returns 0.
 247                  *
 248                  * PTE encoding:
 249                  *
 250                  *       PCD
 251                  *       |PWT  PAT
 252                  *       ||    slot
 253                  *       00    0    WB : _PAGE_CACHE_MODE_WB
 254                  *       01    1    WT : _PAGE_CACHE_MODE_WT
 255                  *       10    2    UC-: _PAGE_CACHE_MODE_UC_MINUS
 256                  *       11    3    UC : _PAGE_CACHE_MODE_UC
 257                  *
 258                  * NOTE: When WC or WP is used, it is redirected to UC- per
 259                  * the default setup in __cachemode2pte_tbl[].
 260                  */
 261                 pat = PAT(0, WB) | PAT(1, WT) | PAT(2, UC_MINUS) | PAT(3, UC) |
 262                       PAT(4, WB) | PAT(5, WT) | PAT(6, UC_MINUS) | PAT(7, UC);
 263
 264         } else if ((c->x86_vendor == X86_VENDOR_INTEL) &&
 265                    (((c->x86 == 0x6) && (c->x86_model <= 0xd)) ||
 266                     ((c->x86 == 0xf) && (c->x86_model <= 0x6)))) {
 267                 /*
 268                  * PAT support with the lower four entries. Intel Pentium 2,
 269                  * 3, M, and 4 are affected by PAT errata, which makes the
 270                  * upper four entries unusable. To be on the safe side, we don't
 271                  * use those.
 272                  *
 273                  *  PTE encoding:
 274                  *      PAT
 275                  *      |PCD
 276                  *      ||PWT  PAT
 277                  *      |||    slot
 278                  *      000    0    WB : _PAGE_CACHE_MODE_WB
 279                  *      001    1    WC : _PAGE_CACHE_MODE_WC
 280                  *      010    2    UC-: _PAGE_CACHE_MODE_UC_MINUS
 281                  *      011    3    UC : _PAGE_CACHE_MODE_UC
 282                  * PAT bit unused
 283                  *
 284                  * NOTE: When WT or WP is used, it is redirected to UC- per
 285                  * the default setup in __cachemode2pte_tbl[].
 286                  */
 287                 pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
 288                       PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, UC);
 289         } else {
 290                 /*
 291                  * Full PAT support.  We put WT in slot 7 to improve
 292                  * robustness in the presence of errata that might cause
 293                  * the high PAT bit to be ignored.  This way, a buggy slot 7
 294                  * access will hit slot 3, and slot 3 is UC, so at worst
 295                  * we lose performance without causing a correctness issue.
 296                  * Pentium 4 erratum N46 is an example for such an erratum,
 297                  * although we try not to use PAT at all on affected CPUs.
 298                  *
 299                  *  PTE encoding:
 300                  *      PAT
 301                  *      |PCD
 302                  *      ||PWT  PAT
 303                  *      |||    slot
 304                  *      000    0    WB : _PAGE_CACHE_MODE_WB
 305                  *      001    1    WC : _PAGE_CACHE_MODE_WC
 306                  *      010    2    UC-: _PAGE_CACHE_MODE_UC_MINUS
 307                  *      011    3    UC : _PAGE_CACHE_MODE_UC
 308                  *      100    4    WB : Reserved
 309                  *      101    5    WC : Reserved
 310                  *      110    6    UC-: Reserved
 311                  *      111    7    WT : _PAGE_CACHE_MODE_WT
 312                  *
 313                  * The reserved slots are unused, but mapped to their
 314                  * corresponding types in the presence of PAT errata.
 315                  */
 316                 pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
 317                       PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, WT);
 318         }
 319
 320         if (!boot_cpu_done) {
 321                 pat_bsp_init(pat);
 322                 boot_cpu_done = true;
 323         } else {
 324                 pat_ap_init(pat);
 325         }
 326 }
 327
 328 #undef PAT
 329
 330 static DEFINE_SPINLOCK(memtype_lock);   /* protects memtype accesses */
 331
 332 /*
 333  * Does intersection of PAT memory type and MTRR memory type and returns
 334  * the resulting memory type as PAT understands it.
 335  * (Type in pat and mtrr will not have same value)
 336  * The intersection is based on "Effective Memory Type" tables in IA-32
 337  * SDM vol 3a
 338  */
 339 static unsigned long pat_x_mtrr_type(u64 start, u64 end,
 340                                      enum page_cache_mode req_type)
 341 {
 342         /*
 343          * Look for MTRR hint to get the effective type in case where PAT
 344          * request is for WB.
 345          */
 346         if (req_type == _PAGE_CACHE_MODE_WB) {
 347                 u8 mtrr_type, uniform;
 348
 349                 mtrr_type = mtrr_type_lookup(start, end, &uniform);
 350                 if (mtrr_type != MTRR_TYPE_WRBACK)
 351                         return _PAGE_CACHE_MODE_UC_MINUS;
 352
 353                 return _PAGE_CACHE_MODE_WB;
 354         }
 355
 356         return req_type;
 357 }
 358
 359 struct pagerange_state {
 360         unsigned long           cur_pfn;
 361         int                     ram;
 362         int                     not_ram;
 363 };
 364
 365 static int
 366 pagerange_is_ram_callback(unsigned long initial_pfn, unsigned long total_nr_pages, void *arg)
 367 {
 368         struct pagerange_state *state = arg;
 369
 370         state->not_ram  |= initial_pfn > state->cur_pfn;
 371         state->ram      |= total_nr_pages > 0;
 372         state->cur_pfn   = initial_pfn + total_nr_pages;
 373
 374         return state->ram && state->not_ram;
 375 }
 376
 377 static int pat_pagerange_is_ram(resource_size_t start, resource_size_t end)
 378 {
 379         int ret = 0;
 380         unsigned long start_pfn = start >> PAGE_SHIFT;
 381         unsigned long end_pfn = (end + PAGE_SIZE - 1) >> PAGE_SHIFT;
 382         struct pagerange_state state = {start_pfn, 0, 0};
 383
 384         /*
 385          * For legacy reasons, physical address range in the legacy ISA
 386          * region is tracked as non-RAM. This will allow users of
 387          * /dev/mem to map portions of legacy ISA region, even when
 388          * some of those portions are listed(or not even listed) with
 389          * different e820 types(RAM/reserved/..)
 390          */
 391         if (start_pfn < ISA_END_ADDRESS >> PAGE_SHIFT)
 392                 start_pfn = ISA_END_ADDRESS >> PAGE_SHIFT;
 393
 394         if (start_pfn < end_pfn) {
 395                 ret = walk_system_ram_range(start_pfn, end_pfn - start_pfn,
 396                                 &state, pagerange_is_ram_callback);
 397         }
 398
 399         return (ret > 0) ? -1 : (state.ram ? 1 : 0);
 400 }
 401
 402 /*
 403  * For RAM pages, we use page flags to mark the pages with appropriate type.
 404  * Here we do two pass:
 405  * - Find the memtype of all the pages in the range, look for any conflicts
 406  * - In case of no conflicts, set the new memtype for pages in the range
 407  */
 408 static int reserve_ram_pages_type(u64 start, u64 end,
 409                                   enum page_cache_mode req_type,
 410                                   enum page_cache_mode *new_type)
 411 {
 412         struct page *page;
 413         u64 pfn;
 414
 415         if (req_type == _PAGE_CACHE_MODE_UC) {
 416                 /* We do not support strong UC */
 417                 WARN_ON_ONCE(1);
 418                 req_type = _PAGE_CACHE_MODE_UC_MINUS;
 419         }
 420
 421         for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
 422                 enum page_cache_mode type;
 423
 424                 page = pfn_to_page(pfn);
 425                 type = get_page_memtype(page);
 426                 if (type != -1) {
 427                         pr_info("x86/PAT: reserve_ram_pages_type failed [mem %#010Lx-%#010Lx], track 0x%x, req 0x%x\n",
 428                                 start, end - 1, type, req_type);
 429                         if (new_type)
 430                                 *new_type = type;
 431
 432                         return -EBUSY;
 433                 }
 434         }
 435
 436         if (new_type)
 437                 *new_type = req_type;
 438
 439         for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
 440                 page = pfn_to_page(pfn);
 441                 set_page_memtype(page, req_type);
 442         }
 443         return 0;
 444 }
 445
 446 static int free_ram_pages_type(u64 start, u64 end)
 447 {
 448         struct page *page;
 449         u64 pfn;
 450
 451         for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
 452                 page = pfn_to_page(pfn);
 453                 set_page_memtype(page, -1);
 454         }
 455         return 0;
 456 }
 457
 458 /*
 459  * req_type typically has one of the:
 460  * - _PAGE_CACHE_MODE_WB
 461  * - _PAGE_CACHE_MODE_WC
 462  * - _PAGE_CACHE_MODE_UC_MINUS
 463  * - _PAGE_CACHE_MODE_UC
 464  *
 465  * If new_type is NULL, function will return an error if it cannot reserve the
 466  * region with req_type. If new_type is non-NULL, function will return
 467  * available type in new_type in case of no error. In case of any error
 468  * it will return a negative return value.
 469  */
 470 int reserve_memtype(u64 start, u64 end, enum page_cache_mode req_type,
 471                     enum page_cache_mode *new_type)
 472 {
 473         struct memtype *new;
 474         enum page_cache_mode actual_type;
 475         int is_range_ram;
 476         int err = 0;
 477
 478         BUG_ON(start >= end); /* end is exclusive */
 479
 480         if (!pat_enabled()) {
 481                 /* This is identical to page table setting without PAT */
 482                 if (new_type)
 483                         *new_type = req_type;
 484                 return 0;
 485         }
 486
 487         /* Low ISA region is always mapped WB in page table. No need to track */
 488         if (x86_platform.is_untracked_pat_range(start, end)) {
 489                 if (new_type)
 490                         *new_type = _PAGE_CACHE_MODE_WB;
 491                 return 0;
 492         }
 493
 494         /*
 495          * Call mtrr_lookup to get the type hint. This is an
 496          * optimization for /dev/mem mmap'ers into WB memory (BIOS
 497          * tools and ACPI tools). Use WB request for WB memory and use
 498          * UC_MINUS otherwise.
 499          */
 500         actual_type = pat_x_mtrr_type(start, end, req_type);
 501
 502         if (new_type)
 503                 *new_type = actual_type;
 504
 505         is_range_ram = pat_pagerange_is_ram(start, end);
 506         if (is_range_ram == 1) {
 507
 508                 err = reserve_ram_pages_type(start, end, req_type, new_type);
 509
 510                 return err;
 511         } else if (is_range_ram < 0) {
 512                 return -EINVAL;
 513         }
 514
 515         new  = kzalloc(sizeof(struct memtype), GFP_KERNEL);
 516         if (!new)
 517                 return -ENOMEM;
 518
 519         new->start      = start;
 520         new->end        = end;
 521         new->type       = actual_type;
 522
 523         spin_lock(&memtype_lock);
 524
 525         err = rbt_memtype_check_insert(new, new_type);
 526         if (err) {
 527                 pr_info("x86/PAT: reserve_memtype failed [mem %#010Lx-%#010Lx], track %s, req %s\n",
 528                         start, end - 1,
 529                         cattr_name(new->type), cattr_name(req_type));
 530                 kfree(new);
 531                 spin_unlock(&memtype_lock);
 532
 533                 return err;
 534         }
 535
 536         spin_unlock(&memtype_lock);
 537
 538         dprintk("reserve_memtype added [mem %#010Lx-%#010Lx], track %s, req %s, ret %s\n",
 539                 start, end - 1, cattr_name(new->type), cattr_name(req_type),
 540                 new_type ? cattr_name(*new_type) : "-");
 541
 542         return err;
 543 }
 544
 545 int free_memtype(u64 start, u64 end)
 546 {
 547         int err = -EINVAL;
 548         int is_range_ram;
 549         struct memtype *entry;
 550
 551         if (!pat_enabled())
 552                 return 0;
 553
 554         /* Low ISA region is always mapped WB. No need to track */
 555         if (x86_platform.is_untracked_pat_range(start, end))
 556                 return 0;
 557
 558         is_range_ram = pat_pagerange_is_ram(start, end);
 559         if (is_range_ram == 1) {
 560
 561                 err = free_ram_pages_type(start, end);
 562
 563                 return err;
 564         } else if (is_range_ram < 0) {
 565                 return -EINVAL;
 566         }
 567
 568         spin_lock(&memtype_lock);
 569         entry = rbt_memtype_erase(start, end);
 570         spin_unlock(&memtype_lock);
 571
 572         if (!entry) {
 573                 pr_info("x86/PAT: %s:%d freeing invalid memtype [mem %#010Lx-%#010Lx]\n",
 574                         current->comm, current->pid, start, end - 1);
 575                 return -EINVAL;
 576         }
 577
 578         kfree(entry);
 579
 580         dprintk("free_memtype request [mem %#010Lx-%#010Lx]\n", start, end - 1);
 581
 582         return 0;
 583 }
 584
 585
 586 /**
 587  * lookup_memtype - Looksup the memory type for a physical address
 588  * @paddr: physical address of which memory type needs to be looked up
 589  *
 590  * Only to be called when PAT is enabled
 591  *
 592  * Returns _PAGE_CACHE_MODE_WB, _PAGE_CACHE_MODE_WC, _PAGE_CACHE_MODE_UC_MINUS
 593  * or _PAGE_CACHE_MODE_UC
 594  */
 595 static enum page_cache_mode lookup_memtype(u64 paddr)
 596 {
 597         enum page_cache_mode rettype = _PAGE_CACHE_MODE_WB;
 598         struct memtype *entry;
 599
 600         if (x86_platform.is_untracked_pat_range(paddr, paddr + PAGE_SIZE))
 601                 return rettype;
 602
 603         if (pat_pagerange_is_ram(paddr, paddr + PAGE_SIZE)) {
 604                 struct page *page;
 605                 page = pfn_to_page(paddr >> PAGE_SHIFT);
 606                 rettype = get_page_memtype(page);
 607                 /*
 608                  * -1 from get_page_memtype() implies RAM page is in its
 609                  * default state and not reserved, and hence of type WB
 610                  */
 611                 if (rettype == -1)
 612                         rettype = _PAGE_CACHE_MODE_WB;
 613
 614                 return rettype;
 615         }
 616
 617         spin_lock(&memtype_lock);
 618
 619         entry = rbt_memtype_lookup(paddr);
 620         if (entry != NULL)
 621                 rettype = entry->type;
 622         else
 623                 rettype = _PAGE_CACHE_MODE_UC_MINUS;
 624
 625         spin_unlock(&memtype_lock);
 626         return rettype;
 627 }
 628
 629 /**
 630  * io_reserve_memtype - Request a memory type mapping for a region of memory
 631  * @start: start (physical address) of the region
 632  * @end: end (physical address) of the region
 633  * @type: A pointer to memtype, with requested type. On success, requested
 634  * or any other compatible type that was available for the region is returned
 635  *
 636  * On success, returns 0
 637  * On failure, returns non-zero
 638  */
 639 int io_reserve_memtype(resource_size_t start, resource_size_t end,
 640                         enum page_cache_mode *type)
 641 {
 642         resource_size_t size = end - start;
 643         enum page_cache_mode req_type = *type;
 644         enum page_cache_mode new_type;
 645         int ret;
 646
 647         WARN_ON_ONCE(iomem_map_sanity_check(start, size));
 648
 649         ret = reserve_memtype(start, end, req_type, &new_type);
 650         if (ret)
 651                 goto out_err;
 652
 653         if (!is_new_memtype_allowed(start, size, req_type, new_type))
 654                 goto out_free;
 655
 656         if (kernel_map_sync_memtype(start, size, new_type) < 0)
 657                 goto out_free;
 658
 659         *type = new_type;
 660         return 0;
 661
 662 out_free:
 663         free_memtype(start, end);
 664         ret = -EBUSY;
 665 out_err:
 666         return ret;
 667 }
 668
 669 /**
 670  * io_free_memtype - Release a memory type mapping for a region of memory
 671  * @start: start (physical address) of the region
 672  * @end: end (physical address) of the region
 673  */
 674 void io_free_memtype(resource_size_t start, resource_size_t end)
 675 {
 676         free_memtype(start, end);
 677 }
 678
 679 pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
 680                                 unsigned long size, pgprot_t vma_prot)
 681 {
 682         return vma_prot;
 683 }
 684
 685 #ifdef CONFIG_STRICT_DEVMEM
 686 /* This check is done in drivers/char/mem.c in case of STRICT_DEVMEM */
 687 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
 688 {
 689         return 1;
 690 }
 691 #else
 692 /* This check is needed to avoid cache aliasing when PAT is enabled */
 693 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
 694 {
 695         u64 from = ((u64)pfn) << PAGE_SHIFT;
 696         u64 to = from + size;
 697         u64 cursor = from;
 698
 699         if (!pat_enabled())
 700                 return 1;
 701
 702         while (cursor < to) {
 703                 if (!devmem_is_allowed(pfn)) {
 704                         pr_info("x86/PAT: Program %s tried to access /dev/mem between [mem %#010Lx-%#010Lx], PAT prevents it\n",
 705                                 current->comm, from, to - 1);
 706                         return 0;
 707                 }
 708                 cursor += PAGE_SIZE;
 709                 pfn++;
 710         }
 711         return 1;
 712 }
 713 #endif /* CONFIG_STRICT_DEVMEM */
 714
 715 int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
 716                                 unsigned long size, pgprot_t *vma_prot)
 717 {
 718         enum page_cache_mode pcm = _PAGE_CACHE_MODE_WB;
 719
 720         if (!range_is_allowed(pfn, size))
 721                 return 0;
 722
 723         if (file->f_flags & O_DSYNC)
 724                 pcm = _PAGE_CACHE_MODE_UC_MINUS;
 725
 726 #ifdef CONFIG_X86_32
 727         /*
 728          * On the PPro and successors, the MTRRs are used to set
 729          * memory types for physical addresses outside main memory,
 730          * so blindly setting UC or PWT on those pages is wrong.
 731          * For Pentiums and earlier, the surround logic should disable
 732          * caching for the high addresses through the KEN pin, but
 733          * we maintain the tradition of paranoia in this code.
 734          */
 735         if (!pat_enabled() &&
 736             !(boot_cpu_has(X86_FEATURE_MTRR) ||
 737               boot_cpu_has(X86_FEATURE_K6_MTRR) ||
 738               boot_cpu_has(X86_FEATURE_CYRIX_ARR) ||
 739               boot_cpu_has(X86_FEATURE_CENTAUR_MCR)) &&
 740             (pfn << PAGE_SHIFT) >= __pa(high_memory)) {
 741                 pcm = _PAGE_CACHE_MODE_UC;
 742         }
 743 #endif
 744
 745         *vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |
 746                              cachemode2protval(pcm));
 747         return 1;
 748 }
 749
 750 /*
 751  * Change the memory type for the physial address range in kernel identity
 752  * mapping space if that range is a part of identity map.
 753  */
 754 int kernel_map_sync_memtype(u64 base, unsigned long size,
 755                             enum page_cache_mode pcm)
 756 {
 757         unsigned long id_sz;
 758
 759         if (base > __pa(high_memory-1))
 760                 return 0;
 761
 762         /*
 763          * some areas in the middle of the kernel identity range
 764          * are not mapped, like the PCI space.
 765          */
 766         if (!page_is_ram(base >> PAGE_SHIFT))
 767                 return 0;
 768
 769         id_sz = (__pa(high_memory-1) <= base + size) ?
 770                                 __pa(high_memory) - base :
 771                                 size;
 772
 773         if (ioremap_change_attr((unsigned long)__va(base), id_sz, pcm) < 0) {
 774                 pr_info("x86/PAT: %s:%d ioremap_change_attr failed %s for [mem %#010Lx-%#010Lx]\n",
 775                         current->comm, current->pid,
 776                         cattr_name(pcm),
 777                         base, (unsigned long long)(base + size-1));
 778                 return -EINVAL;
 779         }
 780         return 0;
 781 }
 782
 783 /*
 784  * Internal interface to reserve a range of physical memory with prot.
 785  * Reserved non RAM regions only and after successful reserve_memtype,
 786  * this func also keeps identity mapping (if any) in sync with this new prot.
 787  */
 788 static int reserve_pfn_range(u64 paddr, unsigned long size, pgprot_t *vma_prot,
 789                                 int strict_prot)
 790 {
 791         int is_ram = 0;
 792         int ret;
 793         enum page_cache_mode want_pcm = pgprot2cachemode(*vma_prot);
 794         enum page_cache_mode pcm = want_pcm;
 795
 796         is_ram = pat_pagerange_is_ram(paddr, paddr + size);
 797
 798         /*
 799          * reserve_pfn_range() for RAM pages. We do not refcount to keep
 800          * track of number of mappings of RAM pages. We can assert that
 801          * the type requested matches the type of first page in the range.
 802          */
 803         if (is_ram) {
 804                 if (!pat_enabled())
 805                         return 0;
 806
 807                 pcm = lookup_memtype(paddr);
 808                 if (want_pcm != pcm) {
 809                         pr_warn("x86/PAT: %s:%d map pfn RAM range req %s for [mem %#010Lx-%#010Lx], got %s\n",
 810                                 current->comm, current->pid,
 811                                 cattr_name(want_pcm),
 812                                 (unsigned long long)paddr,
 813                                 (unsigned long long)(paddr + size - 1),
 814                                 cattr_name(pcm));
 815                         *vma_prot = __pgprot((pgprot_val(*vma_prot) &
 816                                              (~_PAGE_CACHE_MASK)) |
 817                                              cachemode2protval(pcm));
 818                 }
 819                 return 0;
 820         }
 821
 822         ret = reserve_memtype(paddr, paddr + size, want_pcm, &pcm);
 823         if (ret)
 824                 return ret;
 825
 826         if (pcm != want_pcm) {
 827                 if (strict_prot ||
 828                     !is_new_memtype_allowed(paddr, size, want_pcm, pcm)) {
 829                         free_memtype(paddr, paddr + size);
 830                         pr_err("x86/PAT: %s:%d map pfn expected mapping type %s for [mem %#010Lx-%#010Lx], got %s\n",
 831                                current->comm, current->pid,
 832                                cattr_name(want_pcm),
 833                                (unsigned long long)paddr,
 834                                (unsigned long long)(paddr + size - 1),
 835                                cattr_name(pcm));
 836                         return -EINVAL;
 837                 }
 838                 /*
 839                  * We allow returning different type than the one requested in
 840                  * non strict case.
 841                  */
 842                 *vma_prot = __pgprot((pgprot_val(*vma_prot) &
 843                                       (~_PAGE_CACHE_MASK)) |
 844                                      cachemode2protval(pcm));
 845         }
 846
 847         if (kernel_map_sync_memtype(paddr, size, pcm) < 0) {
 848                 free_memtype(paddr, paddr + size);
 849                 return -EINVAL;
 850         }
 851         return 0;
 852 }
 853
 854 /*
 855  * Internal interface to free a range of physical memory.
 856  * Frees non RAM regions only.
 857  */
 858 static void free_pfn_range(u64 paddr, unsigned long size)
 859 {
 860         int is_ram;
 861
 862         is_ram = pat_pagerange_is_ram(paddr, paddr + size);
 863         if (is_ram == 0)
 864                 free_memtype(paddr, paddr + size);
 865 }
 866
 867 /*
 868  * track_pfn_copy is called when vma that is covering the pfnmap gets
 869  * copied through copy_page_range().
 870  *
 871  * If the vma has a linear pfn mapping for the entire range, we get the prot
 872  * from pte and reserve the entire vma range with single reserve_pfn_range call.
 873  */
 874 int track_pfn_copy(struct vm_area_struct *vma)
 875 {
 876         resource_size_t paddr;
 877         unsigned long prot;
 878         unsigned long vma_size = vma->vm_end - vma->vm_start;
 879         pgprot_t pgprot;
 880
 881         if (vma->vm_flags & VM_PAT) {
 882                 /*
 883                  * reserve the whole chunk covered by vma. We need the
 884                  * starting address and protection from pte.
 885                  */
 886                 if (follow_phys(vma, vma->vm_start, 0, &prot, &paddr)) {
 887                         WARN_ON_ONCE(1);
 888                         return -EINVAL;
 889                 }
 890                 pgprot = __pgprot(prot);
 891                 return reserve_pfn_range(paddr, vma_size, &pgprot, 1);
 892         }
 893
 894         return 0;
 895 }
 896
 897 /*
 898  * prot is passed in as a parameter for the new mapping. If the vma has a
 899  * linear pfn mapping for the entire range reserve the entire vma range with
 900  * single reserve_pfn_range call.
 901  */
 902 int track_pfn_remap(struct vm_area_struct *vma, pgprot_t *prot,
 903                     unsigned long pfn, unsigned long addr, unsigned long size)
 904 {
 905         resource_size_t paddr = (resource_size_t)pfn << PAGE_SHIFT;
 906         enum page_cache_mode pcm;
 907
 908         /* reserve the whole chunk starting from paddr */
 909         if (addr == vma->vm_start && size == (vma->vm_end - vma->vm_start)) {
 910                 int ret;
 911
 912                 ret = reserve_pfn_range(paddr, size, prot, 0);
 913                 if (!ret)
 914                         vma->vm_flags |= VM_PAT;
 915                 return ret;
 916         }
 917
 918         if (!pat_enabled())
 919                 return 0;
 920
 921         /*
 922          * For anything smaller than the vma size we set prot based on the
 923          * lookup.
 924          */
 925         pcm = lookup_memtype(paddr);
 926
 927         /* Check memtype for the remaining pages */
 928         while (size > PAGE_SIZE) {
 929                 size -= PAGE_SIZE;
 930                 paddr += PAGE_SIZE;
 931                 if (pcm != lookup_memtype(paddr))
 932                         return -EINVAL;
 933         }
 934
 935         *prot = __pgprot((pgprot_val(vma->vm_page_prot) & (~_PAGE_CACHE_MASK)) |
 936                          cachemode2protval(pcm));
 937
 938         return 0;
 939 }
 940
 941 int track_pfn_insert(struct vm_area_struct *vma, pgprot_t *prot,
 942                      unsigned long pfn)
 943 {
 944         enum page_cache_mode pcm;
 945
 946         if (!pat_enabled())
 947                 return 0;
 948
 949         /* Set prot based on lookup */
 950         pcm = lookup_memtype((resource_size_t)pfn << PAGE_SHIFT);
 951         *prot = __pgprot((pgprot_val(vma->vm_page_prot) & (~_PAGE_CACHE_MASK)) |
 952                          cachemode2protval(pcm));
 953
 954         return 0;
 955 }
 956
 957 /*
 958  * untrack_pfn is called while unmapping a pfnmap for a region.
 959  * untrack can be called for a specific region indicated by pfn and size or
 960  * can be for the entire vma (in which case pfn, size are zero).
 961  */
 962 void untrack_pfn(struct vm_area_struct *vma, unsigned long pfn,
 963                  unsigned long size)
 964 {
 965         resource_size_t paddr;
 966         unsigned long prot;
 967
 968         if (!(vma->vm_flags & VM_PAT))
 969                 return;
 970
 971         /* free the chunk starting from pfn or the whole chunk */
 972         paddr = (resource_size_t)pfn << PAGE_SHIFT;
 973         if (!paddr && !size) {
 974                 if (follow_phys(vma, vma->vm_start, 0, &prot, &paddr)) {
 975                         WARN_ON_ONCE(1);
 976                         return;
 977                 }
 978
 979                 size = vma->vm_end - vma->vm_start;
 980         }
 981         free_pfn_range(paddr, size);
 982         vma->vm_flags &= ~VM_PAT;
 983 }
 984
 985 pgprot_t pgprot_writecombine(pgprot_t prot)
 986 {
 987         return __pgprot(pgprot_val(prot) |
 988                                 cachemode2protval(_PAGE_CACHE_MODE_WC));
 989 }
 990 EXPORT_SYMBOL_GPL(pgprot_writecombine);
 991
 992 #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_X86_PAT)
 993
 994 static struct memtype *memtype_get_idx(loff_t pos)
 995 {
 996         struct memtype *print_entry;
 997         int ret;
 998
 999         print_entry  = kzalloc(sizeof(struct memtype), GFP_KERNEL);
1000         if (!print_entry)
1001                 return NULL;
1002
1003         spin_lock(&memtype_lock);
1004         ret = rbt_memtype_copy_nth_element(print_entry, pos);
1005         spin_unlock(&memtype_lock);
1006
1007         if (!ret) {
1008                 return print_entry;
1009         } else {
1010                 kfree(print_entry);
1011                 return NULL;
1012         }
1013 }
1014
1015 static void *memtype_seq_start(struct seq_file *seq, loff_t *pos)
1016 {
1017         if (*pos == 0) {
1018                 ++*pos;
1019                 seq_puts(seq, "PAT memtype list:\n");
1020         }
1021
1022         return memtype_get_idx(*pos);
1023 }
1024
1025 static void *memtype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1026 {
1027         ++*pos;
1028         return memtype_get_idx(*pos);
1029 }
1030
1031 static void memtype_seq_stop(struct seq_file *seq, void *v)
1032 {
1033 }
1034
1035 static int memtype_seq_show(struct seq_file *seq, void *v)
1036 {
1037         struct memtype *print_entry = (struct memtype *)v;
1038
1039         seq_printf(seq, "%s @ 0x%Lx-0x%Lx\n", cattr_name(print_entry->type),
1040                         print_entry->start, print_entry->end);
1041         kfree(print_entry);
1042
1043         return 0;
1044 }
1045
1046 static const struct seq_operations memtype_seq_ops = {
1047         .start = memtype_seq_start,
1048         .next  = memtype_seq_next,
1049         .stop  = memtype_seq_stop,
1050         .show  = memtype_seq_show,
1051 };
1052
1053 static int memtype_seq_open(struct inode *inode, struct file *file)
1054 {
1055         return seq_open(file, &memtype_seq_ops);
1056 }
1057
1058 static const struct file_operations memtype_fops = {
1059         .open    = memtype_seq_open,
1060         .read    = seq_read,
1061         .llseek  = seq_lseek,
1062         .release = seq_release,
1063 };
1064
1065 static int __init pat_memtype_list_init(void)
1066 {
1067         if (pat_enabled()) {
1068                 debugfs_create_file("pat_memtype_list", S_IRUSR,
1069                                     arch_debugfs_dir, NULL, &memtype_fops);
1070         }
1071         return 0;
1072 }
1073
1074 late_initcall(pat_memtype_list_init);
1075
1076 #endif /* CONFIG_DEBUG_FS && CONFIG_X86_PAT */