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