KVM: arm64: Introduce pkvm_alloc_private_va_range()

pkvm_hyp_alloc_private_va_range() can be used to reserve private VA ranges
in the pKVM nVHE hypervisor. Allocations are aligned based on the order of
the requested size.

This will be used to implement stack guard pages for pKVM nVHE hypervisor
(in a subsequent patch in the series).

Credits to Quentin Perret <qperret@google.com> for the idea of moving
private VA allocation out of __pkvm_create_private_mapping()

Signed-off-by: Kalesh Singh <kaleshsingh@google.com>
Tested-by: Fuad Tabba <tabba@google.com>
Reviewed-by: Fuad Tabba <tabba@google.com>
Signed-off-by: Marc Zyngier <maz@kernel.org>
Link: https://lore.kernel.org/r/20220420214317.3303360-3-kaleshsingh@google.com

diff --git a/arch/arm64/kvm/hyp/include/nvhe/mm.h b/arch/arm64/kvm/hyp/include/nvhe/mm.h
index 2d08510c6cc1bf62e87a10fecb48d5a37ccabe2f..42d8eb9bfe725b49c808b22e4333d69bb7a47ece 100644 (file)
--- a/arch/arm64/kvm/hyp/include/nvhe/mm.h
+++ b/arch/arm64/kvm/hyp/include/nvhe/mm.h
@@ -19,8 +19,10 @@ int hyp_back_vmemmap(phys_addr_t phys, unsigned long size, phys_addr_t back);
 int pkvm_cpu_set_vector(enum arm64_hyp_spectre_vector slot);
 int pkvm_create_mappings(void *from, void *to, enum kvm_pgtable_prot prot);
 int pkvm_create_mappings_locked(void *from, void *to, enum kvm_pgtable_prot prot);
-unsigned long __pkvm_create_private_mapping(phys_addr_t phys, size_t size,
-                                           enum kvm_pgtable_prot prot);
+int __pkvm_create_private_mapping(phys_addr_t phys, size_t size,
+                                 enum kvm_pgtable_prot prot,
+                                 unsigned long *haddr);
+int pkvm_alloc_private_va_range(size_t size, unsigned long *haddr);
 
 static inline void hyp_vmemmap_range(phys_addr_t phys, unsigned long size,
                                     unsigned long *start, unsigned long *end)

diff --git a/arch/arm64/kvm/hyp/nvhe/hyp-main.c b/arch/arm64/kvm/hyp/nvhe/hyp-main.c
index 5e2197db0d328e40e7a7ed7173d3da286095cba6..3cea4b6ac23ec114c037348fee1363ad25edeff6 100644 (file)
--- a/arch/arm64/kvm/hyp/nvhe/hyp-main.c
+++ b/arch/arm64/kvm/hyp/nvhe/hyp-main.c
@@ -160,7 +160,23 @@ static void handle___pkvm_create_private_mapping(struct kvm_cpu_context *host_ct
        DECLARE_REG(size_t, size, host_ctxt, 2);
        DECLARE_REG(enum kvm_pgtable_prot, prot, host_ctxt, 3);
 
-       cpu_reg(host_ctxt, 1) = __pkvm_create_private_mapping(phys, size, prot);
+       /*
+        * __pkvm_create_private_mapping() populates a pointer with the
+        * hypervisor start address of the allocation.
+        *
+        * However, handle___pkvm_create_private_mapping() hypercall crosses the
+        * EL1/EL2 boundary so the pointer would not be valid in this context.
+        *
+        * Instead pass the allocation address as the return value (or return
+        * ERR_PTR() on failure).
+        */
+       unsigned long haddr;
+       int err = __pkvm_create_private_mapping(phys, size, prot, &haddr);
+
+       if (err)
+               haddr = (unsigned long)ERR_PTR(err);
+
+       cpu_reg(host_ctxt, 1) = haddr;
 }
 
 static void handle___pkvm_prot_finalize(struct kvm_cpu_context *host_ctxt)

diff --git a/arch/arm64/kvm/hyp/nvhe/mm.c b/arch/arm64/kvm/hyp/nvhe/mm.c
index cdbe8e24641838401820027b0d8e521cf216d9d8..96193cb31a399da80598f9517a7c3e0259676b58 100644 (file)
--- a/arch/arm64/kvm/hyp/nvhe/mm.c
+++ b/arch/arm64/kvm/hyp/nvhe/mm.c
@@ -37,36 +37,60 @@ static int __pkvm_create_mappings(unsigned long start, unsigned long size,
        return err;
 }
 
