SSL core.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2023, Arm Limited
 */

#include <linux/arm_ffa.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/limits.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/scatterlist.h>
#include <linux/slab.h>
#include <linux/tee_core.h>
#include <linux/types.h>
#include <linux/uuid.h>
#include <linux/xarray.h>
#include "tstee_private.h"

#define FFA_DIRECT_REQ_ARG_NUM 5
#define FFA_INVALID_MEM_HANDLE U64_MAX

static void arg_list_to_ffa_data(const u32 *args,
     struct ffa_send_direct_data *data)
{
 data->data0 = args[0];
 data->data1 = args[1];
 data->data2 = args[2];
 data->data3 = args[3];
 data->data4 = args[4];
}

static void arg_list_from_ffa_data(const struct ffa_send_direct_data *data,
       u32 *args)
{
 args[0] = lower_32_bits(data->data0);
 args[1] = lower_32_bits(data->data1);
 args[2] = lower_32_bits(data->data2);
 args[3] = lower_32_bits(data->data3);
 args[4] = lower_32_bits(data->data4);
}

static void tstee_get_version(struct tee_device *teedev,
         struct tee_ioctl_version_data *vers)
{
 struct tstee *tstee = tee_get_drvdata(teedev);
 struct tee_ioctl_version_data v = {
  .impl_id = TEE_IMPL_ID_TSTEE,
  /* FF-A endpoint ID only uses the lower 16 bits */
  .impl_caps = lower_16_bits(tstee->ffa_dev->vm_id),
  .gen_caps = 0,
 };

 *vers = v;
}

static int tstee_open(struct tee_context *ctx)
{
 struct ts_context_data *ctxdata;

 ctxdata = kzalloc(sizeof(*ctxdata), GFP_KERNEL);
 if (!ctxdata)
  return -ENOMEM;

 xa_init_flags(&ctxdata->sess_list, XA_FLAGS_ALLOC);

 ctx->data = ctxdata;

 return 0;
}

static void tstee_release(struct tee_context *ctx)
{
 struct ts_context_data *ctxdata = ctx->data;
 struct ts_session *sess;
 unsigned long idx;

 if (!ctxdata)
  return;

 xa_for_each(&ctxdata->sess_list, idx, sess) {
  xa_erase(&ctxdata->sess_list, idx);
  kfree(sess);
 }

 xa_destroy(&ctxdata->sess_list);

 kfree(ctxdata);
 ctx->data = NULL;
}

static int tstee_open_session(struct tee_context *ctx,
         struct tee_ioctl_open_session_arg *arg,
         struct tee_param *param __always_unused)
{
 struct tstee *tstee = tee_get_drvdata(ctx->teedev);
 struct ffa_device *ffa_dev = tstee->ffa_dev;
 struct ts_context_data *ctxdata = ctx->data;
 struct ffa_send_direct_data ffa_data;
 struct ts_session *sess = NULL;
 u32 ffa_args[FFA_DIRECT_REQ_ARG_NUM] = {};
 u32 sess_id;
 int rc;

 ffa_args[TS_RPC_CTRL_REG] =
  TS_RPC_CTRL_PACK_IFACE_OPCODE(TS_RPC_MGMT_IFACE_ID,
           TS_RPC_OP_SERVICE_INFO);

 memcpy(ffa_args + TS_RPC_SERVICE_INFO_UUID0, arg->uuid, UUID_SIZE);

 arg_list_to_ffa_data(ffa_args, &ffa_data);
 rc = ffa_dev->ops->msg_ops->sync_send_receive(ffa_dev, &ffa_data);
 if (rc)
  return rc;

 arg_list_from_ffa_data(&ffa_data, ffa_args);

 if (ffa_args[TS_RPC_SERVICE_INFO_RPC_STATUS] != TS_RPC_OK)
  return -ENODEV;

 if (ffa_args[TS_RPC_SERVICE_INFO_IFACE] > U8_MAX)
  return -EINVAL;

 sess = kzalloc(sizeof(*sess), GFP_KERNEL);
 if (!sess)
  return -ENOMEM;

 sess->iface_id = ffa_args[TS_RPC_SERVICE_INFO_IFACE];

