arch/s390/mm/pgtable.c

   1 /*
   2  *    Copyright IBM Corp. 2007, 2011
   3  *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
   4  */
   5
   6 #include <linux/sched.h>
   7 #include <linux/kernel.h>
   8 #include <linux/errno.h>
   9 #include <linux/gfp.h>
  10 #include <linux/mm.h>
  11 #include <linux/swap.h>
  12 #include <linux/smp.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/rcupdate.h>
  15 #include <linux/slab.h>
  16 #include <linux/swapops.h>
  17 #include <linux/sysctl.h>
  18 #include <linux/ksm.h>
  19 #include <linux/mman.h>
  20
  21 #include <asm/pgtable.h>
  22 #include <asm/pgalloc.h>
  23 #include <asm/tlb.h>
  24 #include <asm/tlbflush.h>
  25 #include <asm/mmu_context.h>
  26 #include <asm/page-states.h>
  27
  28 static inline pte_t ptep_flush_direct(struct mm_struct *mm,
  29                                       unsigned long addr, pte_t *ptep)
  30 {
  31         pte_t old;
  32
  33         old = *ptep;
  34         if (unlikely(pte_val(old) & _PAGE_INVALID))
  35                 return old;
  36         atomic_inc(&mm->context.flush_count);
  37         if (MACHINE_HAS_TLB_LC &&
  38             cpumask_equal(mm_cpumask(mm), cpumask_of(smp_processor_id())))
  39                 __ptep_ipte(addr, ptep, IPTE_LOCAL);
  40         else
  41                 __ptep_ipte(addr, ptep, IPTE_GLOBAL);
  42         atomic_dec(&mm->context.flush_count);
  43         return old;
  44 }
  45
  46 static inline pte_t ptep_flush_lazy(struct mm_struct *mm,
  47                                     unsigned long addr, pte_t *ptep)
  48 {
  49         pte_t old;
  50
  51         old = *ptep;
  52         if (unlikely(pte_val(old) & _PAGE_INVALID))
  53                 return old;
  54         atomic_inc(&mm->context.flush_count);
  55         if (cpumask_equal(&mm->context.cpu_attach_mask,
  56                           cpumask_of(smp_processor_id()))) {
  57                 pte_val(*ptep) |= _PAGE_INVALID;
  58                 mm->context.flush_mm = 1;
  59         } else
  60                 __ptep_ipte(addr, ptep, IPTE_GLOBAL);
  61         atomic_dec(&mm->context.flush_count);
  62         return old;
  63 }
  64
  65 static inline pgste_t pgste_get_lock(pte_t *ptep)
  66 {
  67         unsigned long new = 0;
  68 #ifdef CONFIG_PGSTE
  69         unsigned long old;
  70
  71         asm(
  72                 "       lg      %0,%2\n"
  73                 "0:     lgr     %1,%0\n"
  74                 "       nihh    %0,0xff7f\n"    /* clear PCL bit in old */
  75                 "       oihh    %1,0x0080\n"    /* set PCL bit in new */
  76                 "       csg     %0,%1,%2\n"
  77                 "       jl      0b\n"
  78                 : "=&d" (old), "=&d" (new), "=Q" (ptep[PTRS_PER_PTE])
  79                 : "Q" (ptep[PTRS_PER_PTE]) : "cc", "memory");
  80 #endif
  81         return __pgste(new);
  82 }
  83
  84 static inline void pgste_set_unlock(pte_t *ptep, pgste_t pgste)
  85 {
  86 #ifdef CONFIG_PGSTE
  87         asm(
  88                 "       nihh    %1,0xff7f\n"    /* clear PCL bit */
  89                 "       stg     %1,%0\n"
  90                 : "=Q" (ptep[PTRS_PER_PTE])
  91                 : "d" (pgste_val(pgste)), "Q" (ptep[PTRS_PER_PTE])
  92                 : "cc", "memory");
  93 #endif
  94 }
  95
  96 static inline pgste_t pgste_get(pte_t *ptep)
  97 {
  98         unsigned long pgste = 0;
  99 #ifdef CONFIG_PGSTE
 100         pgste = *(unsigned long *)(ptep + PTRS_PER_PTE);
 101 #endif
 102         return __pgste(pgste);
 103 }
 104
 105 static inline void pgste_set(pte_t *ptep, pgste_t pgste)
 106 {
 107 #ifdef CONFIG_PGSTE
 108         *(pgste_t *)(ptep + PTRS_PER_PTE) = pgste;
 109 #endif
 110 }
 111
 112 static inline pgste_t pgste_update_all(pte_t pte, pgste_t pgste,
 113                                        struct mm_struct *mm)
 114 {
 115 #ifdef CONFIG_PGSTE
 116         unsigned long address, bits, skey;
 117
 118         if (!mm_use_skey(mm) || pte_val(pte) & _PAGE_INVALID)
 119                 return pgste;
 120         address = pte_val(pte) & PAGE_MASK;
 121         skey = (unsigned long) page_get_storage_key(address);
 122         bits = skey & (_PAGE_CHANGED | _PAGE_REFERENCED);
 123         /* Transfer page changed & referenced bit to guest bits in pgste */
 124         pgste_val(pgste) |= bits << 48;         /* GR bit & GC bit */
 125         /* Copy page access key and fetch protection bit to pgste */
 126         pgste_val(pgste) &= ~(PGSTE_ACC_BITS | PGSTE_FP_BIT);
 127         pgste_val(pgste) |= (skey & (_PAGE_ACC_BITS | _PAGE_FP_BIT)) << 56;
 128 #endif
 129         return pgste;
 130
 131 }
 132
 133 static inline void pgste_set_key(pte_t *ptep, pgste_t pgste, pte_t entry,
 134                                  struct mm_struct *mm)
 135 {
 136 #ifdef CONFIG_PGSTE
 137         unsigned long address;
 138         unsigned long nkey;
 139
 140         if (!mm_use_skey(mm) || pte_val(entry) & _PAGE_INVALID)
 141                 return;
 142         VM_BUG_ON(!(pte_val(*ptep) & _PAGE_INVALID));
 143         address = pte_val(entry) & PAGE_MASK;
 144         /*
 145          * Set page access key and fetch protection bit from pgste.
 146          * The guest C/R information is still in the PGSTE, set real
 147          * key C/R to 0.
 148          */
 149         nkey = (pgste_val(pgste) & (PGSTE_ACC_BITS | PGSTE_FP_BIT)) >> 56;
 150         nkey |= (pgste_val(pgste) & (PGSTE_GR_BIT | PGSTE_GC_BIT)) >> 48;
 151         page_set_storage_key(address, nkey, 0);
 152 #endif
 153 }
 154
 155 static inline pgste_t pgste_set_pte(pte_t *ptep, pgste_t pgste, pte_t entry)
 156 {
 157 #ifdef CONFIG_PGSTE
 158         if ((pte_val(entry) & _PAGE_PRESENT) &&
 159             (pte_val(entry) & _PAGE_WRITE) &&
 160             !(pte_val(entry) & _PAGE_INVALID)) {
 161                 if (!MACHINE_HAS_ESOP) {
 162                         /*
 163                          * Without enhanced suppression-on-protection force
 164                          * the dirty bit on for all writable ptes.
 165                          */
 166                         pte_val(entry) |= _PAGE_DIRTY;
 167                         pte_val(entry) &= ~_PAGE_PROTECT;
 168                 }
 169                 if (!(pte_val(entry) & _PAGE_PROTECT))
 170                         /* This pte allows write access, set user-dirty */
 171                         pgste_val(pgste) |= PGSTE_UC_BIT;
 172         }
 173 #endif
 174         *ptep = entry;
 175         return pgste;
 176 }
 177
 178 static inline pgste_t pgste_pte_notify(struct mm_struct *mm,
 179                                        unsigned long addr,
 180                                        pte_t *ptep, pgste_t pgste)
 181 {
 182 #ifdef CONFIG_PGSTE
 183         unsigned long bits;
 184
 185         bits = pgste_val(pgste) & (PGSTE_IN_BIT | PGSTE_VSIE_BIT);
 186         if (bits) {
 187                 pgste_val(pgste) ^= bits;
 188                 ptep_notify(mm, addr, ptep, bits);
 189         }
 190 #endif
 191         return pgste;
 192 }
 193
 194 static inline pgste_t ptep_xchg_start(struct mm_struct *mm,
 195                                       unsigned long addr, pte_t *ptep)
 196 {
 197         pgste_t pgste = __pgste(0);
 198
 199         if (mm_has_pgste(mm)) {
 200                 pgste = pgste_get_lock(ptep);
 201                 pgste = pgste_pte_notify(mm, addr, ptep, pgste);
 202         }
 203         return pgste;
 204 }
 205
 206 static inline pte_t ptep_xchg_commit(struct mm_struct *mm,
 207                                     unsigned long addr, pte_t *ptep,
 208                                     pgste_t pgste, pte_t old, pte_t new)
 209 {
 210         if (mm_has_pgste(mm)) {
 211                 if (pte_val(old) & _PAGE_INVALID)
 212                         pgste_set_key(ptep, pgste, new, mm);
 213                 if (pte_val(new) & _PAGE_INVALID) {
 214                         pgste = pgste_update_all(old, pgste, mm);
 215                         if ((pgste_val(pgste) & _PGSTE_GPS_USAGE_MASK) ==
 216                             _PGSTE_GPS_USAGE_UNUSED)
 217                                 pte_val(old) |= _PAGE_UNUSED;
 218                 }
 219                 pgste = pgste_set_pte(ptep, pgste, new);
 220                 pgste_set_unlock(ptep, pgste);
 221         } else {
 222                 *ptep = new;
 223         }
 224         return old;
 225 }
 226
 227 pte_t ptep_xchg_direct(struct mm_struct *mm, unsigned long addr,
 228                        pte_t *ptep, pte_t new)
 229 {
 230         pgste_t pgste;
 231         pte_t old;
 232
 233         preempt_disable();
 234         pgste = ptep_xchg_start(mm, addr, ptep);
 235         old = ptep_flush_direct(mm, addr, ptep);
 236         old = ptep_xchg_commit(mm, addr, ptep, pgste, old, new);
 237         preempt_enable();
 238         return old;
 239 }
 240 EXPORT_SYMBOL(ptep_xchg_direct);
 241
 242 pte_t ptep_xchg_lazy(struct mm_struct *mm, unsigned long addr,
 243                      pte_t *ptep, pte_t new)
 244 {
 245         pgste_t pgste;
 246         pte_t old;
 247
 248         preempt_disable();
 249         pgste = ptep_xchg_start(mm, addr, ptep);
 250         old = ptep_flush_lazy(mm, addr, ptep);
 251         old = ptep_xchg_commit(mm, addr, ptep, pgste, old, new);
 252         preempt_enable();
 253         return old;
 254 }
 255 EXPORT_SYMBOL(ptep_xchg_lazy);
 256
 257 pte_t ptep_modify_prot_start(struct mm_struct *mm, unsigned long addr,
 258                              pte_t *ptep)
 259 {
 260         pgste_t pgste;
 261         pte_t old;
 262
 263         preempt_disable();
 264         pgste = ptep_xchg_start(mm, addr, ptep);
 265         old = ptep_flush_lazy(mm, addr, ptep);
 266         if (mm_has_pgste(mm)) {
 267                 pgste = pgste_update_all(old, pgste, mm);
 268                 pgste_set(ptep, pgste);
 269         }
 270         return old;
 271 }
 272 EXPORT_SYMBOL(ptep_modify_prot_start);
 273
 274 void ptep_modify_prot_commit(struct mm_struct *mm, unsigned long addr,
 275                              pte_t *ptep, pte_t pte)
 276 {
 277         pgste_t pgste;
 278
 279         if (!MACHINE_HAS_NX)
 280                 pte_val(pte) &= ~_PAGE_NOEXEC;
 281         if (mm_has_pgste(mm)) {
 282                 pgste = pgste_get(ptep);
 283                 pgste_set_key(ptep, pgste, pte, mm);
 284                 pgste = pgste_set_pte(ptep, pgste, pte);
 285                 pgste_set_unlock(ptep, pgste);
 286         } else {
 287                 *ptep = pte;
 288         }
 289         preempt_enable();
 290 }
 291 EXPORT_SYMBOL(ptep_modify_prot_commit);
 292
 293 static inline pmd_t pmdp_flush_direct(struct mm_struct *mm,
 294                                       unsigned long addr, pmd_t *pmdp)
 295 {
 296         pmd_t old;
 297
 298         old = *pmdp;
 299         if (pmd_val(old) & _SEGMENT_ENTRY_INVALID)
 300                 return old;
 301         if (!MACHINE_HAS_IDTE) {
 302                 __pmdp_csp(pmdp);
 303                 return old;
 304         }
 305         atomic_inc(&mm->context.flush_count);
 306         if (MACHINE_HAS_TLB_LC &&
 307             cpumask_equal(mm_cpumask(mm), cpumask_of(smp_processor_id())))
 308                 __pmdp_idte(addr, pmdp, IDTE_LOCAL);
 309         else
 310                 __pmdp_idte(addr, pmdp, IDTE_GLOBAL);
 311         atomic_dec(&mm->context.flush_count);
 312         return old;
 313 }
 314
 315 static inline pmd_t pmdp_flush_lazy(struct mm_struct *mm,
 316                                     unsigned long addr, pmd_t *pmdp)
 317 {
 318         pmd_t old;
 319
 320         old = *pmdp;
 321         if (pmd_val(old) & _SEGMENT_ENTRY_INVALID)
 322                 return old;
 323         atomic_inc(&mm->context.flush_count);
 324         if (cpumask_equal(&mm->context.cpu_attach_mask,
 325                           cpumask_of(smp_processor_id()))) {
 326                 pmd_val(*pmdp) |= _SEGMENT_ENTRY_INVALID;
 327                 mm->context.flush_mm = 1;
 328         } else if (MACHINE_HAS_IDTE)
 329                 __pmdp_idte(addr, pmdp, IDTE_GLOBAL);
 330         else
 331                 __pmdp_csp(pmdp);
 332         atomic_dec(&mm->context.flush_count);
 333         return old;
 334 }
 335
 336 pmd_t pmdp_xchg_direct(struct mm_struct *mm, unsigned long addr,
 337                        pmd_t *pmdp, pmd_t new)
 338 {
 339         pmd_t old;
 340
 341         preempt_disable();
 342         old = pmdp_flush_direct(mm, addr, pmdp);
 343         *pmdp = new;
 344         preempt_enable();
 345         return old;
 346 }
 347 EXPORT_SYMBOL(pmdp_xchg_direct);
 348
 349 pmd_t pmdp_xchg_lazy(struct mm_struct *mm, unsigned long addr,
 350                      pmd_t *pmdp, pmd_t new)
 351 {
 352         pmd_t old;
 353
 354         preempt_disable();
 355         old = pmdp_flush_lazy(mm, addr, pmdp);
 356         *pmdp = new;
 357         preempt_enable();
 358         return old;
 359 }
 360 EXPORT_SYMBOL(pmdp_xchg_lazy);
 361
 362 static inline pud_t pudp_flush_direct(struct mm_struct *mm,
 363                                       unsigned long addr, pud_t *pudp)
 364 {
 365         pud_t old;
 366
 367         old = *pudp;
 368         if (pud_val(old) & _REGION_ENTRY_INVALID)
 369                 return old;
 370         if (!MACHINE_HAS_IDTE) {
 371                 /*
 372                  * Invalid bit position is the same for pmd and pud, so we can
 373                  * re-use _pmd_csp() here
 374                  */
 375                 __pmdp_csp((pmd_t *) pudp);
 376                 return old;
 377         }
 378         atomic_inc(&mm->context.flush_count);
 379         if (MACHINE_HAS_TLB_LC &&
 380             cpumask_equal(mm_cpumask(mm), cpumask_of(smp_processor_id())))
 381                 __pudp_idte(addr, pudp, IDTE_LOCAL);
 382         else
 383                 __pudp_idte(addr, pudp, IDTE_GLOBAL);
 384         atomic_dec(&mm->context.flush_count);
 385         return old;
 386 }
 387
 388 pud_t pudp_xchg_direct(struct mm_struct *mm, unsigned long addr,
 389                        pud_t *pudp, pud_t new)
 390 {
 391         pud_t old;
 392
 393         preempt_disable();
 394         old = pudp_flush_direct(mm, addr, pudp);
 395         *pudp = new;
 396         preempt_enable();
 397         return old;
 398 }
 399 EXPORT_SYMBOL(pudp_xchg_direct);
 400
 401 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 402 void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
 403                                 pgtable_t pgtable)
 404 {
 405         struct list_head *lh = (struct list_head *) pgtable;
 406
 407         assert_spin_locked(pmd_lockptr(mm, pmdp));
 408
 409         /* FIFO */
 410         if (!pmd_huge_pte(mm, pmdp))
 411                 INIT_LIST_HEAD(lh);
 412         else
 413                 list_add(lh, (struct list_head *) pmd_huge_pte(mm, pmdp));
 414         pmd_huge_pte(mm, pmdp) = pgtable;
 415 }
 416
 417 pgtable_t pgtable_trans_huge_withdraw(struct mm_struct *mm, pmd_t *pmdp)
 418 {
 419         struct list_head *lh;
 420         pgtable_t pgtable;
 421         pte_t *ptep;
 422
 423         assert_spin_locked(pmd_lockptr(mm, pmdp));
 424
 425         /* FIFO */
 426         pgtable = pmd_huge_pte(mm, pmdp);
 427         lh = (struct list_head *) pgtable;
 428         if (list_empty(lh))
 429                 pmd_huge_pte(mm, pmdp) = NULL;
 430         else {
 431                 pmd_huge_pte(mm, pmdp) = (pgtable_t) lh->next;
 432                 list_del(lh);
 433         }
 434         ptep = (pte_t *) pgtable;
 435         pte_val(*ptep) = _PAGE_INVALID;
 436         ptep++;
 437         pte_val(*ptep) = _PAGE_INVALID;
 438         return pgtable;
 439 }
 440 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
 441
 442 #ifdef CONFIG_PGSTE
 443 void ptep_set_pte_at(struct mm_struct *mm, unsigned long addr,
 444                      pte_t *ptep, pte_t entry)
 445 {
 446         pgste_t pgste;
 447
 448         /* the mm_has_pgste() check is done in set_pte_at() */
 449         preempt_disable();
 450         pgste = pgste_get_lock(ptep);
 451         pgste_val(pgste) &= ~_PGSTE_GPS_ZERO;
 452         pgste_set_key(ptep, pgste, entry, mm);
 453         pgste = pgste_set_pte(ptep, pgste, entry);
 454         pgste_set_unlock(ptep, pgste);
 455         preempt_enable();
 456 }
 457
 458 void ptep_set_notify(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 459 {
 460         pgste_t pgste;
 461
 462         preempt_disable();
 463         pgste = pgste_get_lock(ptep);
 464         pgste_val(pgste) |= PGSTE_IN_BIT;
 465         pgste_set_unlock(ptep, pgste);
 466         preempt_enable();
 467 }
 468
 469 /**
 470  * ptep_force_prot - change access rights of a locked pte
 471  * @mm: pointer to the process mm_struct
 472  * @addr: virtual address in the guest address space
 473  * @ptep: pointer to the page table entry
 474  * @prot: indicates guest access rights: PROT_NONE, PROT_READ or PROT_WRITE
 475  * @bit: pgste bit to set (e.g. for notification)
 476  *
 477  * Returns 0 if the access rights were changed and -EAGAIN if the current
 478  * and requested access rights are incompatible.
 479  */
 480 int ptep_force_prot(struct mm_struct *mm, unsigned long addr,
 481                     pte_t *ptep, int prot, unsigned long bit)
 482 {
 483         pte_t entry;
 484         pgste_t pgste;
 485         int pte_i, pte_p;
 486
 487         pgste = pgste_get_lock(ptep);
 488         entry = *ptep;
 489         /* Check pte entry after all locks have been acquired */
 490         pte_i = pte_val(entry) & _PAGE_INVALID;
 491         pte_p = pte_val(entry) & _PAGE_PROTECT;
 492         if ((pte_i && (prot != PROT_NONE)) ||
 493             (pte_p && (prot & PROT_WRITE))) {
 494                 pgste_set_unlock(ptep, pgste);
 495                 return -EAGAIN;
 496         }
 497         /* Change access rights and set pgste bit */
 498         if (prot == PROT_NONE && !pte_i) {
 499                 ptep_flush_direct(mm, addr, ptep);
 500                 pgste = pgste_update_all(entry, pgste, mm);
 501                 pte_val(entry) |= _PAGE_INVALID;
 502         }
 503         if (prot == PROT_READ && !pte_p) {
 504                 ptep_flush_direct(mm, addr, ptep);
 505                 pte_val(entry) &= ~_PAGE_INVALID;
 506                 pte_val(entry) |= _PAGE_PROTECT;
 507         }
 508         pgste_val(pgste) |= bit;
 509         pgste = pgste_set_pte(ptep, pgste, entry);
 510         pgste_set_unlock(ptep, pgste);
 511         return 0;
 512 }
 513
 514 int ptep_shadow_pte(struct mm_struct *mm, unsigned long saddr,
 515                     pte_t *sptep, pte_t *tptep, pte_t pte)
 516 {
 517         pgste_t spgste, tpgste;
 518         pte_t spte, tpte;
 519         int rc = -EAGAIN;
 520
 521         if (!(pte_val(*tptep) & _PAGE_INVALID))
 522                 return 0;       /* already shadowed */
 523         spgste = pgste_get_lock(sptep);
 524         spte = *sptep;
 525         if (!(pte_val(spte) & _PAGE_INVALID) &&
 526             !((pte_val(spte) & _PAGE_PROTECT) &&
 527               !(pte_val(pte) & _PAGE_PROTECT))) {
 528                 pgste_val(spgste) |= PGSTE_VSIE_BIT;
 529                 tpgste = pgste_get_lock(tptep);
 530                 pte_val(tpte) = (pte_val(spte) & PAGE_MASK) |
 531                                 (pte_val(pte) & _PAGE_PROTECT);
 532                 /* don't touch the storage key - it belongs to parent pgste */
 533                 tpgste = pgste_set_pte(tptep, tpgste, tpte);
 534                 pgste_set_unlock(tptep, tpgste);
 535                 rc = 1;
 536         }
 537         pgste_set_unlock(sptep, spgste);
 538         return rc;
 539 }
 540
 541 void ptep_unshadow_pte(struct mm_struct *mm, unsigned long saddr, pte_t *ptep)
 542 {
 543         pgste_t pgste;
 544
 545         pgste = pgste_get_lock(ptep);
 546         /* notifier is called by the caller */
 547         ptep_flush_direct(mm, saddr, ptep);
 548         /* don't touch the storage key - it belongs to parent pgste */
 549         pgste = pgste_set_pte(ptep, pgste, __pte(_PAGE_INVALID));
 550         pgste_set_unlock(ptep, pgste);
 551 }
 552
 553 static void ptep_zap_swap_entry(struct mm_struct *mm, swp_entry_t entry)
 554 {
 555         if (!non_swap_entry(entry))
 556                 dec_mm_counter(mm, MM_SWAPENTS);
 557         else if (is_migration_entry(entry)) {
 558                 struct page *page = migration_entry_to_page(entry);
 559
 560                 dec_mm_counter(mm, mm_counter(page));
 561         }
 562         free_swap_and_cache(entry);
 563 }
 564
 565 void ptep_zap_unused(struct mm_struct *mm, unsigned long addr,
 566                      pte_t *ptep, int reset)
 567 {
 568         unsigned long pgstev;
 569         pgste_t pgste;
 570         pte_t pte;
 571
 572         /* Zap unused and logically-zero pages */
 573         preempt_disable();
 574         pgste = pgste_get_lock(ptep);
 575         pgstev = pgste_val(pgste);
 576         pte = *ptep;
 577         if (!reset && pte_swap(pte) &&
 578             ((pgstev & _PGSTE_GPS_USAGE_MASK) == _PGSTE_GPS_USAGE_UNUSED ||
 579              (pgstev & _PGSTE_GPS_ZERO))) {
 580                 ptep_zap_swap_entry(mm, pte_to_swp_entry(pte));
 581                 pte_clear(mm, addr, ptep);
 582         }
 583         if (reset)
 584                 pgste_val(pgste) &= ~_PGSTE_GPS_USAGE_MASK;
 585         pgste_set_unlock(ptep, pgste);
 586         preempt_enable();
 587 }
 588
 589 void ptep_zap_key(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 590 {
 591         unsigned long ptev;
 592         pgste_t pgste;
 593
 594         /* Clear storage key ACC and F, but set R/C */
 595         preempt_disable();
 596         pgste = pgste_get_lock(ptep);
 597         pgste_val(pgste) &= ~(PGSTE_ACC_BITS | PGSTE_FP_BIT);
 598         pgste_val(pgste) |= PGSTE_GR_BIT | PGSTE_GC_BIT;
 599         ptev = pte_val(*ptep);
 600         if (!(ptev & _PAGE_INVALID) && (ptev & _PAGE_WRITE))
 601                 page_set_storage_key(ptev & PAGE_MASK, PAGE_DEFAULT_KEY, 1);
 602         pgste_set_unlock(ptep, pgste);
 603         preempt_enable();
 604 }
 605
 606 /*
 607  * Test and reset if a guest page is dirty
 608  */
 609 bool test_and_clear_guest_dirty(struct mm_struct *mm, unsigned long addr)
 610 {
 611         spinlock_t *ptl;
 612         pgd_t *pgd;
 613         p4d_t *p4d;
 614         pud_t *pud;
 615         pmd_t *pmd;
 616         pgste_t pgste;
 617         pte_t *ptep;
 618         pte_t pte;
 619         bool dirty;
 620
 621         pgd = pgd_offset(mm, addr);
 622         p4d = p4d_alloc(mm, pgd, addr);
 623         if (!p4d)
 624                 return false;
 625         pud = pud_alloc(mm, p4d, addr);
 626         if (!pud)
 627                 return false;
 628         pmd = pmd_alloc(mm, pud, addr);
 629         if (!pmd)
 630                 return false;
 631         /* We can't run guests backed by huge pages, but userspace can
 632          * still set them up and then try to migrate them without any
 633          * migration support.
 634          */
 635         if (pmd_large(*pmd))
 636                 return true;
 637
 638         ptep = pte_alloc_map_lock(mm, pmd, addr, &ptl);
 639         if (unlikely(!ptep))
 640                 return false;
 641
 642         pgste = pgste_get_lock(ptep);
 643         dirty = !!(pgste_val(pgste) & PGSTE_UC_BIT);
 644         pgste_val(pgste) &= ~PGSTE_UC_BIT;
 645         pte = *ptep;
 646         if (dirty && (pte_val(pte) & _PAGE_PRESENT)) {
 647                 pgste = pgste_pte_notify(mm, addr, ptep, pgste);
 648                 __ptep_ipte(addr, ptep, IPTE_GLOBAL);
 649                 if (MACHINE_HAS_ESOP || !(pte_val(pte) & _PAGE_WRITE))
 650                         pte_val(pte) |= _PAGE_PROTECT;
 651                 else
 652                         pte_val(pte) |= _PAGE_INVALID;
 653                 *ptep = pte;
 654         }
 655         pgste_set_unlock(ptep, pgste);
 656
 657         spin_unlock(ptl);
 658         return dirty;
 659 }
 660 EXPORT_SYMBOL_GPL(test_and_clear_guest_dirty);
 661
 662 int set_guest_storage_key(struct mm_struct *mm, unsigned long addr,
 663                           unsigned char key, bool nq)
 664 {
 665         unsigned long keyul;
 666         spinlock_t *ptl;
 667         pgste_t old, new;
 668         pte_t *ptep;
 669
 670         ptep = get_locked_pte(mm, addr, &ptl);
 671         if (unlikely(!ptep))
 672                 return -EFAULT;
 673
 674         new = old = pgste_get_lock(ptep);
 675         pgste_val(new) &= ~(PGSTE_GR_BIT | PGSTE_GC_BIT |
 676                             PGSTE_ACC_BITS | PGSTE_FP_BIT);
 677         keyul = (unsigned long) key;
 678         pgste_val(new) |= (keyul & (_PAGE_CHANGED | _PAGE_REFERENCED)) << 48;
 679         pgste_val(new) |= (keyul & (_PAGE_ACC_BITS | _PAGE_FP_BIT)) << 56;
 680         if (!(pte_val(*ptep) & _PAGE_INVALID)) {
 681                 unsigned long address, bits, skey;
 682
 683                 address = pte_val(*ptep) & PAGE_MASK;
 684                 skey = (unsigned long) page_get_storage_key(address);
 685                 bits = skey & (_PAGE_CHANGED | _PAGE_REFERENCED);
 686                 skey = key & (_PAGE_ACC_BITS | _PAGE_FP_BIT);
 687                 /* Set storage key ACC and FP */
 688                 page_set_storage_key(address, skey, !nq);
 689                 /* Merge host changed & referenced into pgste  */
 690                 pgste_val(new) |= bits << 52;
 691         }
 692         /* changing the guest storage key is considered a change of the page */
 693         if ((pgste_val(new) ^ pgste_val(old)) &
 694             (PGSTE_ACC_BITS | PGSTE_FP_BIT | PGSTE_GR_BIT | PGSTE_GC_BIT))
 695                 pgste_val(new) |= PGSTE_UC_BIT;
 696
 697         pgste_set_unlock(ptep, new);
 698         pte_unmap_unlock(ptep, ptl);
 699         return 0;
 700 }
 701 EXPORT_SYMBOL(set_guest_storage_key);
 702
 703 /**
 704  * Conditionally set a guest storage key (handling csske).
 705  * oldkey will be updated when either mr or mc is set and a pointer is given.
 706  *
 707  * Returns 0 if a guests storage key update wasn't necessary, 1 if the guest
 708  * storage key was updated and -EFAULT on access errors.
 709  */
 710 int cond_set_guest_storage_key(struct mm_struct *mm, unsigned long addr,
 711                                unsigned char key, unsigned char *oldkey,
 712                                bool nq, bool mr, bool mc)
 713 {
 714         unsigned char tmp, mask = _PAGE_ACC_BITS | _PAGE_FP_BIT;
 715         int rc;
 716
 717         /* we can drop the pgste lock between getting and setting the key */
 718         if (mr | mc) {
 719                 rc = get_guest_storage_key(current->mm, addr, &tmp);
 720                 if (rc)
 721                         return rc;
 722                 if (oldkey)
 723                         *oldkey = tmp;
 724                 if (!mr)
 725                         mask |= _PAGE_REFERENCED;
 726                 if (!mc)
 727                         mask |= _PAGE_CHANGED;
 728                 if (!((tmp ^ key) & mask))
 729                         return 0;
 730         }
 731         rc = set_guest_storage_key(current->mm, addr, key, nq);
 732         return rc < 0 ? rc : 1;
 733 }
 734 EXPORT_SYMBOL(cond_set_guest_storage_key);
 735
 736 /**
 737  * Reset a guest reference bit (rrbe), returning the reference and changed bit.
 738  *
 739  * Returns < 0 in case of error, otherwise the cc to be reported to the guest.
 740  */
 741 int reset_guest_reference_bit(struct mm_struct *mm, unsigned long addr)
 742 {
 743         spinlock_t *ptl;
 744         pgste_t old, new;
 745         pte_t *ptep;
 746         int cc = 0;
 747
 748         ptep = get_locked_pte(mm, addr, &ptl);
 749         if (unlikely(!ptep))
 750                 return -EFAULT;
 751
 752         new = old = pgste_get_lock(ptep);
 753         /* Reset guest reference bit only */
 754         pgste_val(new) &= ~PGSTE_GR_BIT;
 755
 756         if (!(pte_val(*ptep) & _PAGE_INVALID)) {
 757                 cc = page_reset_referenced(pte_val(*ptep) & PAGE_MASK);
 758                 /* Merge real referenced bit into host-set */
 759                 pgste_val(new) |= ((unsigned long) cc << 53) & PGSTE_HR_BIT;
 760         }
 761         /* Reflect guest's logical view, not physical */
 762         cc |= (pgste_val(old) & (PGSTE_GR_BIT | PGSTE_GC_BIT)) >> 49;
 763         /* Changing the guest storage key is considered a change of the page */
 764         if ((pgste_val(new) ^ pgste_val(old)) & PGSTE_GR_BIT)
 765                 pgste_val(new) |= PGSTE_UC_BIT;
 766
 767         pgste_set_unlock(ptep, new);
 768         pte_unmap_unlock(ptep, ptl);
 769         return cc;
 770 }
 771 EXPORT_SYMBOL(reset_guest_reference_bit);
 772
 773 int get_guest_storage_key(struct mm_struct *mm, unsigned long addr,
 774                           unsigned char *key)
 775 {
 776         spinlock_t *ptl;
 777         pgste_t pgste;
 778         pte_t *ptep;
 779
 780         ptep = get_locked_pte(mm, addr, &ptl);
 781         if (unlikely(!ptep))
 782                 return -EFAULT;
 783
 784         pgste = pgste_get_lock(ptep);
 785         *key = (pgste_val(pgste) & (PGSTE_ACC_BITS | PGSTE_FP_BIT)) >> 56;
 786         if (!(pte_val(*ptep) & _PAGE_INVALID))
 787                 *key = page_get_storage_key(pte_val(*ptep) & PAGE_MASK);
 788         /* Reflect guest's logical view, not physical */
 789         *key |= (pgste_val(pgste) & (PGSTE_GR_BIT | PGSTE_GC_BIT)) >> 48;
 790         pgste_set_unlock(ptep, pgste);
 791         pte_unmap_unlock(ptep, ptl);
 792         return 0;
 793 }
 794 EXPORT_SYMBOL(get_guest_storage_key);
 795
 796 /**
 797  * pgste_perform_essa - perform ESSA actions on the PGSTE.
 798  * @mm: the memory context. It must have PGSTEs, no check is performed here!
 799  * @hva: the host virtual address of the page whose PGSTE is to be processed
 800  * @orc: the specific action to perform, see the ESSA_SET_* macros.
 801  * @oldpte: the PTE will be saved there if the pointer is not NULL.
 802  * @oldpgste: the old PGSTE will be saved there if the pointer is not NULL.
 803  *
 804  * Return: 1 if the page is to be added to the CBRL, otherwise 0,
 805  *         or < 0 in case of error. -EINVAL is returned for invalid values
 806  *         of orc, -EFAULT for invalid addresses.
 807  */
 808 int pgste_perform_essa(struct mm_struct *mm, unsigned long hva, int orc,
 809                         unsigned long *oldpte, unsigned long *oldpgste)
 810 {
 811         unsigned long pgstev;
 812         spinlock_t *ptl;
 813         pgste_t pgste;
 814         pte_t *ptep;
 815         int res = 0;
 816
 817         WARN_ON_ONCE(orc > ESSA_MAX);
 818         if (unlikely(orc > ESSA_MAX))
 819                 return -EINVAL;
 820         ptep = get_locked_pte(mm, hva, &ptl);
 821         if (unlikely(!ptep))
 822                 return -EFAULT;
 823         pgste = pgste_get_lock(ptep);
 824         pgstev = pgste_val(pgste);
 825         if (oldpte)
 826                 *oldpte = pte_val(*ptep);
 827         if (oldpgste)
 828                 *oldpgste = pgstev;
 829
 830         switch (orc) {
 831         case ESSA_GET_STATE:
 832                 break;
 833         case ESSA_SET_STABLE:
 834                 pgstev &= ~_PGSTE_GPS_USAGE_MASK;
 835                 pgstev |= _PGSTE_GPS_USAGE_STABLE;
 836                 break;
 837         case ESSA_SET_UNUSED:
 838                 pgstev &= ~_PGSTE_GPS_USAGE_MASK;
 839                 pgstev |= _PGSTE_GPS_USAGE_UNUSED;
 840                 if (pte_val(*ptep) & _PAGE_INVALID)
 841                         res = 1;
 842                 break;
 843         case ESSA_SET_VOLATILE:
 844                 pgstev &= ~_PGSTE_GPS_USAGE_MASK;
 845                 pgstev |= _PGSTE_GPS_USAGE_VOLATILE;
 846                 if (pte_val(*ptep) & _PAGE_INVALID)
 847                         res = 1;
 848                 break;
 849         case ESSA_SET_POT_VOLATILE:
 850                 pgstev &= ~_PGSTE_GPS_USAGE_MASK;
 851                 if (!(pte_val(*ptep) & _PAGE_INVALID)) {
 852                         pgstev |= _PGSTE_GPS_USAGE_POT_VOLATILE;
 853                         break;
 854                 }
 855                 if (pgstev & _PGSTE_GPS_ZERO) {
 856                         pgstev |= _PGSTE_GPS_USAGE_VOLATILE;
 857                         break;
 858                 }
 859                 if (!(pgstev & PGSTE_GC_BIT)) {
 860                         pgstev |= _PGSTE_GPS_USAGE_VOLATILE;
 861                         res = 1;
 862                         break;
 863                 }
 864                 break;
 865         case ESSA_SET_STABLE_RESIDENT:
 866                 pgstev &= ~_PGSTE_GPS_USAGE_MASK;
 867                 pgstev |= _PGSTE_GPS_USAGE_STABLE;
 868                 /*
 869                  * Since the resident state can go away any time after this
 870                  * call, we will not make this page resident. We can revisit
 871                  * this decision if a guest will ever start using this.
 872                  */
 873                 break;
 874         case ESSA_SET_STABLE_IF_RESIDENT:
 875                 if (!(pte_val(*ptep) & _PAGE_INVALID)) {
 876                         pgstev &= ~_PGSTE_GPS_USAGE_MASK;
 877                         pgstev |= _PGSTE_GPS_USAGE_STABLE;
 878                 }
 879                 break;
 880         default:
 881                 /* we should never get here! */
 882                 break;
 883         }
 884         /* If we are discarding a page, set it to logical zero */
 885         if (res)
 886                 pgstev |= _PGSTE_GPS_ZERO;
 887
 888         pgste_val(pgste) = pgstev;
 889         pgste_set_unlock(ptep, pgste);
 890         pte_unmap_unlock(ptep, ptl);
 891         return res;
 892 }
 893 EXPORT_SYMBOL(pgste_perform_essa);
 894
 895 /**
 896  * set_pgste_bits - set specific PGSTE bits.
 897  * @mm: the memory context. It must have PGSTEs, no check is performed here!
 898  * @hva: the host virtual address of the page whose PGSTE is to be processed
 899  * @bits: a bitmask representing the bits that will be touched
 900  * @value: the values of the bits to be written. Only the bits in the mask
 901  *         will be written.
 902  *
 903  * Return: 0 on success, < 0 in case of error.
 904  */
 905 int set_pgste_bits(struct mm_struct *mm, unsigned long hva,
 906                         unsigned long bits, unsigned long value)
 907 {
 908         spinlock_t *ptl;
 909         pgste_t new;
 910         pte_t *ptep;
 911
 912         ptep = get_locked_pte(mm, hva, &ptl);
 913         if (unlikely(!ptep))
 914                 return -EFAULT;
 915         new = pgste_get_lock(ptep);
 916
 917         pgste_val(new) &= ~bits;
 918         pgste_val(new) |= value & bits;
 919
 920         pgste_set_unlock(ptep, new);
 921         pte_unmap_unlock(ptep, ptl);
 922         return 0;
 923 }
 924 EXPORT_SYMBOL(set_pgste_bits);
 925
 926 /**
 927  * get_pgste - get the current PGSTE for the given address.
 928  * @mm: the memory context. It must have PGSTEs, no check is performed here!
 929  * @hva: the host virtual address of the page whose PGSTE is to be processed
 930  * @pgstep: will be written with the current PGSTE for the given address.
 931  *
 932  * Return: 0 on success, < 0 in case of error.
 933  */
 934 int get_pgste(struct mm_struct *mm, unsigned long hva, unsigned long *pgstep)
 935 {
 936         spinlock_t *ptl;
 937         pte_t *ptep;
 938
 939         ptep = get_locked_pte(mm, hva, &ptl);
 940         if (unlikely(!ptep))
 941                 return -EFAULT;
 942         *pgstep = pgste_val(pgste_get(ptep));
 943         pte_unmap_unlock(ptep, ptl);
 944         return 0;
 945 }
 946 EXPORT_SYMBOL(get_pgste);
 947 #endif