arch/s390/mm/pgtable.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *    Copyright IBM Corp. 2007, 2011
   4  *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
   5  */
   6
   7 #include <linux/sched.h>
   8 #include <linux/kernel.h>
   9 #include <linux/errno.h>
  10 #include <linux/gfp.h>
  11 #include <linux/mm.h>
  12 #include <linux/swap.h>
  13 #include <linux/smp.h>
  14 #include <linux/spinlock.h>
  15 #include <linux/rcupdate.h>
  16 #include <linux/slab.h>
  17 #include <linux/swapops.h>
  18 #include <linux/sysctl.h>
  19 #include <linux/ksm.h>
  20 #include <linux/mman.h>
  21
  22 #include <asm/tlb.h>
  23 #include <asm/tlbflush.h>
  24 #include <asm/mmu_context.h>
  25 #include <asm/page-states.h>
  26
  27 pgprot_t pgprot_writecombine(pgprot_t prot)
  28 {
  29         /*
  30          * mio_wb_bit_mask may be set on a different CPU, but it is only set
  31          * once at init and only read afterwards.
  32          */
  33         return __pgprot(pgprot_val(prot) | mio_wb_bit_mask);
  34 }
  35 EXPORT_SYMBOL_GPL(pgprot_writecombine);
  36
  37 pgprot_t pgprot_writethrough(pgprot_t prot)
  38 {
  39         /*
  40          * mio_wb_bit_mask may be set on a different CPU, but it is only set
  41          * once at init and only read afterwards.
  42          */
  43         return __pgprot(pgprot_val(prot) & ~mio_wb_bit_mask);
  44 }
  45 EXPORT_SYMBOL_GPL(pgprot_writethrough);
  46
  47 static inline void ptep_ipte_local(struct mm_struct *mm, unsigned long addr,
  48                                    pte_t *ptep, int nodat)
  49 {
  50         unsigned long opt, asce;
  51
  52         if (MACHINE_HAS_TLB_GUEST) {
  53                 opt = 0;
  54                 asce = READ_ONCE(mm->context.gmap_asce);
  55                 if (asce == 0UL || nodat)
  56                         opt |= IPTE_NODAT;
  57                 if (asce != -1UL) {
  58                         asce = asce ? : mm->context.asce;
  59                         opt |= IPTE_GUEST_ASCE;
  60                 }
  61                 __ptep_ipte(addr, ptep, opt, asce, IPTE_LOCAL);
  62         } else {
  63                 __ptep_ipte(addr, ptep, 0, 0, IPTE_LOCAL);
  64         }
  65 }
  66
  67 static inline void ptep_ipte_global(struct mm_struct *mm, unsigned long addr,
  68                                     pte_t *ptep, int nodat)
  69 {
  70         unsigned long opt, asce;
  71
  72         if (MACHINE_HAS_TLB_GUEST) {
  73                 opt = 0;
  74                 asce = READ_ONCE(mm->context.gmap_asce);
  75                 if (asce == 0UL || nodat)
  76                         opt |= IPTE_NODAT;
  77                 if (asce != -1UL) {
  78                         asce = asce ? : mm->context.asce;
  79                         opt |= IPTE_GUEST_ASCE;
  80                 }
  81                 __ptep_ipte(addr, ptep, opt, asce, IPTE_GLOBAL);
  82         } else {
  83                 __ptep_ipte(addr, ptep, 0, 0, IPTE_GLOBAL);
  84         }
  85 }
  86
  87 static inline pte_t ptep_flush_direct(struct mm_struct *mm,
  88                                       unsigned long addr, pte_t *ptep,
  89                                       int nodat)
  90 {
  91         pte_t old;
  92
  93         old = *ptep;
  94         if (unlikely(pte_val(old) & _PAGE_INVALID))
  95                 return old;
  96         atomic_inc(&mm->context.flush_count);
  97         if (MACHINE_HAS_TLB_LC &&
  98             cpumask_equal(mm_cpumask(mm), cpumask_of(smp_processor_id())))
  99                 ptep_ipte_local(mm, addr, ptep, nodat);
 100         else
 101                 ptep_ipte_global(mm, addr, ptep, nodat);
 102         atomic_dec(&mm->context.flush_count);
 103         return old;
 104 }
 105
 106 static inline pte_t ptep_flush_lazy(struct mm_struct *mm,
 107                                     unsigned long addr, pte_t *ptep,
 108                                     int nodat)
 109 {
 110         pte_t old;
 111
 112         old = *ptep;
 113         if (unlikely(pte_val(old) & _PAGE_INVALID))
 114                 return old;
 115         atomic_inc(&mm->context.flush_count);
 116         if (cpumask_equal(&mm->context.cpu_attach_mask,
 117                           cpumask_of(smp_processor_id()))) {
 118                 set_pte(ptep, set_pte_bit(*ptep, __pgprot(_PAGE_INVALID)));
 119                 mm->context.flush_mm = 1;
 120         } else
 121                 ptep_ipte_global(mm, addr, ptep, nodat);
 122         atomic_dec(&mm->context.flush_count);
 123         return old;
 124 }
 125
 126 static inline pgste_t pgste_get_lock(pte_t *ptep)
 127 {
 128         unsigned long new = 0;
 129 #ifdef CONFIG_PGSTE
 130         unsigned long old;
 131
 132         asm(
 133                 "       lg      %0,%2\n"
 134                 "0:     lgr     %1,%0\n"
 135                 "       nihh    %0,0xff7f\n"    /* clear PCL bit in old */
 136                 "       oihh    %1,0x0080\n"    /* set PCL bit in new */
 137                 "       csg     %0,%1,%2\n"
 138                 "       jl      0b\n"
 139                 : "=&d" (old), "=&d" (new), "=Q" (ptep[PTRS_PER_PTE])
 140                 : "Q" (ptep[PTRS_PER_PTE]) : "cc", "memory");
 141 #endif
 142         return __pgste(new);
 143 }
 144
 145 static inline void pgste_set_unlock(pte_t *ptep, pgste_t pgste)
 146 {
 147 #ifdef CONFIG_PGSTE
 148         asm(
 149                 "       nihh    %1,0xff7f\n"    /* clear PCL bit */
 150                 "       stg     %1,%0\n"
 151                 : "=Q" (ptep[PTRS_PER_PTE])
 152                 : "d" (pgste_val(pgste)), "Q" (ptep[PTRS_PER_PTE])
 153                 : "cc", "memory");
 154 #endif
 155 }
 156
 157 static inline pgste_t pgste_get(pte_t *ptep)
 158 {
 159         unsigned long pgste = 0;
 160 #ifdef CONFIG_PGSTE
 161         pgste = *(unsigned long *)(ptep + PTRS_PER_PTE);
 162 #endif
 163         return __pgste(pgste);
 164 }
 165
 166 static inline void pgste_set(pte_t *ptep, pgste_t pgste)
 167 {
 168 #ifdef CONFIG_PGSTE
 169         *(pgste_t *)(ptep + PTRS_PER_PTE) = pgste;
 170 #endif
 171 }
 172
 173 static inline pgste_t pgste_update_all(pte_t pte, pgste_t pgste,
 174                                        struct mm_struct *mm)
 175 {
 176 #ifdef CONFIG_PGSTE
 177         unsigned long address, bits, skey;
 178
 179         if (!mm_uses_skeys(mm) || pte_val(pte) & _PAGE_INVALID)
 180                 return pgste;
 181         address = pte_val(pte) & PAGE_MASK;
 182         skey = (unsigned long) page_get_storage_key(address);
 183         bits = skey & (_PAGE_CHANGED | _PAGE_REFERENCED);
 184         /* Transfer page changed & referenced bit to guest bits in pgste */
 185         pgste_val(pgste) |= bits << 48;         /* GR bit & GC bit */
 186         /* Copy page access key and fetch protection bit to pgste */
 187         pgste_val(pgste) &= ~(PGSTE_ACC_BITS | PGSTE_FP_BIT);
 188         pgste_val(pgste) |= (skey & (_PAGE_ACC_BITS | _PAGE_FP_BIT)) << 56;
 189 #endif
 190         return pgste;
 191
 192 }
 193
 194 static inline void pgste_set_key(pte_t *ptep, pgste_t pgste, pte_t entry,
 195                                  struct mm_struct *mm)
 196 {
 197 #ifdef CONFIG_PGSTE
 198         unsigned long address;
 199         unsigned long nkey;
 200
 201         if (!mm_uses_skeys(mm) || pte_val(entry) & _PAGE_INVALID)
 202                 return;
 203         VM_BUG_ON(!(pte_val(*ptep) & _PAGE_INVALID));
 204         address = pte_val(entry) & PAGE_MASK;
 205         /*
 206          * Set page access key and fetch protection bit from pgste.
 207          * The guest C/R information is still in the PGSTE, set real
 208          * key C/R to 0.
 209          */
 210         nkey = (pgste_val(pgste) & (PGSTE_ACC_BITS | PGSTE_FP_BIT)) >> 56;
 211         nkey |= (pgste_val(pgste) & (PGSTE_GR_BIT | PGSTE_GC_BIT)) >> 48;
 212         page_set_storage_key(address, nkey, 0);
 213 #endif
 214 }
 215
 216 static inline pgste_t pgste_set_pte(pte_t *ptep, pgste_t pgste, pte_t entry)
 217 {
 218 #ifdef CONFIG_PGSTE
 219         if ((pte_val(entry) & _PAGE_PRESENT) &&
 220             (pte_val(entry) & _PAGE_WRITE) &&
 221             !(pte_val(entry) & _PAGE_INVALID)) {
 222                 if (!MACHINE_HAS_ESOP) {
 223                         /*
 224                          * Without enhanced suppression-on-protection force
 225                          * the dirty bit on for all writable ptes.
 226                          */
 227                         entry = set_pte_bit(entry, __pgprot(_PAGE_DIRTY));
 228                         entry = clear_pte_bit(entry, __pgprot(_PAGE_PROTECT));
 229                 }
 230                 if (!(pte_val(entry) & _PAGE_PROTECT))
 231                         /* This pte allows write access, set user-dirty */
 232                         pgste_val(pgste) |= PGSTE_UC_BIT;
 233         }
 234 #endif
 235         set_pte(ptep, entry);
 236         return pgste;
 237 }
 238
 239 static inline pgste_t pgste_pte_notify(struct mm_struct *mm,
 240                                        unsigned long addr,
 241                                        pte_t *ptep, pgste_t pgste)
 242 {
 243 #ifdef CONFIG_PGSTE
 244         unsigned long bits;
 245
 246         bits = pgste_val(pgste) & (PGSTE_IN_BIT | PGSTE_VSIE_BIT);
 247         if (bits) {
 248                 pgste_val(pgste) ^= bits;
 249                 ptep_notify(mm, addr, ptep, bits);
 250         }
 251 #endif
 252         return pgste;
 253 }
 254
 255 static inline pgste_t ptep_xchg_start(struct mm_struct *mm,
 256                                       unsigned long addr, pte_t *ptep)
 257 {
 258         pgste_t pgste = __pgste(0);
 259
 260         if (mm_has_pgste(mm)) {
 261                 pgste = pgste_get_lock(ptep);
 262                 pgste = pgste_pte_notify(mm, addr, ptep, pgste);
 263         }
 264         return pgste;
 265 }
 266
 267 static inline pte_t ptep_xchg_commit(struct mm_struct *mm,
 268                                     unsigned long addr, pte_t *ptep,
 269                                     pgste_t pgste, pte_t old, pte_t new)
 270 {
 271         if (mm_has_pgste(mm)) {
 272                 if (pte_val(old) & _PAGE_INVALID)
 273                         pgste_set_key(ptep, pgste, new, mm);
 274                 if (pte_val(new) & _PAGE_INVALID) {
 275                         pgste = pgste_update_all(old, pgste, mm);
 276                         if ((pgste_val(pgste) & _PGSTE_GPS_USAGE_MASK) ==
 277                             _PGSTE_GPS_USAGE_UNUSED)
 278                                 old = set_pte_bit(old, __pgprot(_PAGE_UNUSED));
 279                 }
 280                 pgste = pgste_set_pte(ptep, pgste, new);
 281                 pgste_set_unlock(ptep, pgste);
 282         } else {
 283                 set_pte(ptep, new);
 284         }
 285         return old;
 286 }
 287
 288 pte_t ptep_xchg_direct(struct mm_struct *mm, unsigned long addr,
 289                        pte_t *ptep, pte_t new)
 290 {
 291         pgste_t pgste;
 292         pte_t old;
 293         int nodat;
 294
 295         preempt_disable();
 296         pgste = ptep_xchg_start(mm, addr, ptep);
 297         nodat = !!(pgste_val(pgste) & _PGSTE_GPS_NODAT);
 298         old = ptep_flush_direct(mm, addr, ptep, nodat);
 299         old = ptep_xchg_commit(mm, addr, ptep, pgste, old, new);
 300         preempt_enable();
 301         return old;
 302 }
 303 EXPORT_SYMBOL(ptep_xchg_direct);
 304
 305 /*
 306  * Caller must check that new PTE only differs in _PAGE_PROTECT HW bit, so that
 307  * RDP can be used instead of IPTE. See also comments at pte_allow_rdp().
 308  */
 309 void ptep_reset_dat_prot(struct mm_struct *mm, unsigned long addr, pte_t *ptep,
 310                          pte_t new)
 311 {
 312         preempt_disable();
 313         atomic_inc(&mm->context.flush_count);
 314         if (cpumask_equal(mm_cpumask(mm), cpumask_of(smp_processor_id())))
 315                 __ptep_rdp(addr, ptep, 0, 0, 1);
 316         else
 317                 __ptep_rdp(addr, ptep, 0, 0, 0);
 318         /*
 319          * PTE is not invalidated by RDP, only _PAGE_PROTECT is cleared. That
 320          * means it is still valid and active, and must not be changed according
 321          * to the architecture. But writing a new value that only differs in SW
 322          * bits is allowed.
 323          */
 324         set_pte(ptep, new);
 325         atomic_dec(&mm->context.flush_count);
 326         preempt_enable();
 327 }
 328 EXPORT_SYMBOL(ptep_reset_dat_prot);
 329
 330 pte_t ptep_xchg_lazy(struct mm_struct *mm, unsigned long addr,
 331                      pte_t *ptep, pte_t new)
 332 {
 333         pgste_t pgste;
 334         pte_t old;
 335         int nodat;
 336
 337         preempt_disable();
 338         pgste = ptep_xchg_start(mm, addr, ptep);
 339         nodat = !!(pgste_val(pgste) & _PGSTE_GPS_NODAT);
 340         old = ptep_flush_lazy(mm, addr, ptep, nodat);
 341         old = ptep_xchg_commit(mm, addr, ptep, pgste, old, new);
 342         preempt_enable();
 343         return old;
 344 }
 345 EXPORT_SYMBOL(ptep_xchg_lazy);
 346
 347 pte_t ptep_modify_prot_start(struct vm_area_struct *vma, unsigned long addr,
 348                              pte_t *ptep)
 349 {
 350         pgste_t pgste;
 351         pte_t old;
 352         int nodat;
 353         struct mm_struct *mm = vma->vm_mm;
 354
 355         preempt_disable();
 356         pgste = ptep_xchg_start(mm, addr, ptep);
 357         nodat = !!(pgste_val(pgste) & _PGSTE_GPS_NODAT);
 358         old = ptep_flush_lazy(mm, addr, ptep, nodat);
 359         if (mm_has_pgste(mm)) {
 360                 pgste = pgste_update_all(old, pgste, mm);
 361                 pgste_set(ptep, pgste);
 362         }
 363         return old;
 364 }
 365
 366 void ptep_modify_prot_commit(struct vm_area_struct *vma, unsigned long addr,
 367                              pte_t *ptep, pte_t old_pte, pte_t pte)
 368 {
 369         pgste_t pgste;
 370         struct mm_struct *mm = vma->vm_mm;
 371
 372         if (!MACHINE_HAS_NX)
 373                 pte = clear_pte_bit(pte, __pgprot(_PAGE_NOEXEC));
 374         if (mm_has_pgste(mm)) {
 375                 pgste = pgste_get(ptep);
 376                 pgste_set_key(ptep, pgste, pte, mm);
 377                 pgste = pgste_set_pte(ptep, pgste, pte);
 378                 pgste_set_unlock(ptep, pgste);
 379         } else {
 380                 set_pte(ptep, pte);
 381         }
 382         preempt_enable();
 383 }
 384
 385 static inline void pmdp_idte_local(struct mm_struct *mm,
 386                                    unsigned long addr, pmd_t *pmdp)
 387 {
 388         if (MACHINE_HAS_TLB_GUEST)
 389                 __pmdp_idte(addr, pmdp, IDTE_NODAT | IDTE_GUEST_ASCE,
 390                             mm->context.asce, IDTE_LOCAL);
 391         else
 392                 __pmdp_idte(addr, pmdp, 0, 0, IDTE_LOCAL);
 393         if (mm_has_pgste(mm) && mm->context.allow_gmap_hpage_1m)
 394                 gmap_pmdp_idte_local(mm, addr);
 395 }
 396
 397 static inline void pmdp_idte_global(struct mm_struct *mm,
 398                                     unsigned long addr, pmd_t *pmdp)
 399 {
 400         if (MACHINE_HAS_TLB_GUEST) {
 401                 __pmdp_idte(addr, pmdp, IDTE_NODAT | IDTE_GUEST_ASCE,
 402                             mm->context.asce, IDTE_GLOBAL);
 403                 if (mm_has_pgste(mm) && mm->context.allow_gmap_hpage_1m)
 404                         gmap_pmdp_idte_global(mm, addr);
 405         } else if (MACHINE_HAS_IDTE) {
 406                 __pmdp_idte(addr, pmdp, 0, 0, IDTE_GLOBAL);
 407                 if (mm_has_pgste(mm) && mm->context.allow_gmap_hpage_1m)
 408                         gmap_pmdp_idte_global(mm, addr);
 409         } else {
 410                 __pmdp_csp(pmdp);
 411                 if (mm_has_pgste(mm) && mm->context.allow_gmap_hpage_1m)
 412                         gmap_pmdp_csp(mm, addr);
 413         }
 414 }
 415
 416 static inline pmd_t pmdp_flush_direct(struct mm_struct *mm,
 417                                       unsigned long addr, pmd_t *pmdp)
 418 {
 419         pmd_t old;
 420
 421         old = *pmdp;
 422         if (pmd_val(old) & _SEGMENT_ENTRY_INVALID)
 423                 return old;
 424         atomic_inc(&mm->context.flush_count);
 425         if (MACHINE_HAS_TLB_LC &&
 426             cpumask_equal(mm_cpumask(mm), cpumask_of(smp_processor_id())))
 427                 pmdp_idte_local(mm, addr, pmdp);
 428         else
 429                 pmdp_idte_global(mm, addr, pmdp);
 430         atomic_dec(&mm->context.flush_count);
 431         return old;
 432 }
 433
 434 static inline pmd_t pmdp_flush_lazy(struct mm_struct *mm,
 435                                     unsigned long addr, pmd_t *pmdp)
 436 {
 437         pmd_t old;
 438
 439         old = *pmdp;
 440         if (pmd_val(old) & _SEGMENT_ENTRY_INVALID)
 441                 return old;
 442         atomic_inc(&mm->context.flush_count);
 443         if (cpumask_equal(&mm->context.cpu_attach_mask,
 444                           cpumask_of(smp_processor_id()))) {
 445                 set_pmd(pmdp, set_pmd_bit(*pmdp, __pgprot(_SEGMENT_ENTRY_INVALID)));
 446                 mm->context.flush_mm = 1;
 447                 if (mm_has_pgste(mm))
 448                         gmap_pmdp_invalidate(mm, addr);
 449         } else {
 450                 pmdp_idte_global(mm, addr, pmdp);
 451         }
 452         atomic_dec(&mm->context.flush_count);
 453         return old;
 454 }
 455
 456 #ifdef CONFIG_PGSTE
 457 static int pmd_lookup(struct mm_struct *mm, unsigned long addr, pmd_t **pmdp)
 458 {
 459         struct vm_area_struct *vma;
 460         pgd_t *pgd;
 461         p4d_t *p4d;
 462         pud_t *pud;
 463
 464         /* We need a valid VMA, otherwise this is clearly a fault. */
 465         vma = vma_lookup(mm, addr);
 466         if (!vma)
 467                 return -EFAULT;
 468
 469         pgd = pgd_offset(mm, addr);
 470         if (!pgd_present(*pgd))
 471                 return -ENOENT;
 472
 473         p4d = p4d_offset(pgd, addr);
 474         if (!p4d_present(*p4d))
 475                 return -ENOENT;
 476
 477         pud = pud_offset(p4d, addr);
 478         if (!pud_present(*pud))
 479                 return -ENOENT;
 480
 481         /* Large PUDs are not supported yet. */
 482         if (pud_large(*pud))
 483                 return -EFAULT;
 484
 485         *pmdp = pmd_offset(pud, addr);
 486         return 0;
 487 }
 488 #endif
 489
 490 pmd_t pmdp_xchg_direct(struct mm_struct *mm, unsigned long addr,
 491                        pmd_t *pmdp, pmd_t new)
 492 {
 493         pmd_t old;
 494
 495         preempt_disable();
 496         old = pmdp_flush_direct(mm, addr, pmdp);
 497         set_pmd(pmdp, new);
 498         preempt_enable();
 499         return old;
 500 }
 501 EXPORT_SYMBOL(pmdp_xchg_direct);
 502
 503 pmd_t pmdp_xchg_lazy(struct mm_struct *mm, unsigned long addr,
 504                      pmd_t *pmdp, pmd_t new)
 505 {
 506         pmd_t old;
 507
 508         preempt_disable();
 509         old = pmdp_flush_lazy(mm, addr, pmdp);
 510         set_pmd(pmdp, new);
 511         preempt_enable();
 512         return old;
 513 }
 514 EXPORT_SYMBOL(pmdp_xchg_lazy);
 515
 516 static inline void pudp_idte_local(struct mm_struct *mm,
 517                                    unsigned long addr, pud_t *pudp)
 518 {
 519         if (MACHINE_HAS_TLB_GUEST)
 520                 __pudp_idte(addr, pudp, IDTE_NODAT | IDTE_GUEST_ASCE,
 521                             mm->context.asce, IDTE_LOCAL);
 522         else
 523                 __pudp_idte(addr, pudp, 0, 0, IDTE_LOCAL);
 524 }
 525
 526 static inline void pudp_idte_global(struct mm_struct *mm,
 527                                     unsigned long addr, pud_t *pudp)
 528 {
 529         if (MACHINE_HAS_TLB_GUEST)
 530                 __pudp_idte(addr, pudp, IDTE_NODAT | IDTE_GUEST_ASCE,
 531                             mm->context.asce, IDTE_GLOBAL);
 532         else if (MACHINE_HAS_IDTE)
 533                 __pudp_idte(addr, pudp, 0, 0, IDTE_GLOBAL);
 534         else
 535                 /*
 536                  * Invalid bit position is the same for pmd and pud, so we can
 537                  * re-use _pmd_csp() here
 538                  */
 539                 __pmdp_csp((pmd_t *) pudp);
 540 }
 541
 542 static inline pud_t pudp_flush_direct(struct mm_struct *mm,
 543                                       unsigned long addr, pud_t *pudp)
 544 {
 545         pud_t old;
 546
 547         old = *pudp;
 548         if (pud_val(old) & _REGION_ENTRY_INVALID)
 549                 return old;
 550         atomic_inc(&mm->context.flush_count);
 551         if (MACHINE_HAS_TLB_LC &&
 552             cpumask_equal(mm_cpumask(mm), cpumask_of(smp_processor_id())))
 553                 pudp_idte_local(mm, addr, pudp);
 554         else
 555                 pudp_idte_global(mm, addr, pudp);
 556         atomic_dec(&mm->context.flush_count);
 557         return old;
 558 }
 559
 560 pud_t pudp_xchg_direct(struct mm_struct *mm, unsigned long addr,
 561                        pud_t *pudp, pud_t new)
 562 {
 563         pud_t old;
 564
 565         preempt_disable();
 566         old = pudp_flush_direct(mm, addr, pudp);
 567         set_pud(pudp, new);
 568         preempt_enable();
 569         return old;
 570 }
 571 EXPORT_SYMBOL(pudp_xchg_direct);
 572
 573 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 574 void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
 575                                 pgtable_t pgtable)
 576 {
 577         struct list_head *lh = (struct list_head *) pgtable;
 578
 579         assert_spin_locked(pmd_lockptr(mm, pmdp));
 580
 581         /* FIFO */
 582         if (!pmd_huge_pte(mm, pmdp))
 583                 INIT_LIST_HEAD(lh);
 584         else
 585                 list_add(lh, (struct list_head *) pmd_huge_pte(mm, pmdp));
 586         pmd_huge_pte(mm, pmdp) = pgtable;
 587 }
 588
 589 pgtable_t pgtable_trans_huge_withdraw(struct mm_struct *mm, pmd_t *pmdp)
 590 {
 591         struct list_head *lh;
 592         pgtable_t pgtable;
 593         pte_t *ptep;
 594
 595         assert_spin_locked(pmd_lockptr(mm, pmdp));
 596
 597         /* FIFO */
 598         pgtable = pmd_huge_pte(mm, pmdp);
 599         lh = (struct list_head *) pgtable;
 600         if (list_empty(lh))
 601                 pmd_huge_pte(mm, pmdp) = NULL;
 602         else {
 603                 pmd_huge_pte(mm, pmdp) = (pgtable_t) lh->next;
 604                 list_del(lh);
 605         }
 606         ptep = (pte_t *) pgtable;
 607         set_pte(ptep, __pte(_PAGE_INVALID));
 608         ptep++;
 609         set_pte(ptep, __pte(_PAGE_INVALID));
 610         return pgtable;
 611 }
 612 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
 613
 614 #ifdef CONFIG_PGSTE
 615 void ptep_set_pte_at(struct mm_struct *mm, unsigned long addr,
 616                      pte_t *ptep, pte_t entry)
 617 {
 618         pgste_t pgste;
 619
 620         /* the mm_has_pgste() check is done in set_pte_at() */
 621         preempt_disable();
 622         pgste = pgste_get_lock(ptep);
 623         pgste_val(pgste) &= ~_PGSTE_GPS_ZERO;
 624         pgste_set_key(ptep, pgste, entry, mm);
 625         pgste = pgste_set_pte(ptep, pgste, entry);
 626         pgste_set_unlock(ptep, pgste);
 627         preempt_enable();
 628 }
 629
 630 void ptep_set_notify(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 631 {
 632         pgste_t pgste;
 633
 634         preempt_disable();
 635         pgste = pgste_get_lock(ptep);
 636         pgste_val(pgste) |= PGSTE_IN_BIT;
 637         pgste_set_unlock(ptep, pgste);
 638         preempt_enable();
 639 }
 640
 641 /**
 642  * ptep_force_prot - change access rights of a locked pte
 643  * @mm: pointer to the process mm_struct
 644  * @addr: virtual address in the guest address space
 645  * @ptep: pointer to the page table entry
 646  * @prot: indicates guest access rights: PROT_NONE, PROT_READ or PROT_WRITE
 647  * @bit: pgste bit to set (e.g. for notification)
 648  *
 649  * Returns 0 if the access rights were changed and -EAGAIN if the current
 650  * and requested access rights are incompatible.
 651  */
 652 int ptep_force_prot(struct mm_struct *mm, unsigned long addr,
 653                     pte_t *ptep, int prot, unsigned long bit)
 654 {
 655         pte_t entry;
 656         pgste_t pgste;
 657         int pte_i, pte_p, nodat;
 658
 659         pgste = pgste_get_lock(ptep);
 660         entry = *ptep;
 661         /* Check pte entry after all locks have been acquired */
 662         pte_i = pte_val(entry) & _PAGE_INVALID;
 663         pte_p = pte_val(entry) & _PAGE_PROTECT;
 664         if ((pte_i && (prot != PROT_NONE)) ||
 665             (pte_p && (prot & PROT_WRITE))) {
 666                 pgste_set_unlock(ptep, pgste);
 667                 return -EAGAIN;
 668         }
 669         /* Change access rights and set pgste bit */
 670         nodat = !!(pgste_val(pgste) & _PGSTE_GPS_NODAT);
 671         if (prot == PROT_NONE && !pte_i) {
 672                 ptep_flush_direct(mm, addr, ptep, nodat);
 673                 pgste = pgste_update_all(entry, pgste, mm);
 674                 entry = set_pte_bit(entry, __pgprot(_PAGE_INVALID));
 675         }
 676         if (prot == PROT_READ && !pte_p) {
 677                 ptep_flush_direct(mm, addr, ptep, nodat);
 678                 entry = clear_pte_bit(entry, __pgprot(_PAGE_INVALID));
 679                 entry = set_pte_bit(entry, __pgprot(_PAGE_PROTECT));
 680         }
 681         pgste_val(pgste) |= bit;
 682         pgste = pgste_set_pte(ptep, pgste, entry);
 683         pgste_set_unlock(ptep, pgste);
 684         return 0;
 685 }
 686
 687 int ptep_shadow_pte(struct mm_struct *mm, unsigned long saddr,
 688                     pte_t *sptep, pte_t *tptep, pte_t pte)
 689 {
 690         pgste_t spgste, tpgste;
 691         pte_t spte, tpte;
 692         int rc = -EAGAIN;
 693
 694         if (!(pte_val(*tptep) & _PAGE_INVALID))
 695                 return 0;       /* already shadowed */
 696         spgste = pgste_get_lock(sptep);
 697         spte = *sptep;
 698         if (!(pte_val(spte) & _PAGE_INVALID) &&
 699             !((pte_val(spte) & _PAGE_PROTECT) &&
 700               !(pte_val(pte) & _PAGE_PROTECT))) {
 701                 pgste_val(spgste) |= PGSTE_VSIE_BIT;
 702                 tpgste = pgste_get_lock(tptep);
 703                 tpte = __pte((pte_val(spte) & PAGE_MASK) |
 704                              (pte_val(pte) & _PAGE_PROTECT));
 705                 /* don't touch the storage key - it belongs to parent pgste */
 706                 tpgste = pgste_set_pte(tptep, tpgste, tpte);
 707                 pgste_set_unlock(tptep, tpgste);
 708                 rc = 1;
 709         }
 710         pgste_set_unlock(sptep, spgste);
 711         return rc;
 712 }
 713
 714 void ptep_unshadow_pte(struct mm_struct *mm, unsigned long saddr, pte_t *ptep)
 715 {
 716         pgste_t pgste;
 717         int nodat;
 718
 719         pgste = pgste_get_lock(ptep);
 720         /* notifier is called by the caller */
 721         nodat = !!(pgste_val(pgste) & _PGSTE_GPS_NODAT);
 722         ptep_flush_direct(mm, saddr, ptep, nodat);
 723         /* don't touch the storage key - it belongs to parent pgste */
 724         pgste = pgste_set_pte(ptep, pgste, __pte(_PAGE_INVALID));
 725         pgste_set_unlock(ptep, pgste);
 726 }
 727
 728 static void ptep_zap_swap_entry(struct mm_struct *mm, swp_entry_t entry)
 729 {
 730         if (!non_swap_entry(entry))
 731                 dec_mm_counter(mm, MM_SWAPENTS);
 732         else if (is_migration_entry(entry)) {
 733                 struct page *page = pfn_swap_entry_to_page(entry);
 734
 735                 dec_mm_counter(mm, mm_counter(page));
 736         }
 737         free_swap_and_cache(entry);
 738 }
 739
 740 void ptep_zap_unused(struct mm_struct *mm, unsigned long addr,
 741                      pte_t *ptep, int reset)
 742 {
 743         unsigned long pgstev;
 744         pgste_t pgste;
 745         pte_t pte;
 746
 747         /* Zap unused and logically-zero pages */
 748         preempt_disable();
 749         pgste = pgste_get_lock(ptep);
 750         pgstev = pgste_val(pgste);
 751         pte = *ptep;
 752         if (!reset && pte_swap(pte) &&
 753             ((pgstev & _PGSTE_GPS_USAGE_MASK) == _PGSTE_GPS_USAGE_UNUSED ||
 754              (pgstev & _PGSTE_GPS_ZERO))) {
 755                 ptep_zap_swap_entry(mm, pte_to_swp_entry(pte));
 756                 pte_clear(mm, addr, ptep);
 757         }
 758         if (reset)
 759                 pgste_val(pgste) &= ~_PGSTE_GPS_USAGE_MASK;
 760         pgste_set_unlock(ptep, pgste);
 761         preempt_enable();
 762 }
 763
 764 void ptep_zap_key(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 765 {
 766         unsigned long ptev;
 767         pgste_t pgste;
 768
 769         /* Clear storage key ACC and F, but set R/C */
 770         preempt_disable();
 771         pgste = pgste_get_lock(ptep);
 772         pgste_val(pgste) &= ~(PGSTE_ACC_BITS | PGSTE_FP_BIT);
 773         pgste_val(pgste) |= PGSTE_GR_BIT | PGSTE_GC_BIT;
 774         ptev = pte_val(*ptep);
 775         if (!(ptev & _PAGE_INVALID) && (ptev & _PAGE_WRITE))
 776                 page_set_storage_key(ptev & PAGE_MASK, PAGE_DEFAULT_KEY, 0);
 777         pgste_set_unlock(ptep, pgste);
 778         preempt_enable();
 779 }
 780
 781 /*
 782  * Test and reset if a guest page is dirty
 783  */
 784 bool ptep_test_and_clear_uc(struct mm_struct *mm, unsigned long addr,
 785                        pte_t *ptep)
 786 {
 787         pgste_t pgste;
 788         pte_t pte;
 789         bool dirty;
 790         int nodat;
 791
 792         pgste = pgste_get_lock(ptep);
 793         dirty = !!(pgste_val(pgste) & PGSTE_UC_BIT);
 794         pgste_val(pgste) &= ~PGSTE_UC_BIT;
 795         pte = *ptep;
 796         if (dirty && (pte_val(pte) & _PAGE_PRESENT)) {
 797                 pgste = pgste_pte_notify(mm, addr, ptep, pgste);
 798                 nodat = !!(pgste_val(pgste) & _PGSTE_GPS_NODAT);
 799                 ptep_ipte_global(mm, addr, ptep, nodat);
 800                 if (MACHINE_HAS_ESOP || !(pte_val(pte) & _PAGE_WRITE))
 801                         pte = set_pte_bit(pte, __pgprot(_PAGE_PROTECT));
 802                 else
 803                         pte = set_pte_bit(pte, __pgprot(_PAGE_INVALID));
 804                 set_pte(ptep, pte);
 805         }
 806         pgste_set_unlock(ptep, pgste);
 807         return dirty;
 808 }
 809 EXPORT_SYMBOL_GPL(ptep_test_and_clear_uc);
 810
 811 int set_guest_storage_key(struct mm_struct *mm, unsigned long addr,
 812                           unsigned char key, bool nq)
 813 {
 814         unsigned long keyul, paddr;
 815         spinlock_t *ptl;
 816         pgste_t old, new;
 817         pmd_t *pmdp;
 818         pte_t *ptep;
 819
 820         /*
 821          * If we don't have a PTE table and if there is no huge page mapped,
 822          * we can ignore attempts to set the key to 0, because it already is 0.
 823          */
 824         switch (pmd_lookup(mm, addr, &pmdp)) {
 825         case -ENOENT:
 826                 return key ? -EFAULT : 0;
 827         case 0:
 828                 break;
 829         default:
 830                 return -EFAULT;
 831         }
 832 again:
 833         ptl = pmd_lock(mm, pmdp);
 834         if (!pmd_present(*pmdp)) {
 835                 spin_unlock(ptl);
 836                 return key ? -EFAULT : 0;
 837         }
 838
 839         if (pmd_large(*pmdp)) {
 840                 paddr = pmd_val(*pmdp) & HPAGE_MASK;
 841                 paddr |= addr & ~HPAGE_MASK;
 842                 /*
 843                  * Huge pmds need quiescing operations, they are
 844                  * always mapped.
 845                  */
 846                 page_set_storage_key(paddr, key, 1);
 847                 spin_unlock(ptl);
 848                 return 0;
 849         }
 850         spin_unlock(ptl);
 851
 852         ptep = pte_offset_map_lock(mm, pmdp, addr, &ptl);
 853         if (!ptep)
 854                 goto again;
 855         new = old = pgste_get_lock(ptep);
 856         pgste_val(new) &= ~(PGSTE_GR_BIT | PGSTE_GC_BIT |
 857                             PGSTE_ACC_BITS | PGSTE_FP_BIT);
 858         keyul = (unsigned long) key;
 859         pgste_val(new) |= (keyul & (_PAGE_CHANGED | _PAGE_REFERENCED)) << 48;
 860         pgste_val(new) |= (keyul & (_PAGE_ACC_BITS | _PAGE_FP_BIT)) << 56;
 861         if (!(pte_val(*ptep) & _PAGE_INVALID)) {
 862                 unsigned long bits, skey;
 863
 864                 paddr = pte_val(*ptep) & PAGE_MASK;
 865                 skey = (unsigned long) page_get_storage_key(paddr);
 866                 bits = skey & (_PAGE_CHANGED | _PAGE_REFERENCED);
 867                 skey = key & (_PAGE_ACC_BITS | _PAGE_FP_BIT);
 868                 /* Set storage key ACC and FP */
 869                 page_set_storage_key(paddr, skey, !nq);
 870                 /* Merge host changed & referenced into pgste  */
 871                 pgste_val(new) |= bits << 52;
 872         }
 873         /* changing the guest storage key is considered a change of the page */
 874         if ((pgste_val(new) ^ pgste_val(old)) &
 875             (PGSTE_ACC_BITS | PGSTE_FP_BIT | PGSTE_GR_BIT | PGSTE_GC_BIT))
 876                 pgste_val(new) |= PGSTE_UC_BIT;
 877
 878         pgste_set_unlock(ptep, new);
 879         pte_unmap_unlock(ptep, ptl);
 880         return 0;
 881 }
 882 EXPORT_SYMBOL(set_guest_storage_key);
 883
 884 /*
 885  * Conditionally set a guest storage key (handling csske).
 886  * oldkey will be updated when either mr or mc is set and a pointer is given.
 887  *
 888  * Returns 0 if a guests storage key update wasn't necessary, 1 if the guest
 889  * storage key was updated and -EFAULT on access errors.
 890  */
 891 int cond_set_guest_storage_key(struct mm_struct *mm, unsigned long addr,
 892                                unsigned char key, unsigned char *oldkey,
 893                                bool nq, bool mr, bool mc)
 894 {
 895         unsigned char tmp, mask = _PAGE_ACC_BITS | _PAGE_FP_BIT;
 896         int rc;
 897
 898         /* we can drop the pgste lock between getting and setting the key */
 899         if (mr | mc) {
 900                 rc = get_guest_storage_key(current->mm, addr, &tmp);
 901                 if (rc)
 902                         return rc;
 903                 if (oldkey)
 904                         *oldkey = tmp;
 905                 if (!mr)
 906                         mask |= _PAGE_REFERENCED;
 907                 if (!mc)
 908                         mask |= _PAGE_CHANGED;
 909                 if (!((tmp ^ key) & mask))
 910                         return 0;
 911         }
 912         rc = set_guest_storage_key(current->mm, addr, key, nq);
 913         return rc < 0 ? rc : 1;
 914 }
 915 EXPORT_SYMBOL(cond_set_guest_storage_key);
 916
 917 /*
 918  * Reset a guest reference bit (rrbe), returning the reference and changed bit.
 919  *
 920  * Returns < 0 in case of error, otherwise the cc to be reported to the guest.
 921  */
 922 int reset_guest_reference_bit(struct mm_struct *mm, unsigned long addr)
 923 {
 924         spinlock_t *ptl;
 925         unsigned long paddr;
 926         pgste_t old, new;
 927         pmd_t *pmdp;
 928         pte_t *ptep;
 929         int cc = 0;
 930
 931         /*
 932          * If we don't have a PTE table and if there is no huge page mapped,
 933          * the storage key is 0 and there is nothing for us to do.
 934          */
 935         switch (pmd_lookup(mm, addr, &pmdp)) {
 936         case -ENOENT:
 937                 return 0;
 938         case 0:
 939                 break;
 940         default:
 941                 return -EFAULT;
 942         }
 943 again:
 944         ptl = pmd_lock(mm, pmdp);
 945         if (!pmd_present(*pmdp)) {
 946                 spin_unlock(ptl);
 947                 return 0;
 948         }
 949
 950         if (pmd_large(*pmdp)) {
 951                 paddr = pmd_val(*pmdp) & HPAGE_MASK;
 952                 paddr |= addr & ~HPAGE_MASK;
 953                 cc = page_reset_referenced(paddr);
 954                 spin_unlock(ptl);
 955                 return cc;
 956         }
 957         spin_unlock(ptl);
 958
 959         ptep = pte_offset_map_lock(mm, pmdp, addr, &ptl);
 960         if (!ptep)
 961                 goto again;
 962         new = old = pgste_get_lock(ptep);
 963         /* Reset guest reference bit only */
 964         pgste_val(new) &= ~PGSTE_GR_BIT;
 965
 966         if (!(pte_val(*ptep) & _PAGE_INVALID)) {
 967                 paddr = pte_val(*ptep) & PAGE_MASK;
 968                 cc = page_reset_referenced(paddr);
 969                 /* Merge real referenced bit into host-set */
 970                 pgste_val(new) |= ((unsigned long) cc << 53) & PGSTE_HR_BIT;
 971         }
 972         /* Reflect guest's logical view, not physical */
 973         cc |= (pgste_val(old) & (PGSTE_GR_BIT | PGSTE_GC_BIT)) >> 49;
 974         /* Changing the guest storage key is considered a change of the page */
 975         if ((pgste_val(new) ^ pgste_val(old)) & PGSTE_GR_BIT)
 976                 pgste_val(new) |= PGSTE_UC_BIT;
 977
 978         pgste_set_unlock(ptep, new);
 979         pte_unmap_unlock(ptep, ptl);
 980         return cc;
 981 }
 982 EXPORT_SYMBOL(reset_guest_reference_bit);
 983
 984 int get_guest_storage_key(struct mm_struct *mm, unsigned long addr,
 985                           unsigned char *key)
 986 {
 987         unsigned long paddr;
 988         spinlock_t *ptl;
 989         pgste_t pgste;
 990         pmd_t *pmdp;
 991         pte_t *ptep;
 992
 993         /*
 994          * If we don't have a PTE table and if there is no huge page mapped,
 995          * the storage key is 0.
 996          */
 997         *key = 0;
 998
 999         switch (pmd_lookup(mm, addr, &pmdp)) {
1000         case -ENOENT:
1001                 return 0;
1002         case 0:
1003                 break;
1004         default:
1005                 return -EFAULT;
1006         }
1007 again:
1008         ptl = pmd_lock(mm, pmdp);
1009         if (!pmd_present(*pmdp)) {
1010                 spin_unlock(ptl);
1011                 return 0;
1012         }
1013
1014         if (pmd_large(*pmdp)) {
1015                 paddr = pmd_val(*pmdp) & HPAGE_MASK;
1016                 paddr |= addr & ~HPAGE_MASK;
1017                 *key = page_get_storage_key(paddr);
1018                 spin_unlock(ptl);
1019                 return 0;
1020         }
1021         spin_unlock(ptl);
1022
1023         ptep = pte_offset_map_lock(mm, pmdp, addr, &ptl);
1024         if (!ptep)
1025                 goto again;
1026         pgste = pgste_get_lock(ptep);
1027         *key = (pgste_val(pgste) & (PGSTE_ACC_BITS | PGSTE_FP_BIT)) >> 56;
1028         paddr = pte_val(*ptep) & PAGE_MASK;
1029         if (!(pte_val(*ptep) & _PAGE_INVALID))
1030                 *key = page_get_storage_key(paddr);
1031         /* Reflect guest's logical view, not physical */
1032         *key |= (pgste_val(pgste) & (PGSTE_GR_BIT | PGSTE_GC_BIT)) >> 48;
1033         pgste_set_unlock(ptep, pgste);
1034         pte_unmap_unlock(ptep, ptl);
1035         return 0;
1036 }
1037 EXPORT_SYMBOL(get_guest_storage_key);
1038
1039 /**
1040  * pgste_perform_essa - perform ESSA actions on the PGSTE.
1041  * @mm: the memory context. It must have PGSTEs, no check is performed here!
1042  * @hva: the host virtual address of the page whose PGSTE is to be processed
1043  * @orc: the specific action to perform, see the ESSA_SET_* macros.
1044  * @oldpte: the PTE will be saved there if the pointer is not NULL.
1045  * @oldpgste: the old PGSTE will be saved there if the pointer is not NULL.
1046  *
1047  * Return: 1 if the page is to be added to the CBRL, otherwise 0,
1048  *         or < 0 in case of error. -EINVAL is returned for invalid values
1049  *         of orc, -EFAULT for invalid addresses.
1050  */
1051 int pgste_perform_essa(struct mm_struct *mm, unsigned long hva, int orc,
1052                         unsigned long *oldpte, unsigned long *oldpgste)
1053 {
1054         struct vm_area_struct *vma;
1055         unsigned long pgstev;
1056         spinlock_t *ptl;
1057         pgste_t pgste;
1058         pte_t *ptep;
1059         int res = 0;
1060
1061         WARN_ON_ONCE(orc > ESSA_MAX);
1062         if (unlikely(orc > ESSA_MAX))
1063                 return -EINVAL;
1064
1065         vma = vma_lookup(mm, hva);
1066         if (!vma || is_vm_hugetlb_page(vma))
1067                 return -EFAULT;
1068         ptep = get_locked_pte(mm, hva, &ptl);
1069         if (unlikely(!ptep))
1070                 return -EFAULT;
1071         pgste = pgste_get_lock(ptep);
1072         pgstev = pgste_val(pgste);
1073         if (oldpte)
1074                 *oldpte = pte_val(*ptep);
1075         if (oldpgste)
1076                 *oldpgste = pgstev;
1077
1078         switch (orc) {
1079         case ESSA_GET_STATE:
1080                 break;
1081         case ESSA_SET_STABLE:
1082                 pgstev &= ~(_PGSTE_GPS_USAGE_MASK | _PGSTE_GPS_NODAT);
1083                 pgstev |= _PGSTE_GPS_USAGE_STABLE;
1084                 break;
1085         case ESSA_SET_UNUSED:
1086                 pgstev &= ~_PGSTE_GPS_USAGE_MASK;
1087                 pgstev |= _PGSTE_GPS_USAGE_UNUSED;
1088                 if (pte_val(*ptep) & _PAGE_INVALID)
1089                         res = 1;
1090                 break;
1091         case ESSA_SET_VOLATILE:
1092                 pgstev &= ~_PGSTE_GPS_USAGE_MASK;
1093                 pgstev |= _PGSTE_GPS_USAGE_VOLATILE;
1094                 if (pte_val(*ptep) & _PAGE_INVALID)
1095                         res = 1;
1096                 break;
1097         case ESSA_SET_POT_VOLATILE:
1098                 pgstev &= ~_PGSTE_GPS_USAGE_MASK;
1099                 if (!(pte_val(*ptep) & _PAGE_INVALID)) {
1100                         pgstev |= _PGSTE_GPS_USAGE_POT_VOLATILE;
1101                         break;
1102                 }
1103                 if (pgstev & _PGSTE_GPS_ZERO) {
1104                         pgstev |= _PGSTE_GPS_USAGE_VOLATILE;
1105                         break;
1106                 }
1107                 if (!(pgstev & PGSTE_GC_BIT)) {
1108                         pgstev |= _PGSTE_GPS_USAGE_VOLATILE;
1109                         res = 1;
1110                         break;
1111                 }
1112                 break;
1113         case ESSA_SET_STABLE_RESIDENT:
1114                 pgstev &= ~_PGSTE_GPS_USAGE_MASK;
1115                 pgstev |= _PGSTE_GPS_USAGE_STABLE;
1116                 /*
1117                  * Since the resident state can go away any time after this
1118                  * call, we will not make this page resident. We can revisit
1119                  * this decision if a guest will ever start using this.
1120                  */
1121                 break;
1122         case ESSA_SET_STABLE_IF_RESIDENT:
1123                 if (!(pte_val(*ptep) & _PAGE_INVALID)) {
1124                         pgstev &= ~_PGSTE_GPS_USAGE_MASK;
1125                         pgstev |= _PGSTE_GPS_USAGE_STABLE;
1126                 }
1127                 break;
1128         case ESSA_SET_STABLE_NODAT:
1129                 pgstev &= ~_PGSTE_GPS_USAGE_MASK;
1130                 pgstev |= _PGSTE_GPS_USAGE_STABLE | _PGSTE_GPS_NODAT;
1131                 break;
1132         default:
1133                 /* we should never get here! */
1134                 break;
1135         }
1136         /* If we are discarding a page, set it to logical zero */
1137         if (res)
1138                 pgstev |= _PGSTE_GPS_ZERO;
1139
1140         pgste_val(pgste) = pgstev;
1141         pgste_set_unlock(ptep, pgste);
1142         pte_unmap_unlock(ptep, ptl);
1143         return res;
1144 }
1145 EXPORT_SYMBOL(pgste_perform_essa);
1146
1147 /**
1148  * set_pgste_bits - set specific PGSTE bits.
1149  * @mm: the memory context. It must have PGSTEs, no check is performed here!
1150  * @hva: the host virtual address of the page whose PGSTE is to be processed
1151  * @bits: a bitmask representing the bits that will be touched
1152  * @value: the values of the bits to be written. Only the bits in the mask
1153  *         will be written.
1154  *
1155  * Return: 0 on success, < 0 in case of error.
1156  */
1157 int set_pgste_bits(struct mm_struct *mm, unsigned long hva,
1158                         unsigned long bits, unsigned long value)
1159 {
1160         struct vm_area_struct *vma;
1161         spinlock_t *ptl;
1162         pgste_t new;
1163         pte_t *ptep;
1164
1165         vma = vma_lookup(mm, hva);
1166         if (!vma || is_vm_hugetlb_page(vma))
1167                 return -EFAULT;
1168         ptep = get_locked_pte(mm, hva, &ptl);
1169         if (unlikely(!ptep))
1170                 return -EFAULT;
1171         new = pgste_get_lock(ptep);
1172
1173         pgste_val(new) &= ~bits;
1174         pgste_val(new) |= value & bits;
1175
1176         pgste_set_unlock(ptep, new);
1177         pte_unmap_unlock(ptep, ptl);
1178         return 0;
1179 }
1180 EXPORT_SYMBOL(set_pgste_bits);
1181
1182 /**
1183  * get_pgste - get the current PGSTE for the given address.
1184  * @mm: the memory context. It must have PGSTEs, no check is performed here!
1185  * @hva: the host virtual address of the page whose PGSTE is to be processed
1186  * @pgstep: will be written with the current PGSTE for the given address.
1187  *
1188  * Return: 0 on success, < 0 in case of error.
1189  */
1190 int get_pgste(struct mm_struct *mm, unsigned long hva, unsigned long *pgstep)
1191 {
1192         struct vm_area_struct *vma;
1193         spinlock_t *ptl;
1194         pte_t *ptep;
1195
1196         vma = vma_lookup(mm, hva);
1197         if (!vma || is_vm_hugetlb_page(vma))
1198                 return -EFAULT;
1199         ptep = get_locked_pte(mm, hva, &ptl);
1200         if (unlikely(!ptep))
1201                 return -EFAULT;
1202         *pgstep = pgste_val(pgste_get(ptep));
1203         pte_unmap_unlock(ptep, ptl);
1204         return 0;
1205 }
1206 EXPORT_SYMBOL(get_pgste);
1207 #endif