arch/arm64/include/asm/kvm_pgtable.h

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2020 Google LLC
   4  * Author: Will Deacon <[email protected]>
   5  */
   6
   7 #ifndef __ARM64_KVM_PGTABLE_H__
   8 #define __ARM64_KVM_PGTABLE_H__
   9
  10 #include <linux/bits.h>
  11 #include <linux/kvm_host.h>
  12 #include <linux/types.h>
  13
  14 #define KVM_PGTABLE_MAX_LEVELS          4U
  15
  16 /*
  17  * The largest supported block sizes for KVM (no 52-bit PA support):
  18  *  - 4K (level 1):     1GB
  19  *  - 16K (level 2):    32MB
  20  *  - 64K (level 2):    512MB
  21  */
  22 #ifdef CONFIG_ARM64_4K_PAGES
  23 #define KVM_PGTABLE_MIN_BLOCK_LEVEL     1U
  24 #else
  25 #define KVM_PGTABLE_MIN_BLOCK_LEVEL     2U
  26 #endif
  27
  28 static inline u64 kvm_get_parange(u64 mmfr0)
  29 {
  30         u64 parange = cpuid_feature_extract_unsigned_field(mmfr0,
  31                                 ID_AA64MMFR0_EL1_PARANGE_SHIFT);
  32         if (parange > ID_AA64MMFR0_EL1_PARANGE_MAX)
  33                 parange = ID_AA64MMFR0_EL1_PARANGE_MAX;
  34
  35         return parange;
  36 }
  37
  38 typedef u64 kvm_pte_t;
  39
  40 #define KVM_PTE_VALID                   BIT(0)
  41
  42 #define KVM_PTE_ADDR_MASK               GENMASK(47, PAGE_SHIFT)
  43 #define KVM_PTE_ADDR_51_48              GENMASK(15, 12)
  44
  45 #define KVM_PHYS_INVALID                (-1ULL)
  46
  47 static inline bool kvm_pte_valid(kvm_pte_t pte)
  48 {
  49         return pte & KVM_PTE_VALID;
  50 }
  51
  52 static inline u64 kvm_pte_to_phys(kvm_pte_t pte)
  53 {
  54         u64 pa = pte & KVM_PTE_ADDR_MASK;
  55
  56         if (PAGE_SHIFT == 16)
  57                 pa |= FIELD_GET(KVM_PTE_ADDR_51_48, pte) << 48;
  58
  59         return pa;
  60 }
  61
  62 static inline kvm_pte_t kvm_phys_to_pte(u64 pa)
  63 {
  64         kvm_pte_t pte = pa & KVM_PTE_ADDR_MASK;
  65
  66         if (PAGE_SHIFT == 16) {
  67                 pa &= GENMASK(51, 48);
  68                 pte |= FIELD_PREP(KVM_PTE_ADDR_51_48, pa >> 48);
  69         }
  70
  71         return pte;
  72 }
  73
  74 static inline u64 kvm_granule_shift(u32 level)
  75 {
  76         /* Assumes KVM_PGTABLE_MAX_LEVELS is 4 */
  77         return ARM64_HW_PGTABLE_LEVEL_SHIFT(level);
  78 }
  79
  80 static inline u64 kvm_granule_size(u32 level)
  81 {
  82         return BIT(kvm_granule_shift(level));
  83 }
  84
  85 static inline bool kvm_level_supports_block_mapping(u32 level)
  86 {
  87         return level >= KVM_PGTABLE_MIN_BLOCK_LEVEL;
  88 }
  89
  90 /**
  91  * struct kvm_pgtable_mm_ops - Memory management callbacks.
  92  * @zalloc_page:                Allocate a single zeroed memory page.
  93  *                              The @arg parameter can be used by the walker
  94  *                              to pass a memcache. The initial refcount of
  95  *                              the page is 1.
  96  * @zalloc_pages_exact:         Allocate an exact number of zeroed memory pages.
  97  *                              The @size parameter is in bytes, and is rounded
  98  *                              up to the next page boundary. The resulting
  99  *                              allocation is physically contiguous.
 100  * @free_pages_exact:           Free an exact number of memory pages previously
 101  *                              allocated by zalloc_pages_exact.
 102  * @free_removed_table:         Free a removed paging structure by unlinking and
 103  *                              dropping references.
 104  * @get_page:                   Increment the refcount on a page.
 105  * @put_page:                   Decrement the refcount on a page. When the
 106  *                              refcount reaches 0 the page is automatically
 107  *                              freed.
 108  * @page_count:                 Return the refcount of a page.
 109  * @phys_to_virt:               Convert a physical address into a virtual
 110  *                              address mapped in the current context.
 111  * @virt_to_phys:               Convert a virtual address mapped in the current
 112  *                              context into a physical address.
 113  * @dcache_clean_inval_poc:     Clean and invalidate the data cache to the PoC
 114  *                              for the specified memory address range.
 115  * @icache_inval_pou:           Invalidate the instruction cache to the PoU
 116  *                              for the specified memory address range.
 117  */
 118 struct kvm_pgtable_mm_ops {
 119         void*           (*zalloc_page)(void *arg);
 120         void*           (*zalloc_pages_exact)(size_t size);
 121         void            (*free_pages_exact)(void *addr, size_t size);
 122         void            (*free_removed_table)(void *addr, u32 level);
 123         void            (*get_page)(void *addr);
 124         void            (*put_page)(void *addr);
 125         int             (*page_count)(void *addr);
 126         void*           (*phys_to_virt)(phys_addr_t phys);
 127         phys_addr_t     (*virt_to_phys)(void *addr);
 128         void            (*dcache_clean_inval_poc)(void *addr, size_t size);
 129         void            (*icache_inval_pou)(void *addr, size_t size);
 130 };
 131
 132 /**
 133  * enum kvm_pgtable_stage2_flags - Stage-2 page-table flags.
 134  * @KVM_PGTABLE_S2_NOFWB:       Don't enforce Normal-WB even if the CPUs have
 135  *                              ARM64_HAS_STAGE2_FWB.
 136  * @KVM_PGTABLE_S2_IDMAP:       Only use identity mappings.
 137  */
 138 enum kvm_pgtable_stage2_flags {
 139         KVM_PGTABLE_S2_NOFWB                    = BIT(0),
 140         KVM_PGTABLE_S2_IDMAP                    = BIT(1),
 141 };
 142
 143 /**
 144  * enum kvm_pgtable_prot - Page-table permissions and attributes.
 145  * @KVM_PGTABLE_PROT_X:         Execute permission.
 146  * @KVM_PGTABLE_PROT_W:         Write permission.
 147  * @KVM_PGTABLE_PROT_R:         Read permission.
 148  * @KVM_PGTABLE_PROT_DEVICE:    Device attributes.
 149  * @KVM_PGTABLE_PROT_SW0:       Software bit 0.
 150  * @KVM_PGTABLE_PROT_SW1:       Software bit 1.
 151  * @KVM_PGTABLE_PROT_SW2:       Software bit 2.
 152  * @KVM_PGTABLE_PROT_SW3:       Software bit 3.
 153  */
 154 enum kvm_pgtable_prot {
 155         KVM_PGTABLE_PROT_X                      = BIT(0),
 156         KVM_PGTABLE_PROT_W                      = BIT(1),
 157         KVM_PGTABLE_PROT_R                      = BIT(2),
 158
 159         KVM_PGTABLE_PROT_DEVICE                 = BIT(3),
 160
 161         KVM_PGTABLE_PROT_SW0                    = BIT(55),
 162         KVM_PGTABLE_PROT_SW1                    = BIT(56),
 163         KVM_PGTABLE_PROT_SW2                    = BIT(57),
 164         KVM_PGTABLE_PROT_SW3                    = BIT(58),
 165 };
 166
 167 #define KVM_PGTABLE_PROT_RW     (KVM_PGTABLE_PROT_R | KVM_PGTABLE_PROT_W)
 168 #define KVM_PGTABLE_PROT_RWX    (KVM_PGTABLE_PROT_RW | KVM_PGTABLE_PROT_X)
 169
 170 #define PKVM_HOST_MEM_PROT      KVM_PGTABLE_PROT_RWX
 171 #define PKVM_HOST_MMIO_PROT     KVM_PGTABLE_PROT_RW
 172
 173 #define PAGE_HYP                KVM_PGTABLE_PROT_RW
 174 #define PAGE_HYP_EXEC           (KVM_PGTABLE_PROT_R | KVM_PGTABLE_PROT_X)
 175 #define PAGE_HYP_RO             (KVM_PGTABLE_PROT_R)
 176 #define PAGE_HYP_DEVICE         (PAGE_HYP | KVM_PGTABLE_PROT_DEVICE)
 177
 178 typedef bool (*kvm_pgtable_force_pte_cb_t)(u64 addr, u64 end,
 179                                            enum kvm_pgtable_prot prot);
 180
 181 /**
 182  * enum kvm_pgtable_walk_flags - Flags to control a depth-first page-table walk.
 183  * @KVM_PGTABLE_WALK_LEAF:              Visit leaf entries, including invalid
 184  *                                      entries.
 185  * @KVM_PGTABLE_WALK_TABLE_PRE:         Visit table entries before their
 186  *                                      children.
 187  * @KVM_PGTABLE_WALK_TABLE_POST:        Visit table entries after their
 188  *                                      children.
 189  * @KVM_PGTABLE_WALK_SHARED:            Indicates the page-tables may be shared
 190  *                                      with other software walkers.
 191  */
 192 enum kvm_pgtable_walk_flags {
 193         KVM_PGTABLE_WALK_LEAF                   = BIT(0),
 194         KVM_PGTABLE_WALK_TABLE_PRE              = BIT(1),
 195         KVM_PGTABLE_WALK_TABLE_POST             = BIT(2),
 196         KVM_PGTABLE_WALK_SHARED                 = BIT(3),
 197 };
 198
 199 struct kvm_pgtable_visit_ctx {
 200         kvm_pte_t                               *ptep;
 201         kvm_pte_t                               old;
 202         void                                    *arg;
 203         struct kvm_pgtable_mm_ops               *mm_ops;
 204         u64                                     addr;
 205         u64                                     end;
 206         u32                                     level;
 207         enum kvm_pgtable_walk_flags             flags;
 208 };
 209
 210 typedef int (*kvm_pgtable_visitor_fn_t)(const struct kvm_pgtable_visit_ctx *ctx,
 211                                         enum kvm_pgtable_walk_flags visit);
 212
 213 static inline bool kvm_pgtable_walk_shared(const struct kvm_pgtable_visit_ctx *ctx)
 214 {
 215         return ctx->flags & KVM_PGTABLE_WALK_SHARED;
 216 }
 217
 218 /**
 219  * struct kvm_pgtable_walker - Hook into a page-table walk.
 220  * @cb:         Callback function to invoke during the walk.
 221  * @arg:        Argument passed to the callback function.
 222  * @flags:      Bitwise-OR of flags to identify the entry types on which to
 223  *              invoke the callback function.
 224  */
 225 struct kvm_pgtable_walker {
 226         const kvm_pgtable_visitor_fn_t          cb;
 227         void * const                            arg;
 228         const enum kvm_pgtable_walk_flags       flags;
 229 };
 230
 231 /*
 232  * RCU cannot be used in a non-kernel context such as the hyp. As such, page
 233  * table walkers used in hyp do not call into RCU and instead use other
 234  * synchronization mechanisms (such as a spinlock).
 235  */
 236 #if defined(__KVM_NVHE_HYPERVISOR__) || defined(__KVM_VHE_HYPERVISOR__)
 237
 238 typedef kvm_pte_t *kvm_pteref_t;
 239
 240 static inline kvm_pte_t *kvm_dereference_pteref(struct kvm_pgtable_walker *walker,
 241                                                 kvm_pteref_t pteref)
 242 {
 243         return pteref;
 244 }
 245
 246 static inline int kvm_pgtable_walk_begin(struct kvm_pgtable_walker *walker)
 247 {
 248         /*
 249          * Due to the lack of RCU (or a similar protection scheme), only
 250          * non-shared table walkers are allowed in the hypervisor.
 251          */
 252         if (walker->flags & KVM_PGTABLE_WALK_SHARED)
 253                 return -EPERM;
 254
 255         return 0;
 256 }
 257
 258 static inline void kvm_pgtable_walk_end(struct kvm_pgtable_walker *walker) {}
 259
 260 static inline bool kvm_pgtable_walk_lock_held(void)
 261 {
 262         return true;
 263 }
 264
 265 #else
 266
 267 typedef kvm_pte_t __rcu *kvm_pteref_t;
 268
 269 static inline kvm_pte_t *kvm_dereference_pteref(struct kvm_pgtable_walker *walker,
 270                                                 kvm_pteref_t pteref)
 271 {
 272         return rcu_dereference_check(pteref, !(walker->flags & KVM_PGTABLE_WALK_SHARED));
 273 }
 274
 275 static inline int kvm_pgtable_walk_begin(struct kvm_pgtable_walker *walker)
 276 {
 277         if (walker->flags & KVM_PGTABLE_WALK_SHARED)
 278                 rcu_read_lock();
 279
 280         return 0;
 281 }
 282
 283 static inline void kvm_pgtable_walk_end(struct kvm_pgtable_walker *walker)
 284 {
 285         if (walker->flags & KVM_PGTABLE_WALK_SHARED)
 286                 rcu_read_unlock();
 287 }
 288
 289 static inline bool kvm_pgtable_walk_lock_held(void)
 290 {
 291         return rcu_read_lock_held();
 292 }
 293
 294 #endif
 295
 296 /**
 297  * struct kvm_pgtable - KVM page-table.
 298  * @ia_bits:            Maximum input address size, in bits.
 299  * @start_level:        Level at which the page-table walk starts.
 300  * @pgd:                Pointer to the first top-level entry of the page-table.
 301  * @mm_ops:             Memory management callbacks.
 302  * @mmu:                Stage-2 KVM MMU struct. Unused for stage-1 page-tables.
 303  * @flags:              Stage-2 page-table flags.
 304  * @force_pte_cb:       Function that returns true if page level mappings must
 305  *                      be used instead of block mappings.
 306  */
 307 struct kvm_pgtable {
 308         u32                                     ia_bits;
 309         u32                                     start_level;
 310         kvm_pteref_t                            pgd;
 311         struct kvm_pgtable_mm_ops               *mm_ops;
 312
 313         /* Stage-2 only */
 314         struct kvm_s2_mmu                       *mmu;
 315         enum kvm_pgtable_stage2_flags           flags;
 316         kvm_pgtable_force_pte_cb_t              force_pte_cb;
 317 };
 318
 319 /**
 320  * kvm_pgtable_hyp_init() - Initialise a hypervisor stage-1 page-table.
 321  * @pgt:        Uninitialised page-table structure to initialise.
 322  * @va_bits:    Maximum virtual address bits.
 323  * @mm_ops:     Memory management callbacks.
 324  *
 325  * Return: 0 on success, negative error code on failure.
 326  */
 327 int kvm_pgtable_hyp_init(struct kvm_pgtable *pgt, u32 va_bits,
 328                          struct kvm_pgtable_mm_ops *mm_ops);
 329
 330 /**
 331  * kvm_pgtable_hyp_destroy() - Destroy an unused hypervisor stage-1 page-table.
 332  * @pgt:        Page-table structure initialised by kvm_pgtable_hyp_init().
 333  *
 334  * The page-table is assumed to be unreachable by any hardware walkers prior
 335  * to freeing and therefore no TLB invalidation is performed.
 336  */
 337 void kvm_pgtable_hyp_destroy(struct kvm_pgtable *pgt);
 338
 339 /**
 340  * kvm_pgtable_hyp_map() - Install a mapping in a hypervisor stage-1 page-table.
 341  * @pgt:        Page-table structure initialised by kvm_pgtable_hyp_init().
 342  * @addr:       Virtual address at which to place the mapping.
 343  * @size:       Size of the mapping.
 344  * @phys:       Physical address of the memory to map.
 345  * @prot:       Permissions and attributes for the mapping.
 346  *
 347  * The offset of @addr within a page is ignored, @size is rounded-up to
 348  * the next page boundary and @phys is rounded-down to the previous page
 349  * boundary.
 350  *
 351  * If device attributes are not explicitly requested in @prot, then the
 352  * mapping will be normal, cacheable. Attempts to install a new mapping
 353  * for a virtual address that is already mapped will be rejected with an
 354  * error and a WARN().
 355  *
 356  * Return: 0 on success, negative error code on failure.
 357  */
 358 int kvm_pgtable_hyp_map(struct kvm_pgtable *pgt, u64 addr, u64 size, u64 phys,
 359                         enum kvm_pgtable_prot prot);
 360
 361 /**
 362  * kvm_pgtable_hyp_unmap() - Remove a mapping from a hypervisor stage-1 page-table.
 363  * @pgt:        Page-table structure initialised by kvm_pgtable_hyp_init().
 364  * @addr:       Virtual address from which to remove the mapping.
 365  * @size:       Size of the mapping.
 366  *
 367  * The offset of @addr within a page is ignored, @size is rounded-up to
 368  * the next page boundary and @phys is rounded-down to the previous page
 369  * boundary.
 370  *
 371  * TLB invalidation is performed for each page-table entry cleared during the
 372  * unmapping operation and the reference count for the page-table page
 373  * containing the cleared entry is decremented, with unreferenced pages being
 374  * freed. The unmapping operation will stop early if it encounters either an
 375  * invalid page-table entry or a valid block mapping which maps beyond the range
 376  * being unmapped.
 377  *
 378  * Return: Number of bytes unmapped, which may be 0.
 379  */
 380 u64 kvm_pgtable_hyp_unmap(struct kvm_pgtable *pgt, u64 addr, u64 size);
 381
 382 /**
 383  * kvm_get_vtcr() - Helper to construct VTCR_EL2
 384  * @mmfr0:      Sanitized value of SYS_ID_AA64MMFR0_EL1 register.
 385  * @mmfr1:      Sanitized value of SYS_ID_AA64MMFR1_EL1 register.
 386  * @phys_shfit: Value to set in VTCR_EL2.T0SZ.
 387  *
 388  * The VTCR value is common across all the physical CPUs on the system.
 389  * We use system wide sanitised values to fill in different fields,
 390  * except for Hardware Management of Access Flags. HA Flag is set
 391  * unconditionally on all CPUs, as it is safe to run with or without
 392  * the feature and the bit is RES0 on CPUs that don't support it.
 393  *
 394  * Return: VTCR_EL2 value
 395  */
 396 u64 kvm_get_vtcr(u64 mmfr0, u64 mmfr1, u32 phys_shift);
 397
 398 /**
 399  * kvm_pgtable_stage2_pgd_size() - Helper to compute size of a stage-2 PGD
 400  * @vtcr:       Content of the VTCR register.
 401  *
 402  * Return: the size (in bytes) of the stage-2 PGD
 403  */
 404 size_t kvm_pgtable_stage2_pgd_size(u64 vtcr);
 405
 406 /**
 407  * __kvm_pgtable_stage2_init() - Initialise a guest stage-2 page-table.
 408  * @pgt:        Uninitialised page-table structure to initialise.
 409  * @mmu:        S2 MMU context for this S2 translation
 410  * @mm_ops:     Memory management callbacks.
 411  * @flags:      Stage-2 configuration flags.
 412  * @force_pte_cb: Function that returns true if page level mappings must
 413  *              be used instead of block mappings.
 414  *
 415  * Return: 0 on success, negative error code on failure.
 416  */
 417 int __kvm_pgtable_stage2_init(struct kvm_pgtable *pgt, struct kvm_s2_mmu *mmu,
 418                               struct kvm_pgtable_mm_ops *mm_ops,
 419                               enum kvm_pgtable_stage2_flags flags,
 420                               kvm_pgtable_force_pte_cb_t force_pte_cb);
 421
 422 #define kvm_pgtable_stage2_init(pgt, mmu, mm_ops) \
 423         __kvm_pgtable_stage2_init(pgt, mmu, mm_ops, 0, NULL)
 424
 425 /**
 426  * kvm_pgtable_stage2_destroy() - Destroy an unused guest stage-2 page-table.
 427  * @pgt:        Page-table structure initialised by kvm_pgtable_stage2_init*().
 428  *
 429  * The page-table is assumed to be unreachable by any hardware walkers prior
 430  * to freeing and therefore no TLB invalidation is performed.
 431  */
 432 void kvm_pgtable_stage2_destroy(struct kvm_pgtable *pgt);
 433
 434 /**
 435  * kvm_pgtable_stage2_free_removed() - Free a removed stage-2 paging structure.
 436  * @mm_ops:     Memory management callbacks.
 437  * @pgtable:    Unlinked stage-2 paging structure to be freed.
 438  * @level:      Level of the stage-2 paging structure to be freed.
 439  *
 440  * The page-table is assumed to be unreachable by any hardware walkers prior to
 441  * freeing and therefore no TLB invalidation is performed.
 442  */
 443 void kvm_pgtable_stage2_free_removed(struct kvm_pgtable_mm_ops *mm_ops, void *pgtable, u32 level);
 444
 445 /**
 446  * kvm_pgtable_stage2_map() - Install a mapping in a guest stage-2 page-table.
 447  * @pgt:        Page-table structure initialised by kvm_pgtable_stage2_init*().
 448  * @addr:       Intermediate physical address at which to place the mapping.
 449  * @size:       Size of the mapping.
 450  * @phys:       Physical address of the memory to map.
 451  * @prot:       Permissions and attributes for the mapping.
 452  * @mc:         Cache of pre-allocated and zeroed memory from which to allocate
 453  *              page-table pages.
 454  * @flags:      Flags to control the page-table walk (ex. a shared walk)
 455  *
 456  * The offset of @addr within a page is ignored, @size is rounded-up to
 457  * the next page boundary and @phys is rounded-down to the previous page
 458  * boundary.
 459  *
 460  * If device attributes are not explicitly requested in @prot, then the
 461  * mapping will be normal, cacheable.
 462  *
 463  * Note that the update of a valid leaf PTE in this function will be aborted,
 464  * if it's trying to recreate the exact same mapping or only change the access
 465  * permissions. Instead, the vCPU will exit one more time from guest if still
 466  * needed and then go through the path of relaxing permissions.
 467  *
 468  * Note that this function will both coalesce existing table entries and split
 469  * existing block mappings, relying on page-faults to fault back areas outside
 470  * of the new mapping lazily.
 471  *
 472  * Return: 0 on success, negative error code on failure.
 473  */
 474 int kvm_pgtable_stage2_map(struct kvm_pgtable *pgt, u64 addr, u64 size,
 475                            u64 phys, enum kvm_pgtable_prot prot,
 476                            void *mc, enum kvm_pgtable_walk_flags flags);
 477
 478 /**
 479  * kvm_pgtable_stage2_set_owner() - Unmap and annotate pages in the IPA space to
 480  *                                  track ownership.
 481  * @pgt:        Page-table structure initialised by kvm_pgtable_stage2_init*().
 482  * @addr:       Base intermediate physical address to annotate.
 483  * @size:       Size of the annotated range.
 484  * @mc:         Cache of pre-allocated and zeroed memory from which to allocate
 485  *              page-table pages.
 486  * @owner_id:   Unique identifier for the owner of the page.
 487  *
 488  * By default, all page-tables are owned by identifier 0. This function can be
 489  * used to mark portions of the IPA space as owned by other entities. When a
 490  * stage 2 is used with identity-mappings, these annotations allow to use the
 491  * page-table data structure as a simple rmap.
 492  *
 493  * Return: 0 on success, negative error code on failure.
 494  */
 495 int kvm_pgtable_stage2_set_owner(struct kvm_pgtable *pgt, u64 addr, u64 size,
 496                                  void *mc, u8 owner_id);
 497
 498 /**
 499  * kvm_pgtable_stage2_unmap() - Remove a mapping from a guest stage-2 page-table.
 500  * @pgt:        Page-table structure initialised by kvm_pgtable_stage2_init*().
 501  * @addr:       Intermediate physical address from which to remove the mapping.
 502  * @size:       Size of the mapping.
 503  *
 504  * The offset of @addr within a page is ignored and @size is rounded-up to
 505  * the next page boundary.
 506  *
 507  * TLB invalidation is performed for each page-table entry cleared during the
 508  * unmapping operation and the reference count for the page-table page
 509  * containing the cleared entry is decremented, with unreferenced pages being
 510  * freed. Unmapping a cacheable page will ensure that it is clean to the PoC if
 511  * FWB is not supported by the CPU.
 512  *
 513  * Return: 0 on success, negative error code on failure.
 514  */
 515 int kvm_pgtable_stage2_unmap(struct kvm_pgtable *pgt, u64 addr, u64 size);
 516
 517 /**
 518  * kvm_pgtable_stage2_wrprotect() - Write-protect guest stage-2 address range
 519  *                                  without TLB invalidation.
 520  * @pgt:        Page-table structure initialised by kvm_pgtable_stage2_init*().
 521  * @addr:       Intermediate physical address from which to write-protect,
 522  * @size:       Size of the range.
 523  *
 524  * The offset of @addr within a page is ignored and @size is rounded-up to
 525  * the next page boundary.
 526  *
 527  * Note that it is the caller's responsibility to invalidate the TLB after
 528  * calling this function to ensure that the updated permissions are visible
 529  * to the CPUs.
 530  *
 531  * Return: 0 on success, negative error code on failure.
 532  */
 533 int kvm_pgtable_stage2_wrprotect(struct kvm_pgtable *pgt, u64 addr, u64 size);
 534
 535 /**
 536  * kvm_pgtable_stage2_mkyoung() - Set the access flag in a page-table entry.
 537  * @pgt:        Page-table structure initialised by kvm_pgtable_stage2_init*().
 538  * @addr:       Intermediate physical address to identify the page-table entry.
 539  *
 540  * The offset of @addr within a page is ignored.
 541  *
 542  * If there is a valid, leaf page-table entry used to translate @addr, then
 543  * set the access flag in that entry.
 544  *
 545  * Return: The old page-table entry prior to setting the flag, 0 on failure.
 546  */
 547 kvm_pte_t kvm_pgtable_stage2_mkyoung(struct kvm_pgtable *pgt, u64 addr);
 548
 549 /**
 550  * kvm_pgtable_stage2_mkold() - Clear the access flag in a page-table entry.
 551  * @pgt:        Page-table structure initialised by kvm_pgtable_stage2_init*().
 552  * @addr:       Intermediate physical address to identify the page-table entry.
 553  *
 554  * The offset of @addr within a page is ignored.
 555  *
 556  * If there is a valid, leaf page-table entry used to translate @addr, then
 557  * clear the access flag in that entry.
 558  *
 559  * Note that it is the caller's responsibility to invalidate the TLB after
 560  * calling this function to ensure that the updated permissions are visible
 561  * to the CPUs.
 562  *
 563  * Return: The old page-table entry prior to clearing the flag, 0 on failure.
 564  */
 565 kvm_pte_t kvm_pgtable_stage2_mkold(struct kvm_pgtable *pgt, u64 addr);
 566
 567 /**
 568  * kvm_pgtable_stage2_relax_perms() - Relax the permissions enforced by a
 569  *                                    page-table entry.
 570  * @pgt:        Page-table structure initialised by kvm_pgtable_stage2_init*().
 571  * @addr:       Intermediate physical address to identify the page-table entry.
 572  * @prot:       Additional permissions to grant for the mapping.
 573  *
 574  * The offset of @addr within a page is ignored.
 575  *
 576  * If there is a valid, leaf page-table entry used to translate @addr, then
 577  * relax the permissions in that entry according to the read, write and
 578  * execute permissions specified by @prot. No permissions are removed, and
 579  * TLB invalidation is performed after updating the entry. Software bits cannot
 580  * be set or cleared using kvm_pgtable_stage2_relax_perms().
 581  *
 582  * Return: 0 on success, negative error code on failure.
 583  */
 584 int kvm_pgtable_stage2_relax_perms(struct kvm_pgtable *pgt, u64 addr,
 585                                    enum kvm_pgtable_prot prot);
 586
 587 /**
 588  * kvm_pgtable_stage2_is_young() - Test whether a page-table entry has the
 589  *                                 access flag set.
 590  * @pgt:        Page-table structure initialised by kvm_pgtable_stage2_init*().
 591  * @addr:       Intermediate physical address to identify the page-table entry.
 592  *
 593  * The offset of @addr within a page is ignored.
 594  *
 595  * Return: True if the page-table entry has the access flag set, false otherwise.
 596  */
 597 bool kvm_pgtable_stage2_is_young(struct kvm_pgtable *pgt, u64 addr);
 598
 599 /**
 600  * kvm_pgtable_stage2_flush_range() - Clean and invalidate data cache to Point
 601  *                                    of Coherency for guest stage-2 address
 602  *                                    range.
 603  * @pgt:        Page-table structure initialised by kvm_pgtable_stage2_init*().
 604  * @addr:       Intermediate physical address from which to flush.
 605  * @size:       Size of the range.
 606  *
 607  * The offset of @addr within a page is ignored and @size is rounded-up to
 608  * the next page boundary.
 609  *
 610  * Return: 0 on success, negative error code on failure.
 611  */
 612 int kvm_pgtable_stage2_flush(struct kvm_pgtable *pgt, u64 addr, u64 size);
 613
 614 /**
 615  * kvm_pgtable_walk() - Walk a page-table.
 616  * @pgt:        Page-table structure initialised by kvm_pgtable_*_init().
 617  * @addr:       Input address for the start of the walk.
 618  * @size:       Size of the range to walk.
 619  * @walker:     Walker callback description.
 620  *
 621  * The offset of @addr within a page is ignored and @size is rounded-up to
 622  * the next page boundary.
 623  *
 624  * The walker will walk the page-table entries corresponding to the input
 625  * address range specified, visiting entries according to the walker flags.
 626  * Invalid entries are treated as leaf entries. Leaf entries are reloaded
 627  * after invoking the walker callback, allowing the walker to descend into
 628  * a newly installed table.
 629  *
 630  * Returning a negative error code from the walker callback function will
 631  * terminate the walk immediately with the same error code.
 632  *
 633  * Return: 0 on success, negative error code on failure.
 634  */
 635 int kvm_pgtable_walk(struct kvm_pgtable *pgt, u64 addr, u64 size,
 636                      struct kvm_pgtable_walker *walker);
 637
 638 /**
 639  * kvm_pgtable_get_leaf() - Walk a page-table and retrieve the leaf entry
 640  *                          with its level.
 641  * @pgt:        Page-table structure initialised by kvm_pgtable_*_init()
 642  *              or a similar initialiser.
 643  * @addr:       Input address for the start of the walk.
 644  * @ptep:       Pointer to storage for the retrieved PTE.
 645  * @level:      Pointer to storage for the level of the retrieved PTE.
 646  *
 647  * The offset of @addr within a page is ignored.
 648  *
 649  * The walker will walk the page-table entries corresponding to the input
 650  * address specified, retrieving the leaf corresponding to this address.
 651  * Invalid entries are treated as leaf entries.
 652  *
 653  * Return: 0 on success, negative error code on failure.
 654  */
 655 int kvm_pgtable_get_leaf(struct kvm_pgtable *pgt, u64 addr,
 656                          kvm_pte_t *ptep, u32 *level);
 657
 658 /**
 659  * kvm_pgtable_stage2_pte_prot() - Retrieve the protection attributes of a
 660  *                                 stage-2 Page-Table Entry.
 661  * @pte:        Page-table entry
 662  *
 663  * Return: protection attributes of the page-table entry in the enum
 664  *         kvm_pgtable_prot format.
 665  */
 666 enum kvm_pgtable_prot kvm_pgtable_stage2_pte_prot(kvm_pte_t pte);
 667
 668 /**
 669  * kvm_pgtable_hyp_pte_prot() - Retrieve the protection attributes of a stage-1
 670  *                              Page-Table Entry.
 671  * @pte:        Page-table entry
 672  *
 673  * Return: protection attributes of the page-table entry in the enum
 674  *         kvm_pgtable_prot format.
 675  */
 676 enum kvm_pgtable_prot kvm_pgtable_hyp_pte_prot(kvm_pte_t pte);
 677 #endif  /* __ARM64_KVM_PGTABLE_H__ */