-unsigned long __pkvm_create_private_mapping(phys_addr_t phys, size_t size,
-                                           enum kvm_pgtable_prot prot)
+/**
+ * pkvm_alloc_private_va_range - Allocates a private VA range.
+ * @size:      The size of the VA range to reserve.
+ * @haddr:     The hypervisor virtual start address of the allocation.
+ *
+ * The private virtual address (VA) range is allocated above __io_map_base
+ * and aligned based on the order of @size.
+ *
+ * Return: 0 on success or negative error code on failure.
+ */
+int pkvm_alloc_private_va_range(size_t size, unsigned long *haddr)
 {
-       unsigned long addr;
-       int err;
+       unsigned long base, addr;
+       int ret = 0;
 
        hyp_spin_lock(&pkvm_pgd_lock);
 
-       size = PAGE_ALIGN(size + offset_in_page(phys));
-       addr = __io_map_base;
-       __io_map_base += size;
+       /* Align the allocation based on the order of its size */
+       addr = ALIGN(__io_map_base, PAGE_SIZE << get_order(size));
 
-       /* Are we overflowing on the vmemmap ? */
-       if (__io_map_base > __hyp_vmemmap) {
-               __io_map_base -= size;
-               addr = (unsigned long)ERR_PTR(-ENOMEM);
-               goto out;
-       }
+       /* The allocated size is always a multiple of PAGE_SIZE */
+       base = addr + PAGE_ALIGN(size);
 
-       err = kvm_pgtable_hyp_map(&pkvm_pgtable, addr, size, phys, prot);
-       if (err) {
-               addr = (unsigned long)ERR_PTR(err);
-               goto out;
+       /* Are we overflowing on the vmemmap ? */
+       if (!addr || base > __hyp_vmemmap)
+               ret = -ENOMEM;
+       else {
+               __io_map_base = base;
+               *haddr = addr;
        }
 
-       addr = addr + offset_in_page(phys);
-out:
        hyp_spin_unlock(&pkvm_pgd_lock);
 
-       return addr;
+       return ret;
+}
+
+int __pkvm_create_private_mapping(phys_addr_t phys, size_t size,
+                                 enum kvm_pgtable_prot prot,
+                                 unsigned long *haddr)
+{
+       unsigned long addr;
+       int err;
+
+       size = PAGE_ALIGN(size + offset_in_page(phys));
+       err = pkvm_alloc_private_va_range(size, &addr);
+       if (err)
+               return err;
+
+       err = __pkvm_create_mappings(addr, size, phys, prot);
+       if (err)
+               return err;
+
+       *haddr = addr + offset_in_page(phys);
+       return err;
 }
 
 int pkvm_create_mappings_locked(void *from, void *to, enum kvm_pgtable_prot prot)
@@ -146,7 +170,8 @@ int pkvm_cpu_set_vector(enum arm64_hyp_spectre_vector slot)
 int hyp_map_vectors(void)
 {
        phys_addr_t phys;
-       void *bp_base;
+       unsigned long bp_base;
+       int ret;
 
        if (!kvm_system_needs_idmapped_vectors()) {
                __hyp_bp_vect_base = __bp_harden_hyp_vecs;
@@ -154,13 +179,12 @@ int hyp_map_vectors(void)
        }
 
        phys = __hyp_pa(__bp_harden_hyp_vecs);
-       bp_base = (void *)__pkvm_create_private_mapping(phys,
-                                                       __BP_HARDEN_HYP_VECS_SZ,
-                                                       PAGE_HYP_EXEC);
-       if (IS_ERR_OR_NULL(bp_base))
-               return PTR_ERR(bp_base);
+       ret = __pkvm_create_private_mapping(phys, __BP_HARDEN_HYP_VECS_SZ,
+                                           PAGE_HYP_EXEC, &bp_base);
+       if (ret)
+               return ret;
 
-       __hyp_bp_vect_base = bp_base;
+       __hyp_bp_vect_base = (void *)bp_base;
 
        return 0;
 }