 rc = xa_alloc(&ctxdata->sess_list, &sess_id, sess, xa_limit_32b,
        GFP_KERNEL);
 if (rc) {
  kfree(sess);
  return rc;
 }

 arg->session = sess_id;
 arg->ret = 0;

 return 0;
}

static int tstee_close_session(struct tee_context *ctx, u32 session)
{
 struct ts_context_data *ctxdata = ctx->data;
 struct ts_session *sess;

 /* Calls xa_lock() internally */
 sess = xa_erase(&ctxdata->sess_list, session);
 if (!sess)
  return -EINVAL;

 kfree(sess);

 return 0;
}

static int tstee_invoke_func(struct tee_context *ctx,
        struct tee_ioctl_invoke_arg *arg,
        struct tee_param *param)
{
 struct tstee *tstee = tee_get_drvdata(ctx->teedev);
 struct ffa_device *ffa_dev = tstee->ffa_dev;
 struct ts_context_data *ctxdata = ctx->data;
 struct ffa_send_direct_data ffa_data;
 struct tee_shm *shm = NULL;
 struct ts_session *sess;
 u32 req_len, ffa_args[FFA_DIRECT_REQ_ARG_NUM] = {};
 int shm_id, rc;
 u8 iface_id;
 u64 handle;
 u16 opcode;

 xa_lock(&ctxdata->sess_list);
 sess = xa_load(&ctxdata->sess_list, arg->session);

 /*
 * Do this while holding the lock to make sure that the session wasn't
 * closed meanwhile
 */
 if (sess)
  iface_id = sess->iface_id;

 xa_unlock(&ctxdata->sess_list);
 if (!sess)
  return -EINVAL;

 opcode = lower_16_bits(arg->func);
 shm_id = lower_32_bits(param[0].u.value.a);
 req_len = lower_32_bits(param[0].u.value.b);

 if (shm_id != 0) {
  shm = tee_shm_get_from_id(ctx, shm_id);
  if (IS_ERR(shm))
   return PTR_ERR(shm);

  if (shm->size < req_len) {
   dev_err(&ffa_dev->dev,
    "request doesn't fit into shared memory buffer\n");
   rc = -EINVAL;
   goto out;
  }

  handle = shm->sec_world_id;
 } else {
  handle = FFA_INVALID_MEM_HANDLE;
 }

 ffa_args[TS_RPC_CTRL_REG] = TS_RPC_CTRL_PACK_IFACE_OPCODE(iface_id,
          opcode);
 ffa_args[TS_RPC_SERVICE_MEM_HANDLE_LSW] = lower_32_bits(handle);
 ffa_args[TS_RPC_SERVICE_MEM_HANDLE_MSW] = upper_32_bits(handle);
 ffa_args[TS_RPC_SERVICE_REQ_LEN] = req_len;
 ffa_args[TS_RPC_SERVICE_CLIENT_ID] = 0;

 arg_list_to_ffa_data(ffa_args, &ffa_data);
 rc = ffa_dev->ops->msg_ops->sync_send_receive(ffa_dev, &ffa_data);
 if (rc)
  goto out;

 arg_list_from_ffa_data(&ffa_data, ffa_args);

 if (ffa_args[TS_RPC_SERVICE_RPC_STATUS] != TS_RPC_OK) {
  dev_err(&ffa_dev->dev, "invoke_func rpc status: %d\n",
   ffa_args[TS_RPC_SERVICE_RPC_STATUS]);
  rc = -EINVAL;
  goto out;
 }

 arg->ret = ffa_args[TS_RPC_SERVICE_STATUS];
 if (shm && shm->size >= ffa_args[TS_RPC_SERVICE_RESP_LEN])
  param[0].u.value.a = ffa_args[TS_RPC_SERVICE_RESP_LEN];

out:
 if (shm)
  tee_shm_put(shm);

 return rc;
}

