arch/x86/include/asm/pgtable.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _ASM_X86_PGTABLE_H
   3 #define _ASM_X86_PGTABLE_H
   4
   5 #include <linux/mem_encrypt.h>
   6 #include <asm/page.h>
   7 #include <asm/pgtable_types.h>
   8
   9 /*
  10  * Macro to mark a page protection value as UC-
  11  */
  12 #define pgprot_noncached(prot)                                          \
  13         ((boot_cpu_data.x86 > 3)                                        \
  14          ? (__pgprot(pgprot_val(prot) |                                 \
  15                      cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS)))     \
  16          : (prot))
  17
  18 /*
  19  * Macros to add or remove encryption attribute
  20  */
  21 #define pgprot_encrypted(prot)  __pgprot(__sme_set(pgprot_val(prot)))
  22 #define pgprot_decrypted(prot)  __pgprot(__sme_clr(pgprot_val(prot)))
  23
  24 #ifndef __ASSEMBLY__
  25 #include <asm/x86_init.h>
  26
  27 extern pgd_t early_top_pgt[PTRS_PER_PGD];
  28 int __init __early_make_pgtable(unsigned long address, pmdval_t pmd);
  29
  30 void ptdump_walk_pgd_level(struct seq_file *m, pgd_t *pgd);
  31 void ptdump_walk_pgd_level_checkwx(void);
  32
  33 #ifdef CONFIG_DEBUG_WX
  34 #define debug_checkwx() ptdump_walk_pgd_level_checkwx()
  35 #else
  36 #define debug_checkwx() do { } while (0)
  37 #endif
  38
  39 /*
  40  * ZERO_PAGE is a global shared page that is always zero: used
  41  * for zero-mapped memory areas etc..
  42  */
  43 extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)]
  44         __visible;
  45 #define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
  46
  47 extern spinlock_t pgd_lock;
  48 extern struct list_head pgd_list;
  49
  50 extern struct mm_struct *pgd_page_get_mm(struct page *page);
  51
  52 extern pmdval_t early_pmd_flags;
  53
  54 #ifdef CONFIG_PARAVIRT
  55 #include <asm/paravirt.h>
  56 #else  /* !CONFIG_PARAVIRT */
  57 #define set_pte(ptep, pte)              native_set_pte(ptep, pte)
  58 #define set_pte_at(mm, addr, ptep, pte) native_set_pte_at(mm, addr, ptep, pte)
  59
  60 #define set_pte_atomic(ptep, pte)                                       \
  61         native_set_pte_atomic(ptep, pte)
  62
  63 #define set_pmd(pmdp, pmd)              native_set_pmd(pmdp, pmd)
  64
  65 #ifndef __PAGETABLE_P4D_FOLDED
  66 #define set_pgd(pgdp, pgd)              native_set_pgd(pgdp, pgd)
  67 #define pgd_clear(pgd)                  native_pgd_clear(pgd)
  68 #endif
  69
  70 #ifndef set_p4d
  71 # define set_p4d(p4dp, p4d)             native_set_p4d(p4dp, p4d)
  72 #endif
  73
  74 #ifndef __PAGETABLE_PUD_FOLDED
  75 #define p4d_clear(p4d)                  native_p4d_clear(p4d)
  76 #endif
  77
  78 #ifndef set_pud
  79 # define set_pud(pudp, pud)             native_set_pud(pudp, pud)
  80 #endif
  81
  82 #ifndef __PAGETABLE_PUD_FOLDED
  83 #define pud_clear(pud)                  native_pud_clear(pud)
  84 #endif
  85
  86 #define pte_clear(mm, addr, ptep)       native_pte_clear(mm, addr, ptep)
  87 #define pmd_clear(pmd)                  native_pmd_clear(pmd)
  88
  89 #define pgd_val(x)      native_pgd_val(x)
  90 #define __pgd(x)        native_make_pgd(x)
  91
  92 #ifndef __PAGETABLE_P4D_FOLDED
  93 #define p4d_val(x)      native_p4d_val(x)
  94 #define __p4d(x)        native_make_p4d(x)
  95 #endif
  96
  97 #ifndef __PAGETABLE_PUD_FOLDED
  98 #define pud_val(x)      native_pud_val(x)
  99 #define __pud(x)        native_make_pud(x)
 100 #endif
 101
 102 #ifndef __PAGETABLE_PMD_FOLDED
 103 #define pmd_val(x)      native_pmd_val(x)
 104 #define __pmd(x)        native_make_pmd(x)
 105 #endif
 106
 107 #define pte_val(x)      native_pte_val(x)
 108 #define __pte(x)        native_make_pte(x)
 109
 110 #define arch_end_context_switch(prev)   do {} while(0)
 111
 112 #endif  /* CONFIG_PARAVIRT */
 113
 114 /*
 115  * The following only work if pte_present() is true.
 116  * Undefined behaviour if not..
 117  */
 118 static inline int pte_dirty(pte_t pte)
 119 {
 120         return pte_flags(pte) & _PAGE_DIRTY;
 121 }
 122
 123
 124 static inline u32 read_pkru(void)
 125 {
 126         if (boot_cpu_has(X86_FEATURE_OSPKE))
 127                 return __read_pkru();
 128         return 0;
 129 }
 130
 131 static inline void write_pkru(u32 pkru)
 132 {
 133         if (boot_cpu_has(X86_FEATURE_OSPKE))
 134                 __write_pkru(pkru);
 135 }
 136
 137 static inline int pte_young(pte_t pte)
 138 {
 139         return pte_flags(pte) & _PAGE_ACCESSED;
 140 }
 141
 142 static inline int pmd_dirty(pmd_t pmd)
 143 {
 144         return pmd_flags(pmd) & _PAGE_DIRTY;
 145 }
 146
 147 static inline int pmd_young(pmd_t pmd)
 148 {
 149         return pmd_flags(pmd) & _PAGE_ACCESSED;
 150 }
 151
 152 static inline int pud_dirty(pud_t pud)
 153 {
 154         return pud_flags(pud) & _PAGE_DIRTY;
 155 }
 156
 157 static inline int pud_young(pud_t pud)
 158 {
 159         return pud_flags(pud) & _PAGE_ACCESSED;
 160 }
 161
 162 static inline int pte_write(pte_t pte)
 163 {
 164         return pte_flags(pte) & _PAGE_RW;
 165 }
 166
 167 static inline int pte_huge(pte_t pte)
 168 {
 169         return pte_flags(pte) & _PAGE_PSE;
 170 }
 171
 172 static inline int pte_global(pte_t pte)
 173 {
 174         return pte_flags(pte) & _PAGE_GLOBAL;
 175 }
 176
 177 static inline int pte_exec(pte_t pte)
 178 {
 179         return !(pte_flags(pte) & _PAGE_NX);
 180 }
 181
 182 static inline int pte_special(pte_t pte)
 183 {
 184         return pte_flags(pte) & _PAGE_SPECIAL;
 185 }
 186
 187 static inline unsigned long pte_pfn(pte_t pte)
 188 {
 189         return (pte_val(pte) & PTE_PFN_MASK) >> PAGE_SHIFT;
 190 }
 191
 192 static inline unsigned long pmd_pfn(pmd_t pmd)
 193 {
 194         return (pmd_val(pmd) & pmd_pfn_mask(pmd)) >> PAGE_SHIFT;
 195 }
 196
 197 static inline unsigned long pud_pfn(pud_t pud)
 198 {
 199         return (pud_val(pud) & pud_pfn_mask(pud)) >> PAGE_SHIFT;
 200 }
 201
 202 static inline unsigned long p4d_pfn(p4d_t p4d)
 203 {
 204         return (p4d_val(p4d) & p4d_pfn_mask(p4d)) >> PAGE_SHIFT;
 205 }
 206
 207 static inline unsigned long pgd_pfn(pgd_t pgd)
 208 {
 209         return (pgd_val(pgd) & PTE_PFN_MASK) >> PAGE_SHIFT;
 210 }
 211
 212 static inline int p4d_large(p4d_t p4d)
 213 {
 214         /* No 512 GiB pages yet */
 215         return 0;
 216 }
 217
 218 #define pte_page(pte)   pfn_to_page(pte_pfn(pte))
 219
 220 static inline int pmd_large(pmd_t pte)
 221 {
 222         return pmd_flags(pte) & _PAGE_PSE;
 223 }
 224
 225 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 226 static inline int pmd_trans_huge(pmd_t pmd)
 227 {
 228         return (pmd_val(pmd) & (_PAGE_PSE|_PAGE_DEVMAP)) == _PAGE_PSE;
 229 }
 230
 231 #ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
 232 static inline int pud_trans_huge(pud_t pud)
 233 {
 234         return (pud_val(pud) & (_PAGE_PSE|_PAGE_DEVMAP)) == _PAGE_PSE;
 235 }
 236 #endif
 237
 238 #define has_transparent_hugepage has_transparent_hugepage
 239 static inline int has_transparent_hugepage(void)
 240 {
 241         return boot_cpu_has(X86_FEATURE_PSE);
 242 }
 243
 244 #ifdef __HAVE_ARCH_PTE_DEVMAP
 245 static inline int pmd_devmap(pmd_t pmd)
 246 {
 247         return !!(pmd_val(pmd) & _PAGE_DEVMAP);
 248 }
 249
 250 #ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
 251 static inline int pud_devmap(pud_t pud)
 252 {
 253         return !!(pud_val(pud) & _PAGE_DEVMAP);
 254 }
 255 #else
 256 static inline int pud_devmap(pud_t pud)
 257 {
 258         return 0;
 259 }
 260 #endif
 261
 262 static inline int pgd_devmap(pgd_t pgd)
 263 {
 264         return 0;
 265 }
 266 #endif
 267 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
 268
 269 static inline pte_t pte_set_flags(pte_t pte, pteval_t set)
 270 {
 271         pteval_t v = native_pte_val(pte);
 272
 273         return native_make_pte(v | set);
 274 }
 275
 276 static inline pte_t pte_clear_flags(pte_t pte, pteval_t clear)
 277 {
 278         pteval_t v = native_pte_val(pte);
 279
 280         return native_make_pte(v & ~clear);
 281 }
 282
 283 static inline pte_t pte_mkclean(pte_t pte)
 284 {
 285         return pte_clear_flags(pte, _PAGE_DIRTY);
 286 }
 287
 288 static inline pte_t pte_mkold(pte_t pte)
 289 {
 290         return pte_clear_flags(pte, _PAGE_ACCESSED);
 291 }
 292
 293 static inline pte_t pte_wrprotect(pte_t pte)
 294 {
 295         return pte_clear_flags(pte, _PAGE_RW);
 296 }
 297
 298 static inline pte_t pte_mkexec(pte_t pte)
 299 {
 300         return pte_clear_flags(pte, _PAGE_NX);
 301 }
 302
 303 static inline pte_t pte_mkdirty(pte_t pte)
 304 {
 305         return pte_set_flags(pte, _PAGE_DIRTY | _PAGE_SOFT_DIRTY);
 306 }
 307
 308 static inline pte_t pte_mkyoung(pte_t pte)
 309 {
 310         return pte_set_flags(pte, _PAGE_ACCESSED);
 311 }
 312
 313 static inline pte_t pte_mkwrite(pte_t pte)
 314 {
 315         return pte_set_flags(pte, _PAGE_RW);
 316 }
 317
 318 static inline pte_t pte_mkhuge(pte_t pte)
 319 {
 320         return pte_set_flags(pte, _PAGE_PSE);
 321 }
 322
 323 static inline pte_t pte_clrhuge(pte_t pte)
 324 {
 325         return pte_clear_flags(pte, _PAGE_PSE);
 326 }
 327
 328 static inline pte_t pte_mkglobal(pte_t pte)
 329 {
 330         return pte_set_flags(pte, _PAGE_GLOBAL);
 331 }
 332
 333 static inline pte_t pte_clrglobal(pte_t pte)
 334 {
 335         return pte_clear_flags(pte, _PAGE_GLOBAL);
 336 }
 337
 338 static inline pte_t pte_mkspecial(pte_t pte)
 339 {
 340         return pte_set_flags(pte, _PAGE_SPECIAL);
 341 }
 342
 343 static inline pte_t pte_mkdevmap(pte_t pte)
 344 {
 345         return pte_set_flags(pte, _PAGE_SPECIAL|_PAGE_DEVMAP);
 346 }
 347
 348 static inline pmd_t pmd_set_flags(pmd_t pmd, pmdval_t set)
 349 {
 350         pmdval_t v = native_pmd_val(pmd);
 351
 352         return __pmd(v | set);
 353 }
 354
 355 static inline pmd_t pmd_clear_flags(pmd_t pmd, pmdval_t clear)
 356 {
 357         pmdval_t v = native_pmd_val(pmd);
 358
 359         return __pmd(v & ~clear);
 360 }
 361
 362 static inline pmd_t pmd_mkold(pmd_t pmd)
 363 {
 364         return pmd_clear_flags(pmd, _PAGE_ACCESSED);
 365 }
 366
 367 static inline pmd_t pmd_mkclean(pmd_t pmd)
 368 {
 369         return pmd_clear_flags(pmd, _PAGE_DIRTY);
 370 }
 371
 372 static inline pmd_t pmd_wrprotect(pmd_t pmd)
 373 {
 374         return pmd_clear_flags(pmd, _PAGE_RW);
 375 }
 376
 377 static inline pmd_t pmd_mkdirty(pmd_t pmd)
 378 {
 379         return pmd_set_flags(pmd, _PAGE_DIRTY | _PAGE_SOFT_DIRTY);
 380 }
 381
 382 static inline pmd_t pmd_mkdevmap(pmd_t pmd)
 383 {
 384         return pmd_set_flags(pmd, _PAGE_DEVMAP);
 385 }
 386
 387 static inline pmd_t pmd_mkhuge(pmd_t pmd)
 388 {
 389         return pmd_set_flags(pmd, _PAGE_PSE);
 390 }
 391
 392 static inline pmd_t pmd_mkyoung(pmd_t pmd)
 393 {
 394         return pmd_set_flags(pmd, _PAGE_ACCESSED);
 395 }
 396
 397 static inline pmd_t pmd_mkwrite(pmd_t pmd)
 398 {
 399         return pmd_set_flags(pmd, _PAGE_RW);
 400 }
 401
 402 static inline pmd_t pmd_mknotpresent(pmd_t pmd)
 403 {
 404         return pmd_clear_flags(pmd, _PAGE_PRESENT | _PAGE_PROTNONE);
 405 }
 406
 407 static inline pud_t pud_set_flags(pud_t pud, pudval_t set)
 408 {
 409         pudval_t v = native_pud_val(pud);
 410
 411         return __pud(v | set);
 412 }
 413
 414 static inline pud_t pud_clear_flags(pud_t pud, pudval_t clear)
 415 {
 416         pudval_t v = native_pud_val(pud);
 417
 418         return __pud(v & ~clear);
 419 }
 420
 421 static inline pud_t pud_mkold(pud_t pud)
 422 {
 423         return pud_clear_flags(pud, _PAGE_ACCESSED);
 424 }
 425
 426 static inline pud_t pud_mkclean(pud_t pud)
 427 {
 428         return pud_clear_flags(pud, _PAGE_DIRTY);
 429 }
 430
 431 static inline pud_t pud_wrprotect(pud_t pud)
 432 {
 433         return pud_clear_flags(pud, _PAGE_RW);
 434 }
 435
 436 static inline pud_t pud_mkdirty(pud_t pud)
 437 {
 438         return pud_set_flags(pud, _PAGE_DIRTY | _PAGE_SOFT_DIRTY);
 439 }
 440
 441 static inline pud_t pud_mkdevmap(pud_t pud)
 442 {
 443         return pud_set_flags(pud, _PAGE_DEVMAP);
 444 }
 445
 446 static inline pud_t pud_mkhuge(pud_t pud)
 447 {
 448         return pud_set_flags(pud, _PAGE_PSE);
 449 }
 450
 451 static inline pud_t pud_mkyoung(pud_t pud)
 452 {
 453         return pud_set_flags(pud, _PAGE_ACCESSED);
 454 }
 455
 456 static inline pud_t pud_mkwrite(pud_t pud)
 457 {
 458         return pud_set_flags(pud, _PAGE_RW);
 459 }
 460
 461 static inline pud_t pud_mknotpresent(pud_t pud)
 462 {
 463         return pud_clear_flags(pud, _PAGE_PRESENT | _PAGE_PROTNONE);
 464 }
 465
 466 #ifdef CONFIG_HAVE_ARCH_SOFT_DIRTY
 467 static inline int pte_soft_dirty(pte_t pte)
 468 {
 469         return pte_flags(pte) & _PAGE_SOFT_DIRTY;
 470 }
 471
 472 static inline int pmd_soft_dirty(pmd_t pmd)
 473 {
 474         return pmd_flags(pmd) & _PAGE_SOFT_DIRTY;
 475 }
 476
 477 static inline int pud_soft_dirty(pud_t pud)
 478 {
 479         return pud_flags(pud) & _PAGE_SOFT_DIRTY;
 480 }
 481
 482 static inline pte_t pte_mksoft_dirty(pte_t pte)
 483 {
 484         return pte_set_flags(pte, _PAGE_SOFT_DIRTY);
 485 }
 486
 487 static inline pmd_t pmd_mksoft_dirty(pmd_t pmd)
 488 {
 489         return pmd_set_flags(pmd, _PAGE_SOFT_DIRTY);
 490 }
 491
 492 static inline pud_t pud_mksoft_dirty(pud_t pud)
 493 {
 494         return pud_set_flags(pud, _PAGE_SOFT_DIRTY);
 495 }
 496
 497 static inline pte_t pte_clear_soft_dirty(pte_t pte)
 498 {
 499         return pte_clear_flags(pte, _PAGE_SOFT_DIRTY);
 500 }
 501
 502 static inline pmd_t pmd_clear_soft_dirty(pmd_t pmd)
 503 {
 504         return pmd_clear_flags(pmd, _PAGE_SOFT_DIRTY);
 505 }
 506
 507 static inline pud_t pud_clear_soft_dirty(pud_t pud)
 508 {
 509         return pud_clear_flags(pud, _PAGE_SOFT_DIRTY);
 510 }
 511
 512 #endif /* CONFIG_HAVE_ARCH_SOFT_DIRTY */
 513
 514 /*
 515  * Mask out unsupported bits in a present pgprot.  Non-present pgprots
 516  * can use those bits for other purposes, so leave them be.
 517  */
 518 static inline pgprotval_t massage_pgprot(pgprot_t pgprot)
 519 {
 520         pgprotval_t protval = pgprot_val(pgprot);
 521
 522         if (protval & _PAGE_PRESENT)
 523                 protval &= __supported_pte_mask;
 524
 525         return protval;
 526 }
 527
 528 static inline pte_t pfn_pte(unsigned long page_nr, pgprot_t pgprot)
 529 {
 530         return __pte(((phys_addr_t)page_nr << PAGE_SHIFT) |
 531                      massage_pgprot(pgprot));
 532 }
 533
 534 static inline pmd_t pfn_pmd(unsigned long page_nr, pgprot_t pgprot)
 535 {
 536         return __pmd(((phys_addr_t)page_nr << PAGE_SHIFT) |
 537                      massage_pgprot(pgprot));
 538 }
 539
 540 static inline pud_t pfn_pud(unsigned long page_nr, pgprot_t pgprot)
 541 {
 542         return __pud(((phys_addr_t)page_nr << PAGE_SHIFT) |
 543                      massage_pgprot(pgprot));
 544 }
 545
 546 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 547 {
 548         pteval_t val = pte_val(pte);
 549
 550         /*
 551          * Chop off the NX bit (if present), and add the NX portion of
 552          * the newprot (if present):
 553          */
 554         val &= _PAGE_CHG_MASK;
 555         val |= massage_pgprot(newprot) & ~_PAGE_CHG_MASK;
 556
 557         return __pte(val);
 558 }
 559
 560 static inline pmd_t pmd_modify(pmd_t pmd, pgprot_t newprot)
 561 {
 562         pmdval_t val = pmd_val(pmd);
 563
 564         val &= _HPAGE_CHG_MASK;
 565         val |= massage_pgprot(newprot) & ~_HPAGE_CHG_MASK;
 566
 567         return __pmd(val);
 568 }
 569
 570 /* mprotect needs to preserve PAT bits when updating vm_page_prot */
 571 #define pgprot_modify pgprot_modify
 572 static inline pgprot_t pgprot_modify(pgprot_t oldprot, pgprot_t newprot)
 573 {
 574         pgprotval_t preservebits = pgprot_val(oldprot) & _PAGE_CHG_MASK;
 575         pgprotval_t addbits = pgprot_val(newprot);
 576         return __pgprot(preservebits | addbits);
 577 }
 578
 579 #define pte_pgprot(x) __pgprot(pte_flags(x))
 580 #define pmd_pgprot(x) __pgprot(pmd_flags(x))
 581 #define pud_pgprot(x) __pgprot(pud_flags(x))
 582 #define p4d_pgprot(x) __pgprot(p4d_flags(x))
 583
 584 #define canon_pgprot(p) __pgprot(massage_pgprot(p))
 585
 586 static inline int is_new_memtype_allowed(u64 paddr, unsigned long size,
 587                                          enum page_cache_mode pcm,
 588                                          enum page_cache_mode new_pcm)
 589 {
 590         /*
 591          * PAT type is always WB for untracked ranges, so no need to check.
 592          */
 593         if (x86_platform.is_untracked_pat_range(paddr, paddr + size))
 594                 return 1;
 595
 596         /*
 597          * Certain new memtypes are not allowed with certain
 598          * requested memtype:
 599          * - request is uncached, return cannot be write-back
 600          * - request is write-combine, return cannot be write-back
 601          * - request is write-through, return cannot be write-back
 602          * - request is write-through, return cannot be write-combine
 603          */
 604         if ((pcm == _PAGE_CACHE_MODE_UC_MINUS &&
 605              new_pcm == _PAGE_CACHE_MODE_WB) ||
 606             (pcm == _PAGE_CACHE_MODE_WC &&
 607              new_pcm == _PAGE_CACHE_MODE_WB) ||
 608             (pcm == _PAGE_CACHE_MODE_WT &&
 609              new_pcm == _PAGE_CACHE_MODE_WB) ||
 610             (pcm == _PAGE_CACHE_MODE_WT &&
 611              new_pcm == _PAGE_CACHE_MODE_WC)) {
 612                 return 0;
 613         }
 614
 615         return 1;
 616 }
 617
 618 pmd_t *populate_extra_pmd(unsigned long vaddr);
 619 pte_t *populate_extra_pte(unsigned long vaddr);
 620 #endif  /* __ASSEMBLY__ */
 621
 622 #ifdef CONFIG_X86_32
 623 # include <asm/pgtable_32.h>
 624 #else
 625 # include <asm/pgtable_64.h>
 626 #endif
 627
 628 #ifndef __ASSEMBLY__
 629 #include <linux/mm_types.h>
 630 #include <linux/mmdebug.h>
 631 #include <linux/log2.h>
 632 #include <asm/fixmap.h>
 633
 634 static inline int pte_none(pte_t pte)
 635 {
 636         return !(pte.pte & ~(_PAGE_KNL_ERRATUM_MASK));
 637 }
 638
 639 #define __HAVE_ARCH_PTE_SAME
 640 static inline int pte_same(pte_t a, pte_t b)
 641 {
 642         return a.pte == b.pte;
 643 }
 644
 645 static inline int pte_present(pte_t a)
 646 {
 647         return pte_flags(a) & (_PAGE_PRESENT | _PAGE_PROTNONE);
 648 }
 649
 650 #ifdef __HAVE_ARCH_PTE_DEVMAP
 651 static inline int pte_devmap(pte_t a)
 652 {
 653         return (pte_flags(a) & _PAGE_DEVMAP) == _PAGE_DEVMAP;
 654 }
 655 #endif
 656
 657 #define pte_accessible pte_accessible
 658 static inline bool pte_accessible(struct mm_struct *mm, pte_t a)
 659 {
 660         if (pte_flags(a) & _PAGE_PRESENT)
 661                 return true;
 662
 663         if ((pte_flags(a) & _PAGE_PROTNONE) &&
 664                         mm_tlb_flush_pending(mm))
 665                 return true;
 666
 667         return false;
 668 }
 669
 670 static inline int pmd_present(pmd_t pmd)
 671 {
 672         /*
 673          * Checking for _PAGE_PSE is needed too because
 674          * split_huge_page will temporarily clear the present bit (but
 675          * the _PAGE_PSE flag will remain set at all times while the
 676          * _PAGE_PRESENT bit is clear).
 677          */
 678         return pmd_flags(pmd) & (_PAGE_PRESENT | _PAGE_PROTNONE | _PAGE_PSE);
 679 }
 680
 681 #ifdef CONFIG_NUMA_BALANCING
 682 /*
 683  * These work without NUMA balancing but the kernel does not care. See the
 684  * comment in include/asm-generic/pgtable.h
 685  */
 686 static inline int pte_protnone(pte_t pte)
 687 {
 688         return (pte_flags(pte) & (_PAGE_PROTNONE | _PAGE_PRESENT))
 689                 == _PAGE_PROTNONE;
 690 }
 691
 692 static inline int pmd_protnone(pmd_t pmd)
 693 {
 694         return (pmd_flags(pmd) & (_PAGE_PROTNONE | _PAGE_PRESENT))
 695                 == _PAGE_PROTNONE;
 696 }
 697 #endif /* CONFIG_NUMA_BALANCING */
 698
 699 static inline int pmd_none(pmd_t pmd)
 700 {
 701         /* Only check low word on 32-bit platforms, since it might be
 702            out of sync with upper half. */
 703         unsigned long val = native_pmd_val(pmd);
 704         return (val & ~_PAGE_KNL_ERRATUM_MASK) == 0;
 705 }
 706
 707 static inline unsigned long pmd_page_vaddr(pmd_t pmd)
 708 {
 709         return (unsigned long)__va(pmd_val(pmd) & pmd_pfn_mask(pmd));
 710 }
 711
 712 /*
 713  * Currently stuck as a macro due to indirect forward reference to
 714  * linux/mmzone.h's __section_mem_map_addr() definition:
 715  */
 716 #define pmd_page(pmd)   pfn_to_page(pmd_pfn(pmd))
 717
 718 /*
 719  * the pmd page can be thought of an array like this: pmd_t[PTRS_PER_PMD]
 720  *
 721  * this macro returns the index of the entry in the pmd page which would
 722  * control the given virtual address
 723  */
 724 static inline unsigned long pmd_index(unsigned long address)
 725 {
 726         return (address >> PMD_SHIFT) & (PTRS_PER_PMD - 1);
 727 }
 728
 729 /*
 730  * Conversion functions: convert a page and protection to a page entry,
 731  * and a page entry and page directory to the page they refer to.
 732  *
 733  * (Currently stuck as a macro because of indirect forward reference
 734  * to linux/mm.h:page_to_nid())
 735  */
 736 #define mk_pte(page, pgprot)   pfn_pte(page_to_pfn(page), (pgprot))
 737
 738 /*
 739  * the pte page can be thought of an array like this: pte_t[PTRS_PER_PTE]
 740  *
 741  * this function returns the index of the entry in the pte page which would
 742  * control the given virtual address
 743  */
 744 static inline unsigned long pte_index(unsigned long address)
 745 {
 746         return (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
 747 }
 748
 749 static inline pte_t *pte_offset_kernel(pmd_t *pmd, unsigned long address)
 750 {
 751         return (pte_t *)pmd_page_vaddr(*pmd) + pte_index(address);
 752 }
 753
 754 static inline int pmd_bad(pmd_t pmd)
 755 {
 756         return (pmd_flags(pmd) & ~_PAGE_USER) != _KERNPG_TABLE;
 757 }
 758
 759 static inline unsigned long pages_to_mb(unsigned long npg)
 760 {
 761         return npg >> (20 - PAGE_SHIFT);
 762 }
 763
 764 #if CONFIG_PGTABLE_LEVELS > 2
 765 static inline int pud_none(pud_t pud)
 766 {
 767         return (native_pud_val(pud) & ~(_PAGE_KNL_ERRATUM_MASK)) == 0;
 768 }
 769
 770 static inline int pud_present(pud_t pud)
 771 {
 772         return pud_flags(pud) & _PAGE_PRESENT;
 773 }
 774
 775 static inline unsigned long pud_page_vaddr(pud_t pud)
 776 {
 777         return (unsigned long)__va(pud_val(pud) & pud_pfn_mask(pud));
 778 }
 779
 780 /*
 781  * Currently stuck as a macro due to indirect forward reference to
 782  * linux/mmzone.h's __section_mem_map_addr() definition:
 783  */
 784 #define pud_page(pud)   pfn_to_page(pud_pfn(pud))
 785
 786 /* Find an entry in the second-level page table.. */
 787 static inline pmd_t *pmd_offset(pud_t *pud, unsigned long address)
 788 {
 789         return (pmd_t *)pud_page_vaddr(*pud) + pmd_index(address);
 790 }
 791
 792 static inline int pud_large(pud_t pud)
 793 {
 794         return (pud_val(pud) & (_PAGE_PSE | _PAGE_PRESENT)) ==
 795                 (_PAGE_PSE | _PAGE_PRESENT);
 796 }
 797
 798 static inline int pud_bad(pud_t pud)
 799 {
 800         return (pud_flags(pud) & ~(_KERNPG_TABLE | _PAGE_USER)) != 0;
 801 }
 802 #else
 803 static inline int pud_large(pud_t pud)
 804 {
 805         return 0;
 806 }
 807 #endif  /* CONFIG_PGTABLE_LEVELS > 2 */
 808
 809 static inline unsigned long pud_index(unsigned long address)
 810 {
 811         return (address >> PUD_SHIFT) & (PTRS_PER_PUD - 1);
 812 }
 813
 814 #if CONFIG_PGTABLE_LEVELS > 3
 815 static inline int p4d_none(p4d_t p4d)
 816 {
 817         return (native_p4d_val(p4d) & ~(_PAGE_KNL_ERRATUM_MASK)) == 0;
 818 }
 819
 820 static inline int p4d_present(p4d_t p4d)
 821 {
 822         return p4d_flags(p4d) & _PAGE_PRESENT;
 823 }
 824
 825 static inline unsigned long p4d_page_vaddr(p4d_t p4d)
 826 {
 827         return (unsigned long)__va(p4d_val(p4d) & p4d_pfn_mask(p4d));
 828 }
 829
 830 /*
 831  * Currently stuck as a macro due to indirect forward reference to
 832  * linux/mmzone.h's __section_mem_map_addr() definition:
 833  */
 834 #define p4d_page(p4d)   pfn_to_page(p4d_pfn(p4d))
 835
 836 /* Find an entry in the third-level page table.. */
 837 static inline pud_t *pud_offset(p4d_t *p4d, unsigned long address)
 838 {
 839         return (pud_t *)p4d_page_vaddr(*p4d) + pud_index(address);
 840 }
 841
 842 static inline int p4d_bad(p4d_t p4d)
 843 {
 844         return (p4d_flags(p4d) & ~(_KERNPG_TABLE | _PAGE_USER)) != 0;
 845 }
 846 #endif  /* CONFIG_PGTABLE_LEVELS > 3 */
 847
 848 static inline unsigned long p4d_index(unsigned long address)
 849 {
 850         return (address >> P4D_SHIFT) & (PTRS_PER_P4D - 1);
 851 }
 852
 853 #if CONFIG_PGTABLE_LEVELS > 4
 854 static inline int pgd_present(pgd_t pgd)
 855 {
 856         return pgd_flags(pgd) & _PAGE_PRESENT;
 857 }
 858
 859 static inline unsigned long pgd_page_vaddr(pgd_t pgd)
 860 {
 861         return (unsigned long)__va((unsigned long)pgd_val(pgd) & PTE_PFN_MASK);
 862 }
 863
 864 /*
 865  * Currently stuck as a macro due to indirect forward reference to
 866  * linux/mmzone.h's __section_mem_map_addr() definition:
 867  */
 868 #define pgd_page(pgd)   pfn_to_page(pgd_pfn(pgd))
 869
 870 /* to find an entry in a page-table-directory. */
 871 static inline p4d_t *p4d_offset(pgd_t *pgd, unsigned long address)
 872 {
 873         return (p4d_t *)pgd_page_vaddr(*pgd) + p4d_index(address);
 874 }
 875
 876 static inline int pgd_bad(pgd_t pgd)
 877 {
 878         return (pgd_flags(pgd) & ~_PAGE_USER) != _KERNPG_TABLE;
 879 }
 880
 881 static inline int pgd_none(pgd_t pgd)
 882 {
 883         /*
 884          * There is no need to do a workaround for the KNL stray
 885          * A/D bit erratum here.  PGDs only point to page tables
 886          * except on 32-bit non-PAE which is not supported on
 887          * KNL.
 888          */
 889         return !native_pgd_val(pgd);
 890 }
 891 #endif  /* CONFIG_PGTABLE_LEVELS > 4 */
 892
 893 #endif  /* __ASSEMBLY__ */
 894
 895 /*
 896  * the pgd page can be thought of an array like this: pgd_t[PTRS_PER_PGD]
 897  *
 898  * this macro returns the index of the entry in the pgd page which would
 899  * control the given virtual address
 900  */
 901 #define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD - 1))
 902
 903 /*
 904  * pgd_offset() returns a (pgd_t *)
 905  * pgd_index() is used get the offset into the pgd page's array of pgd_t's;
 906  */
 907 #define pgd_offset(mm, address) ((mm)->pgd + pgd_index((address)))
 908 /*
 909  * a shortcut which implies the use of the kernel's pgd, instead
 910  * of a process's
 911  */
 912 #define pgd_offset_k(address) pgd_offset(&init_mm, (address))
 913
 914
 915 #define KERNEL_PGD_BOUNDARY     pgd_index(PAGE_OFFSET)
 916 #define KERNEL_PGD_PTRS         (PTRS_PER_PGD - KERNEL_PGD_BOUNDARY)
 917
 918 #ifndef __ASSEMBLY__
 919
 920 extern int direct_gbpages;
 921 void init_mem_mapping(void);
 922 void early_alloc_pgt_buf(void);
 923 extern void memblock_find_dma_reserve(void);
 924
 925 #ifdef CONFIG_X86_64
 926 /* Realmode trampoline initialization. */
 927 extern pgd_t trampoline_pgd_entry;
 928 static inline void __meminit init_trampoline_default(void)
 929 {
 930         /* Default trampoline pgd value */
 931         trampoline_pgd_entry = init_top_pgt[pgd_index(__PAGE_OFFSET)];
 932 }
 933 # ifdef CONFIG_RANDOMIZE_MEMORY
 934 void __meminit init_trampoline(void);
 935 # else
 936 #  define init_trampoline init_trampoline_default
 937 # endif
 938 #else
 939 static inline void init_trampoline(void) { }
 940 #endif
 941
 942 /* local pte updates need not use xchg for locking */
 943 static inline pte_t native_local_ptep_get_and_clear(pte_t *ptep)
 944 {
 945         pte_t res = *ptep;
 946
 947         /* Pure native function needs no input for mm, addr */
 948         native_pte_clear(NULL, 0, ptep);
 949         return res;
 950 }
 951
 952 static inline pmd_t native_local_pmdp_get_and_clear(pmd_t *pmdp)
 953 {
 954         pmd_t res = *pmdp;
 955
 956         native_pmd_clear(pmdp);
 957         return res;
 958 }
 959
 960 static inline pud_t native_local_pudp_get_and_clear(pud_t *pudp)
 961 {
 962         pud_t res = *pudp;
 963
 964         native_pud_clear(pudp);
 965         return res;
 966 }
 967
 968 static inline void native_set_pte_at(struct mm_struct *mm, unsigned long addr,
 969                                      pte_t *ptep , pte_t pte)
 970 {
 971         native_set_pte(ptep, pte);
 972 }
 973
 974 static inline void set_pmd_at(struct mm_struct *mm, unsigned long addr,
 975                               pmd_t *pmdp, pmd_t pmd)
 976 {
 977         native_set_pmd(pmdp, pmd);
 978 }
 979
 980 static inline void set_pud_at(struct mm_struct *mm, unsigned long addr,
 981                               pud_t *pudp, pud_t pud)
 982 {
 983         native_set_pud(pudp, pud);
 984 }
 985
 986 /*
 987  * We only update the dirty/accessed state if we set
 988  * the dirty bit by hand in the kernel, since the hardware
 989  * will do the accessed bit for us, and we don't want to
 990  * race with other CPU's that might be updating the dirty
 991  * bit at the same time.
 992  */
 993 struct vm_area_struct;
 994
 995 #define  __HAVE_ARCH_PTEP_SET_ACCESS_FLAGS
 996 extern int ptep_set_access_flags(struct vm_area_struct *vma,
 997                                  unsigned long address, pte_t *ptep,
 998                                  pte_t entry, int dirty);
 999
1000 #define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
1001 extern int ptep_test_and_clear_young(struct vm_area_struct *vma,
1002                                      unsigned long addr, pte_t *ptep);
1003
1004 #define __HAVE_ARCH_PTEP_CLEAR_YOUNG_FLUSH
1005 extern int ptep_clear_flush_young(struct vm_area_struct *vma,
1006                                   unsigned long address, pte_t *ptep);
1007
1008 #define __HAVE_ARCH_PTEP_GET_AND_CLEAR
1009 static inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
1010                                        pte_t *ptep)
1011 {
1012         pte_t pte = native_ptep_get_and_clear(ptep);
1013         return pte;
1014 }
1015
1016 #define __HAVE_ARCH_PTEP_GET_AND_CLEAR_FULL
1017 static inline pte_t ptep_get_and_clear_full(struct mm_struct *mm,
1018                                             unsigned long addr, pte_t *ptep,
1019                                             int full)
1020 {
1021         pte_t pte;
1022         if (full) {
1023                 /*
1024                  * Full address destruction in progress; paravirt does not
1025                  * care about updates and native needs no locking
1026                  */
1027                 pte = native_local_ptep_get_and_clear(ptep);
1028         } else {
1029                 pte = ptep_get_and_clear(mm, addr, ptep);
1030         }
1031         return pte;
1032 }
1033
1034 #define __HAVE_ARCH_PTEP_SET_WRPROTECT
1035 static inline void ptep_set_wrprotect(struct mm_struct *mm,
1036                                       unsigned long addr, pte_t *ptep)
1037 {
1038         clear_bit(_PAGE_BIT_RW, (unsigned long *)&ptep->pte);
1039 }
1040
1041 #define flush_tlb_fix_spurious_fault(vma, address) do { } while (0)
1042
1043 #define mk_pmd(page, pgprot)   pfn_pmd(page_to_pfn(page), (pgprot))
1044
1045 #define  __HAVE_ARCH_PMDP_SET_ACCESS_FLAGS
1046 extern int pmdp_set_access_flags(struct vm_area_struct *vma,
1047                                  unsigned long address, pmd_t *pmdp,
1048                                  pmd_t entry, int dirty);
1049 extern int pudp_set_access_flags(struct vm_area_struct *vma,
1050                                  unsigned long address, pud_t *pudp,
1051                                  pud_t entry, int dirty);
1052
1053 #define __HAVE_ARCH_PMDP_TEST_AND_CLEAR_YOUNG
1054 extern int pmdp_test_and_clear_young(struct vm_area_struct *vma,
1055                                      unsigned long addr, pmd_t *pmdp);
1056 extern int pudp_test_and_clear_young(struct vm_area_struct *vma,
1057                                      unsigned long addr, pud_t *pudp);
1058
1059 #define __HAVE_ARCH_PMDP_CLEAR_YOUNG_FLUSH
1060 extern int pmdp_clear_flush_young(struct vm_area_struct *vma,
1061                                   unsigned long address, pmd_t *pmdp);
1062
1063
1064 #define __HAVE_ARCH_PMD_WRITE
1065 static inline int pmd_write(pmd_t pmd)
1066 {
1067         return pmd_flags(pmd) & _PAGE_RW;
1068 }
1069
1070 #define __HAVE_ARCH_PMDP_HUGE_GET_AND_CLEAR
1071 static inline pmd_t pmdp_huge_get_and_clear(struct mm_struct *mm, unsigned long addr,
1072                                        pmd_t *pmdp)
1073 {
1074         return native_pmdp_get_and_clear(pmdp);
1075 }
1076
1077 #define __HAVE_ARCH_PUDP_HUGE_GET_AND_CLEAR
1078 static inline pud_t pudp_huge_get_and_clear(struct mm_struct *mm,
1079                                         unsigned long addr, pud_t *pudp)
1080 {
1081         return native_pudp_get_and_clear(pudp);
1082 }
1083
1084 #define __HAVE_ARCH_PMDP_SET_WRPROTECT
1085 static inline void pmdp_set_wrprotect(struct mm_struct *mm,
1086                                       unsigned long addr, pmd_t *pmdp)
1087 {
1088         clear_bit(_PAGE_BIT_RW, (unsigned long *)pmdp);
1089 }
1090
1091 /*
1092  * clone_pgd_range(pgd_t *dst, pgd_t *src, int count);
1093  *
1094  *  dst - pointer to pgd range anwhere on a pgd page
1095  *  src - ""
1096  *  count - the number of pgds to copy.
1097  *
1098  * dst and src can be on the same page, but the range must not overlap,
1099  * and must not cross a page boundary.
1100  */
1101 static inline void clone_pgd_range(pgd_t *dst, pgd_t *src, int count)
1102 {
1103        memcpy(dst, src, count * sizeof(pgd_t));
1104 }
1105
1106 #define PTE_SHIFT ilog2(PTRS_PER_PTE)
1107 static inline int page_level_shift(enum pg_level level)
1108 {
1109         return (PAGE_SHIFT - PTE_SHIFT) + level * PTE_SHIFT;
1110 }
1111 static inline unsigned long page_level_size(enum pg_level level)
1112 {
1113         return 1UL << page_level_shift(level);
1114 }
1115 static inline unsigned long page_level_mask(enum pg_level level)
1116 {
1117         return ~(page_level_size(level) - 1);
1118 }
1119
1120 /*
1121  * The x86 doesn't have any external MMU info: the kernel page
1122  * tables contain all the necessary information.
1123  */
1124 static inline void update_mmu_cache(struct vm_area_struct *vma,
1125                 unsigned long addr, pte_t *ptep)
1126 {
1127 }
1128 static inline void update_mmu_cache_pmd(struct vm_area_struct *vma,
1129                 unsigned long addr, pmd_t *pmd)
1130 {
1131 }
1132 static inline void update_mmu_cache_pud(struct vm_area_struct *vma,
1133                 unsigned long addr, pud_t *pud)
1134 {
1135 }
1136
1137 #ifdef CONFIG_HAVE_ARCH_SOFT_DIRTY
1138 static inline pte_t pte_swp_mksoft_dirty(pte_t pte)
1139 {
1140         return pte_set_flags(pte, _PAGE_SWP_SOFT_DIRTY);
1141 }
1142
1143 static inline int pte_swp_soft_dirty(pte_t pte)
1144 {
1145         return pte_flags(pte) & _PAGE_SWP_SOFT_DIRTY;
1146 }
1147
1148 static inline pte_t pte_swp_clear_soft_dirty(pte_t pte)
1149 {
1150         return pte_clear_flags(pte, _PAGE_SWP_SOFT_DIRTY);
1151 }
1152
1153 #ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION
1154 static inline pmd_t pmd_swp_mksoft_dirty(pmd_t pmd)
1155 {
1156         return pmd_set_flags(pmd, _PAGE_SWP_SOFT_DIRTY);
1157 }
1158
1159 static inline int pmd_swp_soft_dirty(pmd_t pmd)
1160 {
1161         return pmd_flags(pmd) & _PAGE_SWP_SOFT_DIRTY;
1162 }
1163
1164 static inline pmd_t pmd_swp_clear_soft_dirty(pmd_t pmd)
1165 {
1166         return pmd_clear_flags(pmd, _PAGE_SWP_SOFT_DIRTY);
1167 }
1168 #endif
1169 #endif
1170
1171 #define PKRU_AD_BIT 0x1
1172 #define PKRU_WD_BIT 0x2
1173 #define PKRU_BITS_PER_PKEY 2
1174
1175 static inline bool __pkru_allows_read(u32 pkru, u16 pkey)
1176 {
1177         int pkru_pkey_bits = pkey * PKRU_BITS_PER_PKEY;
1178         return !(pkru & (PKRU_AD_BIT << pkru_pkey_bits));
1179 }
1180
1181 static inline bool __pkru_allows_write(u32 pkru, u16 pkey)
1182 {
1183         int pkru_pkey_bits = pkey * PKRU_BITS_PER_PKEY;
1184         /*
1185          * Access-disable disables writes too so we need to check
1186          * both bits here.
1187          */
1188         return !(pkru & ((PKRU_AD_BIT|PKRU_WD_BIT) << pkru_pkey_bits));
1189 }
1190
1191 static inline u16 pte_flags_pkey(unsigned long pte_flags)
1192 {
1193 #ifdef CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS
1194         /* ifdef to avoid doing 59-bit shift on 32-bit values */
1195         return (pte_flags & _PAGE_PKEY_MASK) >> _PAGE_BIT_PKEY_BIT0;
1196 #else
1197         return 0;
1198 #endif
1199 }
1200
1201 static inline bool __pkru_allows_pkey(u16 pkey, bool write)
1202 {
1203         u32 pkru = read_pkru();
1204
1205         if (!__pkru_allows_read(pkru, pkey))
1206                 return false;
1207         if (write && !__pkru_allows_write(pkru, pkey))
1208                 return false;
1209
1210         return true;
1211 }
1212
1213 /*
1214  * 'pteval' can come from a PTE, PMD or PUD.  We only check
1215  * _PAGE_PRESENT, _PAGE_USER, and _PAGE_RW in here which are the
1216  * same value on all 3 types.
1217  */
1218 static inline bool __pte_access_permitted(unsigned long pteval, bool write)
1219 {
1220         unsigned long need_pte_bits = _PAGE_PRESENT|_PAGE_USER;
1221
1222         if (write)
1223                 need_pte_bits |= _PAGE_RW;
1224
1225         if ((pteval & need_pte_bits) != need_pte_bits)
1226                 return 0;
1227
1228         return __pkru_allows_pkey(pte_flags_pkey(pteval), write);
1229 }
1230
1231 #define pte_access_permitted pte_access_permitted
1232 static inline bool pte_access_permitted(pte_t pte, bool write)
1233 {
1234         return __pte_access_permitted(pte_val(pte), write);
1235 }
1236
1237 #define pmd_access_permitted pmd_access_permitted
1238 static inline bool pmd_access_permitted(pmd_t pmd, bool write)
1239 {
1240         return __pte_access_permitted(pmd_val(pmd), write);
1241 }
1242
1243 #define pud_access_permitted pud_access_permitted
1244 static inline bool pud_access_permitted(pud_t pud, bool write)
1245 {
1246         return __pte_access_permitted(pud_val(pud), write);
1247 }
1248
1249 #include <asm-generic/pgtable.h>
1250 #endif  /* __ASSEMBLY__ */
1251
1252 #endif /* _ASM_X86_PGTABLE_H */