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