static int tstee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
         struct page **pages, size_t num_pages,
         unsigned long start __always_unused)
{
 struct tstee *tstee = tee_get_drvdata(ctx->teedev);
 struct ffa_device *ffa_dev = tstee->ffa_dev;
 struct ffa_mem_region_attributes mem_attr = {
  .receiver = tstee->ffa_dev->vm_id,
  .attrs = FFA_MEM_RW,
  .flag = 0,
 };
 struct ffa_mem_ops_args mem_args = {
  .attrs = &mem_attr,
  .use_txbuf = true,
  .nattrs = 1,
  .flags = 0,
 };
 struct ffa_send_direct_data ffa_data;
 struct sg_table sgt;
 u32 ffa_args[FFA_DIRECT_REQ_ARG_NUM] = {};
 int rc;

 rc = sg_alloc_table_from_pages(&sgt, pages, num_pages, 0,
           num_pages * PAGE_SIZE, GFP_KERNEL);
 if (rc)
  return rc;

 mem_args.sg = sgt.sgl;
 rc = ffa_dev->ops->mem_ops->memory_share(&mem_args);
 sg_free_table(&sgt);
 if (rc)
  return rc;

 shm->sec_world_id = mem_args.g_handle;

 ffa_args[TS_RPC_CTRL_REG] =
   TS_RPC_CTRL_PACK_IFACE_OPCODE(TS_RPC_MGMT_IFACE_ID,
            TS_RPC_OP_RETRIEVE_MEM);
 ffa_args[TS_RPC_RETRIEVE_MEM_HANDLE_LSW] =
   lower_32_bits(shm->sec_world_id);
 ffa_args[TS_RPC_RETRIEVE_MEM_HANDLE_MSW] =
   upper_32_bits(shm->sec_world_id);
 ffa_args[TS_RPC_RETRIEVE_MEM_TAG_LSW] = 0;
 ffa_args[TS_RPC_RETRIEVE_MEM_TAG_MSW] = 0;

 arg_list_to_ffa_data(ffa_args, &ffa_data);
 rc = ffa_dev->ops->msg_ops->sync_send_receive(ffa_dev, &ffa_data);
 if (rc) {
  (void)ffa_dev->ops->mem_ops->memory_reclaim(shm->sec_world_id,
           0);
  return rc;
 }

 arg_list_from_ffa_data(&ffa_data, ffa_args);

 if (ffa_args[TS_RPC_RETRIEVE_MEM_RPC_STATUS] != TS_RPC_OK) {
  dev_err(&ffa_dev->dev, "shm_register rpc status: %d\n",
   ffa_args[TS_RPC_RETRIEVE_MEM_RPC_STATUS]);
  ffa_dev->ops->mem_ops->memory_reclaim(shm->sec_world_id, 0);
  return -EINVAL;
 }

 return 0;
}

static int tstee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
{
 struct tstee *tstee = tee_get_drvdata(ctx->teedev);
 struct ffa_device *ffa_dev = tstee->ffa_dev;
 struct ffa_send_direct_data ffa_data;
 u32 ffa_args[FFA_DIRECT_REQ_ARG_NUM] = {};
 int rc;

 ffa_args[TS_RPC_CTRL_REG] =
   TS_RPC_CTRL_PACK_IFACE_OPCODE(TS_RPC_MGMT_IFACE_ID,
            TS_RPC_OP_RELINQ_MEM);
 ffa_args[TS_RPC_RELINQ_MEM_HANDLE_LSW] =
   lower_32_bits(shm->sec_world_id);
 ffa_args[TS_RPC_RELINQ_MEM_HANDLE_MSW] =
   upper_32_bits(shm->sec_world_id);

 arg_list_to_ffa_data(ffa_args, &ffa_data);
 rc = ffa_dev->ops->msg_ops->sync_send_receive(ffa_dev, &ffa_data);
 if (rc)
  return rc;
 arg_list_from_ffa_data(&ffa_data, ffa_args);

 if (ffa_args[TS_RPC_RELINQ_MEM_RPC_STATUS] != TS_RPC_OK) {
  dev_err(&ffa_dev->dev, "shm_unregister rpc status: %d\n",
   ffa_args[TS_RPC_RELINQ_MEM_RPC_STATUS]);
  return -EINVAL;
 }

 rc = ffa_dev->ops->mem_ops->memory_reclaim(shm->sec_world_id, 0);

 return rc;
}

static const struct tee_driver_ops tstee_ops = {
 .get_version = tstee_get_version,
 .open = tstee_open,
 .release = tstee_release,
 .open_session = tstee_open_session,
 .close_session = tstee_close_session,
 .invoke_func = tstee_invoke_func,
};

