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_PARANGE_SHIFT);
20 	if (parange > ID_AA64MMFR0_PARANGE_MAX)
21 		parange = ID_AA64MMFR0_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