KVM: arm64: Trap FFA_VERSION host call in pKVM

The pKVM hypervisor initializes with FF-A version 1.0. The spec requires
that no other FF-A calls to be issued before the version negotiation
phase is complete. Split the hypervisor proxy initialization code in two
parts so that we can move the later one after the host negotiates its
version.

Without trapping the call, the host drivers can negotiate a higher
version number with TEE which can result in a different memory layout
described during the memory sharing calls.

Signed-off-by: Sebastian Ene <sebastianene@google.com>
Reviewed-by: Sudeep Holla <sudeep.holla@arm.com>
Tested-by: Sudeep Holla <sudeep.holla@arm.com>
Acked-by: Marc Zyngier <maz@kernel.org>
Link: https://lore.kernel.org/r/20240613132035.1070360-2-sebastianene@google.com
Signed-off-by: Oliver Upton <oliver.upton@linux.dev>

diff --git a/arch/arm64/kvm/hyp/nvhe/ffa.c b/arch/arm64/kvm/hyp/nvhe/ffa.c
index 02746f9d0980f95d40e70f2c985d9e6051bc1ecf..c8ab51c331f00d0de888b3a15ee9ad0a8287894d 100644 (file)
--- a/arch/arm64/kvm/hyp/nvhe/ffa.c
+++ b/arch/arm64/kvm/hyp/nvhe/ffa.c
@@ -67,6 +67,9 @@ struct kvm_ffa_buffers {
  */
 static struct kvm_ffa_buffers hyp_buffers;
 static struct kvm_ffa_buffers host_buffers;
+static u32 hyp_ffa_version;
+static bool has_version_negotiated;
+static hyp_spinlock_t version_lock;
 
 static void ffa_to_smccc_error(struct arm_smccc_res *res, u64 ffa_errno)
 {
@@ -639,6 +642,83 @@ out_handled:
        return true;
 }
 
+static int hyp_ffa_post_init(void)
+{
+       size_t min_rxtx_sz;
+       struct arm_smccc_res res;
+
+       arm_smccc_1_1_smc(FFA_ID_GET, 0, 0, 0, 0, 0, 0, 0, &res);
+       if (res.a0 != FFA_SUCCESS)
+               return -EOPNOTSUPP;
+
+       if (res.a2 != HOST_FFA_ID)
+               return -EINVAL;
+
+       arm_smccc_1_1_smc(FFA_FEATURES, FFA_FN64_RXTX_MAP,
+                         0, 0, 0, 0, 0, 0, &res);
+       if (res.a0 != FFA_SUCCESS)
+               return -EOPNOTSUPP;
+
+       switch (res.a2) {
+       case FFA_FEAT_RXTX_MIN_SZ_4K:
+               min_rxtx_sz = SZ_4K;
+               break;
+       case FFA_FEAT_RXTX_MIN_SZ_16K:
+               min_rxtx_sz = SZ_16K;
+               break;
+       case FFA_FEAT_RXTX_MIN_SZ_64K:
+               min_rxtx_sz = SZ_64K;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       if (min_rxtx_sz > PAGE_SIZE)
+               return -EOPNOTSUPP;
+
+       return 0;
+}
+
+static void do_ffa_version(struct arm_smccc_res *res,
+                          struct kvm_cpu_context *ctxt)
+{
+       DECLARE_REG(u32, ffa_req_version, ctxt, 1);
+
+       if (FFA_MAJOR_VERSION(ffa_req_version) != 1) {
+               res->a0 = FFA_RET_NOT_SUPPORTED;
+               return;
+       }
+
+       hyp_spin_lock(&version_lock);
+       if (has_version_negotiated) {
+               res->a0 = hyp_ffa_version;
+               goto unlock;
+       }
+
+       /*
+        * If the client driver tries to downgrade the version, we need to ask
+        * first if TEE supports it.
+        */
+       if (FFA_MINOR_VERSION(ffa_req_version) < FFA_MINOR_VERSION(hyp_ffa_version)) {
+               arm_smccc_1_1_smc(FFA_VERSION, ffa_req_version, 0,
+                                 0, 0, 0, 0, 0,
+                                 res);
+               if (res->a0 == FFA_RET_NOT_SUPPORTED)
+                       goto unlock;
+
+               hyp_ffa_version = ffa_req_version;
+       }
+
+       if (hyp_ffa_post_init())
+               res->a0 = FFA_RET_NOT_SUPPORTED;
+       else {
+               has_version_negotiated = true;
+               res->a0 = hyp_ffa_version;
+       }
+unlock:
+       hyp_spin_unlock(&version_lock);
+}
+
 bool kvm_host_ffa_handler(struct kvm_cpu_context *host_ctxt, u32 func_id)
 {
        struct arm_smccc_res res;
@@ -659,6 +739,11 @@ bool kvm_host_ffa_handler(struct kvm_cpu_context *host_ctxt, u32 func_id)
        if (!is_ffa_call(func_id))
                return false;
 
+       if (!has_version_negotiated && func_id != FFA_VERSION) {
+               ffa_to_smccc_error(&res, FFA_RET_INVALID_PARAMETERS);
+               goto out_handled;
+       }
+
        switch (func_id) {
        case FFA_FEATURES:
                if (!do_ffa_features(&res, host_ctxt))
@@ -685,6 +770,9 @@ bool kvm_host_ffa_handler(struct kvm_cpu_context *host_ctxt, u32 func_id)
        case FFA_MEM_FRAG_TX:
                do_ffa_mem_frag_tx(&res, host_ctxt);
                goto out_handled;
+       case FFA_VERSION:
+               do_ffa_version(&res, host_ctxt);
+               goto out_handled;
        }
 
        if (ffa_call_supported(func_id))
@@ -699,7 +787,6 @@ out_handled:
 int hyp_ffa_init(void *pages)
 {
        struct arm_smccc_res res;
-       size_t min_rxtx_sz;
        void *tx, *rx;
 
        if (kvm_host_psci_config.smccc_version < ARM_SMCCC_VERSION_1_2)
@@ -725,35 +812,7 @@ int hyp_ffa_init(void *pages)
        if (FFA_MAJOR_VERSION(res.a0) != 1)
                return -EOPNOTSUPP;
 
-       arm_smccc_1_1_smc(FFA_ID_GET, 0, 0, 0, 0, 0, 0, 0, &res);
-       if (res.a0 != FFA_SUCCESS)
-               return -EOPNOTSUPP;
-
-       if (res.a2 != HOST_FFA_ID)
-               return -EINVAL;
-
-       arm_smccc_1_1_smc(FFA_FEATURES, FFA_FN64_RXTX_MAP,
-                         0, 0, 0, 0, 0, 0, &res);
-       if (res.a0 != FFA_SUCCESS)
-               return -EOPNOTSUPP;
-
-       switch (res.a2) {
-       case FFA_FEAT_RXTX_MIN_SZ_4K:
-               min_rxtx_sz = SZ_4K;
-               break;
-       case FFA_FEAT_RXTX_MIN_SZ_16K:
-               min_rxtx_sz = SZ_16K;
-               break;
-       case FFA_FEAT_RXTX_MIN_SZ_64K:
-               min_rxtx_sz = SZ_64K;
-               break;
-       default:
-               return -EINVAL;
-       }
-
-       if (min_rxtx_sz > PAGE_SIZE)
-               return -EOPNOTSUPP;
-
+       hyp_ffa_version = FFA_VERSION_1_0;
        tx = pages;
        pages += KVM_FFA_MBOX_NR_PAGES * PAGE_SIZE;
        rx = pages;
@@ -775,5 +834,6 @@ int hyp_ffa_init(void *pages)
                .lock   = __HYP_SPIN_LOCK_UNLOCKED,
        };
 
+       version_lock = __HYP_SPIN_LOCK_UNLOCKED;
        return 0;
 }