static const struct tee_desc tstee_desc = {
 .name = "tstee-clnt",
 .ops = &tstee_ops,
 .owner = THIS_MODULE,
};

static int pool_op_alloc(struct tee_shm_pool *pool, struct tee_shm *shm,
    size_t size, size_t align)
{
 return tee_dyn_shm_alloc_helper(shm, size, align, tstee_shm_register);
}

static void pool_op_free(struct tee_shm_pool *pool, struct tee_shm *shm)
{
 tee_dyn_shm_free_helper(shm, tstee_shm_unregister);
}

static void pool_op_destroy_pool(struct tee_shm_pool *pool)
{
 kfree(pool);
}

static const struct tee_shm_pool_ops pool_ops = {
 .alloc = pool_op_alloc,
 .free = pool_op_free,
 .destroy_pool = pool_op_destroy_pool,
};

static struct tee_shm_pool *tstee_create_shm_pool(void)
{
 struct tee_shm_pool *pool = kzalloc(sizeof(*pool), GFP_KERNEL);

 if (!pool)
  return ERR_PTR(-ENOMEM);

 pool->ops = &pool_ops;

 return pool;
}

static bool tstee_check_rpc_compatible(struct ffa_device *ffa_dev)
{
 struct ffa_send_direct_data ffa_data;
 u32 ffa_args[FFA_DIRECT_REQ_ARG_NUM] = {};

 ffa_args[TS_RPC_CTRL_REG] =
   TS_RPC_CTRL_PACK_IFACE_OPCODE(TS_RPC_MGMT_IFACE_ID,
            TS_RPC_OP_GET_VERSION);

 arg_list_to_ffa_data(ffa_args, &ffa_data);
 if (ffa_dev->ops->msg_ops->sync_send_receive(ffa_dev, &ffa_data))
  return false;

 arg_list_from_ffa_data(&ffa_data, ffa_args);

 return ffa_args[TS_RPC_GET_VERSION_RESP] == TS_RPC_PROTOCOL_VERSION;
}

static int tstee_probe(struct ffa_device *ffa_dev)
{
 struct tstee *tstee;
 int rc;

 ffa_dev->ops->msg_ops->mode_32bit_set(ffa_dev);

 if (!tstee_check_rpc_compatible(ffa_dev))
  return -EINVAL;

 tstee = kzalloc(sizeof(*tstee), GFP_KERNEL);
 if (!tstee)
  return -ENOMEM;

 tstee->ffa_dev = ffa_dev;

 tstee->pool = tstee_create_shm_pool();
 if (IS_ERR(tstee->pool)) {
  rc = PTR_ERR(tstee->pool);
  tstee->pool = NULL;
  goto err_free_tstee;
 }

 tstee->teedev = tee_device_alloc(&tstee_desc, NULL, tstee->pool, tstee);
 if (IS_ERR(tstee->teedev)) {
  rc = PTR_ERR(tstee->teedev);
  tstee->teedev = NULL;
  goto err_free_pool;
 }

 rc = tee_device_register(tstee->teedev);
 if (rc)
  goto err_unreg_teedev;

 ffa_dev_set_drvdata(ffa_dev, tstee);

 return 0;

err_unreg_teedev:
 tee_device_unregister(tstee->teedev);
err_free_pool:
 tee_shm_pool_free(tstee->pool);
err_free_tstee:
 kfree(tstee);
 return rc;
}

static void tstee_remove(struct ffa_device *ffa_dev)
{
 struct tstee *tstee = ffa_dev->dev.driver_data;

 tee_device_unregister(tstee->teedev);
 tee_shm_pool_free(tstee->pool);
 kfree(tstee);
}

static const struct ffa_device_id tstee_device_ids[] = {
 /* TS RPC protocol UUID: bdcd76d7-825e-4751-963b-86d4f84943ac */
 { TS_RPC_UUID },
 {}
};

static struct ffa_driver tstee_driver = {
 .name = "arm_tstee",
 .probe = tstee_probe,
 .remove = tstee_remove,
 .id_table = tstee_device_ids,
};

module_ffa_driver(tstee_driver);

MODULE_AUTHOR("Balint Dobszay <balint.dobszay@arm.com>");
MODULE_DESCRIPTION("Arm Trusted Services TEE driver");
MODULE_LICENSE("GPL");