Merge tag 'optee-ffa-for-v5.16' of... (20f6d958) · Commits · EulixOS / Software / Kernel

drivers/tee/optee/Makefile

+3 −2

Original line number	Diff line number	Diff line
		@@ -4,8 +4,9 @@ optee-objs += core.o
		optee-objs += call.o
		optee-objs += rpc.o
		optee-objs += supp.o
		optee-objs += shm_pool.o
		optee-objs += device.o
		optee-objs += smc_abi.o
		optee-objs += ffa_abi.o

		# for tracing framework to find optee_trace.h
		CFLAGS_call.o := -I$(src)
		CFLAGS_smc_abi.o := -I$(src)

drivers/tee/optee/call.c

+58 −387

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/*
		* Copyright (c) 2015, Linaro Limited
		* Copyright (c) 2015-2021, Linaro Limited
		*/
		#include <linux/arm-smccc.h>
		#include <linux/device.h>
		#include <linux/err.h>
		#include <linux/errno.h>
		#include <linux/mm.h>
		#include <linux/sched.h>
		#include <linux/slab.h>
		#include <linux/tee_drv.h>
		#include <linux/types.h>
		#include <linux/uaccess.h>
		#include "optee_private.h"
		#include "optee_smc.h"
		#define CREATE_TRACE_POINTS
		#include "optee_trace.h"

		struct optee_call_waiter {
		struct list_head list_node;
		struct completion c;
		};

		static void optee_cq_wait_init(struct optee_call_queue *cq,
		void optee_cq_wait_init(struct optee_call_queue *cq,
		struct optee_call_waiter *w)
		{
		/*
		@@ -47,7 +36,7 @@ static void optee_cq_wait_init(struct optee_call_queue *cq,
		mutex_unlock(&cq->mutex);
		}

		static void optee_cq_wait_for_completion(struct optee_call_queue *cq,
		void optee_cq_wait_for_completion(struct optee_call_queue *cq,
		struct optee_call_waiter *w)
		{
		wait_for_completion(&w->c);
		@@ -74,7 +63,7 @@ static void optee_cq_complete_one(struct optee_call_queue *cq)
		}
		}

		static void optee_cq_wait_final(struct optee_call_queue *cq,
		void optee_cq_wait_final(struct optee_call_queue *cq,
		struct optee_call_waiter *w)
		{
		/*
		@@ -115,97 +104,35 @@ static struct optee_session find_session(struct optee_context_data ctxdata,
		return NULL;
		}

		/**
		* optee_do_call_with_arg() - Do an SMC to OP-TEE in secure world
		* @ctx: calling context
		* @parg: physical address of message to pass to secure world
		*
		* Does and SMC to OP-TEE in secure world and handles eventual resulting
		* Remote Procedure Calls (RPC) from OP-TEE.
		*
		* Returns return code from secure world, 0 is OK
		*/
		u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
		struct tee_shm optee_get_msg_arg(struct tee_context ctx, size_t num_params,
		struct optee_msg_arg **msg_arg)
		{
		struct optee *optee = tee_get_drvdata(ctx->teedev);
		struct optee_call_waiter w;
		struct optee_rpc_param param = { };
		struct optee_call_ctx call_ctx = { };
		u32 ret;

		param.a0 = OPTEE_SMC_CALL_WITH_ARG;
		reg_pair_from_64(&param.a1, &param.a2, parg);
		/* Initialize waiter */
		optee_cq_wait_init(&optee->call_queue, &w);
		while (true) {
		struct arm_smccc_res res;

		trace_optee_invoke_fn_begin(&param);
		optee->invoke_fn(param.a0, param.a1, param.a2, param.a3,
		param.a4, param.a5, param.a6, param.a7,
		&res);
		trace_optee_invoke_fn_end(&param, &res);

		if (res.a0 == OPTEE_SMC_RETURN_ETHREAD_LIMIT) {
		/*
		* Out of threads in secure world, wait for a thread
		* become available.
		*/
		optee_cq_wait_for_completion(&optee->call_queue, &w);
		} else if (OPTEE_SMC_RETURN_IS_RPC(res.a0)) {
		cond_resched();
		param.a0 = res.a0;
		param.a1 = res.a1;
		param.a2 = res.a2;
		param.a3 = res.a3;
		optee_handle_rpc(ctx, &param, &call_ctx);
		} else {
		ret = res.a0;
		break;
		}
		}
		size_t sz = OPTEE_MSG_GET_ARG_SIZE(num_params);
		struct tee_shm *shm;
		struct optee_msg_arg *ma;

		optee_rpc_finalize_call(&call_ctx);
		/*
		* We're done with our thread in secure world, if there's any
		* thread waiters wake up one.
		* rpc_arg_count is set to the number of allocated parameters in
		* the RPC argument struct if a second MSG arg struct is expected.
		* The second arg struct will then be used for RPC.
		*/
		optee_cq_wait_final(&optee->call_queue, &w);

		return ret;
		}

		static struct tee_shm get_msg_arg(struct tee_context ctx, size_t num_params,
		struct optee_msg_arg **msg_arg,
		phys_addr_t *msg_parg)
		{
		int rc;
		struct tee_shm *shm;
		struct optee_msg_arg *ma;
		if (optee->rpc_arg_count)
		sz += OPTEE_MSG_GET_ARG_SIZE(optee->rpc_arg_count);

		shm = tee_shm_alloc(ctx, OPTEE_MSG_GET_ARG_SIZE(num_params),
		TEE_SHM_MAPPED \| TEE_SHM_PRIV);
		shm = tee_shm_alloc(ctx, sz, TEE_SHM_MAPPED \| TEE_SHM_PRIV);
		if (IS_ERR(shm))
		return shm;

		ma = tee_shm_get_va(shm, 0);
		if (IS_ERR(ma)) {
		rc = PTR_ERR(ma);
		goto out;
		tee_shm_free(shm);
		return (void *)ma;
		}

		rc = tee_shm_get_pa(shm, 0, msg_parg);
		if (rc)
		goto out;

		memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
		ma->num_params = num_params;
		*msg_arg = ma;
		out:
		if (rc) {
		tee_shm_free(shm);
		return ERR_PTR(rc);
		}

		return shm;
		}
		@@ -214,16 +141,16 @@ int optee_open_session(struct tee_context *ctx,
		struct tee_ioctl_open_session_arg *arg,
		struct tee_param *param)
		{
		struct optee *optee = tee_get_drvdata(ctx->teedev);
		struct optee_context_data *ctxdata = ctx->data;
		int rc;
		struct tee_shm *shm;
		struct optee_msg_arg *msg_arg;
		phys_addr_t msg_parg;
		struct optee_session *sess = NULL;
		uuid_t client_uuid;

		/* +2 for the meta parameters added below */
		shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg, &msg_parg);
		shm = optee_get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
		if (IS_ERR(shm))
		return PTR_ERR(shm);

		@@ -247,7 +174,8 @@ int optee_open_session(struct tee_context *ctx,
		goto out;
		export_uuid(msg_arg->params[1].u.octets, &client_uuid);

		rc = optee_to_msg_param(msg_arg->params + 2, arg->num_params, param);
		rc = optee->ops->to_msg_param(optee, msg_arg->params + 2,
		arg->num_params, param);
		if (rc)
		goto out;

		@@ -257,7 +185,7 @@ int optee_open_session(struct tee_context *ctx,
		goto out;
		}

		if (optee_do_call_with_arg(ctx, msg_parg)) {
		if (optee->ops->do_call_with_arg(ctx, shm)) {
		msg_arg->ret = TEEC_ERROR_COMMUNICATION;
		msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
		}
		@@ -272,7 +200,8 @@ int optee_open_session(struct tee_context *ctx,
		kfree(sess);
		}

		if (optee_from_msg_param(param, arg->num_params, msg_arg->params + 2)) {
		if (optee->ops->from_msg_param(optee, param, arg->num_params,
		msg_arg->params + 2)) {
		arg->ret = TEEC_ERROR_COMMUNICATION;
		arg->ret_origin = TEEC_ORIGIN_COMMS;
		/* Close session again to avoid leakage */
		@@ -288,12 +217,28 @@ int optee_open_session(struct tee_context *ctx,
		return rc;
		}

		int optee_close_session(struct tee_context *ctx, u32 session)
		int optee_close_session_helper(struct tee_context *ctx, u32 session)
		{
		struct optee_context_data *ctxdata = ctx->data;
		struct tee_shm *shm;
		struct optee *optee = tee_get_drvdata(ctx->teedev);
		struct optee_msg_arg *msg_arg;
		phys_addr_t msg_parg;

		shm = optee_get_msg_arg(ctx, 0, &msg_arg);
		if (IS_ERR(shm))
		return PTR_ERR(shm);

		msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
		msg_arg->session = session;
		optee->ops->do_call_with_arg(ctx, shm);

		tee_shm_free(shm);

		return 0;
		}

		int optee_close_session(struct tee_context *ctx, u32 session)
		{
		struct optee_context_data *ctxdata = ctx->data;
		struct optee_session *sess;

		/* Check that the session is valid and remove it from the list */
		@@ -306,25 +251,16 @@ int optee_close_session(struct tee_context *ctx, u32 session)
		return -EINVAL;
		kfree(sess);

		shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
		if (IS_ERR(shm))
		return PTR_ERR(shm);

		msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
		msg_arg->session = session;
		optee_do_call_with_arg(ctx, msg_parg);

		tee_shm_free(shm);
		return 0;
		return optee_close_session_helper(ctx, session);
		}

		int optee_invoke_func(struct tee_context ctx, struct tee_ioctl_invoke_arg arg,
		struct tee_param *param)
		{
		struct optee *optee = tee_get_drvdata(ctx->teedev);
		struct optee_context_data *ctxdata = ctx->data;
		struct tee_shm *shm;
		struct optee_msg_arg *msg_arg;
		phys_addr_t msg_parg;
		struct optee_session *sess;
		int rc;

		@@ -335,7 +271,7 @@ int optee_invoke_func(struct tee_context ctx, struct tee_ioctl_invoke_arg arg,
		if (!sess)
		return -EINVAL;

		shm = get_msg_arg(ctx, arg->num_params, &msg_arg, &msg_parg);
		shm = optee_get_msg_arg(ctx, arg->num_params, &msg_arg);
		if (IS_ERR(shm))
		return PTR_ERR(shm);
		msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
		@@ -343,16 +279,18 @@ int optee_invoke_func(struct tee_context ctx, struct tee_ioctl_invoke_arg arg,
		msg_arg->session = arg->session;
		msg_arg->cancel_id = arg->cancel_id;

		rc = optee_to_msg_param(msg_arg->params, arg->num_params, param);
		rc = optee->ops->to_msg_param(optee, msg_arg->params, arg->num_params,
		param);
		if (rc)
		goto out;

		if (optee_do_call_with_arg(ctx, msg_parg)) {
		if (optee->ops->do_call_with_arg(ctx, shm)) {
		msg_arg->ret = TEEC_ERROR_COMMUNICATION;
		msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
		}

		if (optee_from_msg_param(param, arg->num_params, msg_arg->params)) {
		if (optee->ops->from_msg_param(optee, param, arg->num_params,
		msg_arg->params)) {
		msg_arg->ret = TEEC_ERROR_COMMUNICATION;
		msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
		}
		@@ -366,10 +304,10 @@ int optee_invoke_func(struct tee_context ctx, struct tee_ioctl_invoke_arg arg,

		int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
		{
		struct optee *optee = tee_get_drvdata(ctx->teedev);
		struct optee_context_data *ctxdata = ctx->data;
		struct tee_shm *shm;
		struct optee_msg_arg *msg_arg;
		phys_addr_t msg_parg;
		struct optee_session *sess;

		/* Check that the session is valid */
		@@ -379,195 +317,19 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
		if (!sess)
		return -EINVAL;

		shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
		shm = optee_get_msg_arg(ctx, 0, &msg_arg);
		if (IS_ERR(shm))
		return PTR_ERR(shm);

		msg_arg->cmd = OPTEE_MSG_CMD_CANCEL;
		msg_arg->session = session;
		msg_arg->cancel_id = cancel_id;
		optee_do_call_with_arg(ctx, msg_parg);
		optee->ops->do_call_with_arg(ctx, shm);

		tee_shm_free(shm);
		return 0;
		}

		/**
		* optee_enable_shm_cache() - Enables caching of some shared memory allocation
		* in OP-TEE
		* @optee: main service struct
		*/
		void optee_enable_shm_cache(struct optee *optee)
		{
		struct optee_call_waiter w;

		/* We need to retry until secure world isn't busy. */
		optee_cq_wait_init(&optee->call_queue, &w);
		while (true) {
		struct arm_smccc_res res;

		optee->invoke_fn(OPTEE_SMC_ENABLE_SHM_CACHE, 0, 0, 0, 0, 0, 0,
		0, &res);
		if (res.a0 == OPTEE_SMC_RETURN_OK)
		break;
		optee_cq_wait_for_completion(&optee->call_queue, &w);
		}
		optee_cq_wait_final(&optee->call_queue, &w);
		}

		/**
		* __optee_disable_shm_cache() - Disables caching of some shared memory
		* allocation in OP-TEE
		* @optee: main service struct
		* @is_mapped: true if the cached shared memory addresses were mapped by this
		* kernel, are safe to dereference, and should be freed
		*/
		static void __optee_disable_shm_cache(struct optee *optee, bool is_mapped)
		{
		struct optee_call_waiter w;

		/* We need to retry until secure world isn't busy. */
		optee_cq_wait_init(&optee->call_queue, &w);
		while (true) {
		union {
		struct arm_smccc_res smccc;
		struct optee_smc_disable_shm_cache_result result;
		} res;

		optee->invoke_fn(OPTEE_SMC_DISABLE_SHM_CACHE, 0, 0, 0, 0, 0, 0,
		0, &res.smccc);
		if (res.result.status == OPTEE_SMC_RETURN_ENOTAVAIL)
		break; /* All shm's freed */
		if (res.result.status == OPTEE_SMC_RETURN_OK) {
		struct tee_shm *shm;

		/*
		* Shared memory references that were not mapped by
		* this kernel must be ignored to prevent a crash.
		*/
		if (!is_mapped)
		continue;

		shm = reg_pair_to_ptr(res.result.shm_upper32,
		res.result.shm_lower32);
		tee_shm_free(shm);
		} else {
		optee_cq_wait_for_completion(&optee->call_queue, &w);
		}
		}
		optee_cq_wait_final(&optee->call_queue, &w);
		}

		/**
		* optee_disable_shm_cache() - Disables caching of mapped shared memory
		* allocations in OP-TEE
		* @optee: main service struct
		*/
		void optee_disable_shm_cache(struct optee *optee)
		{
		return __optee_disable_shm_cache(optee, true);
		}

		/**
		* optee_disable_unmapped_shm_cache() - Disables caching of shared memory
		* allocations in OP-TEE which are not
		* currently mapped
		* @optee: main service struct
		*/
		void optee_disable_unmapped_shm_cache(struct optee *optee)
		{
		return __optee_disable_shm_cache(optee, false);
		}

		#define PAGELIST_ENTRIES_PER_PAGE \
		((OPTEE_MSG_NONCONTIG_PAGE_SIZE / sizeof(u64)) - 1)

		/**
		* optee_fill_pages_list() - write list of user pages to given shared
		* buffer.
		*
		* @dst: page-aligned buffer where list of pages will be stored
		* @pages: array of pages that represents shared buffer
		* @num_pages: number of entries in @pages
		* @page_offset: offset of user buffer from page start
		*
		* @dst should be big enough to hold list of user page addresses and
		* links to the next pages of buffer
		*/
		void optee_fill_pages_list(u64 dst, struct page *pages, int num_pages,
		size_t page_offset)
		{
		int n = 0;
		phys_addr_t optee_page;
		/*
		* Refer to OPTEE_MSG_ATTR_NONCONTIG description in optee_msg.h
		* for details.
		*/
		struct {
		u64 pages_list[PAGELIST_ENTRIES_PER_PAGE];
		u64 next_page_data;
		} *pages_data;

		/*
		* Currently OP-TEE uses 4k page size and it does not looks
		* like this will change in the future. On other hand, there are
		* no know ARM architectures with page size < 4k.
		* Thus the next built assert looks redundant. But the following
		* code heavily relies on this assumption, so it is better be
		* safe than sorry.
		*/
		BUILD_BUG_ON(PAGE_SIZE < OPTEE_MSG_NONCONTIG_PAGE_SIZE);

		pages_data = (void *)dst;
		/*
		* If linux page is bigger than 4k, and user buffer offset is
		* larger than 4k/8k/12k/etc this will skip first 4k pages,
		* because they bear no value data for OP-TEE.
		*/
		optee_page = page_to_phys(*pages) +
		round_down(page_offset, OPTEE_MSG_NONCONTIG_PAGE_SIZE);

		while (true) {
		pages_data->pages_list[n++] = optee_page;

		if (n == PAGELIST_ENTRIES_PER_PAGE) {
		pages_data->next_page_data =
		virt_to_phys(pages_data + 1);
		pages_data++;
		n = 0;
		}

		optee_page += OPTEE_MSG_NONCONTIG_PAGE_SIZE;
		if (!(optee_page & ~PAGE_MASK)) {
		if (!--num_pages)
		break;
		pages++;
		optee_page = page_to_phys(*pages);
		}
		}
		}

		/*
		* The final entry in each pagelist page is a pointer to the next
		* pagelist page.
		*/
		static size_t get_pages_list_size(size_t num_entries)
		{
		int pages = DIV_ROUND_UP(num_entries, PAGELIST_ENTRIES_PER_PAGE);

		return pages * OPTEE_MSG_NONCONTIG_PAGE_SIZE;
		}

		u64 *optee_allocate_pages_list(size_t num_entries)
		{
		return alloc_pages_exact(get_pages_list_size(num_entries), GFP_KERNEL);
		}

		void optee_free_pages_list(void *list, size_t num_entries)
		{
		free_pages_exact(list, get_pages_list_size(num_entries));
		}

		static bool is_normal_memory(pgprot_t p)
		{
		#if defined(CONFIG_ARM)
		@@ -591,7 +353,7 @@ static int __check_mem_type(struct vm_area_struct *vma, unsigned long end)
		return -EINVAL;
		}

		static int check_mem_type(unsigned long start, size_t num_pages)
		int optee_check_mem_type(unsigned long start, size_t num_pages)
		{
		struct mm_struct *mm = current->mm;
		int rc;
		@@ -610,94 +372,3 @@ static int check_mem_type(unsigned long start, size_t num_pages)

		return rc;
		}

		int optee_shm_register(struct tee_context ctx, struct tee_shm shm,
		struct page **pages, size_t num_pages,
		unsigned long start)
		{
		struct tee_shm *shm_arg = NULL;
		struct optee_msg_arg *msg_arg;
		u64 *pages_list;
		phys_addr_t msg_parg;
		int rc;

		if (!num_pages)
		return -EINVAL;

		rc = check_mem_type(start, num_pages);
		if (rc)
		return rc;

		pages_list = optee_allocate_pages_list(num_pages);
		if (!pages_list)
		return -ENOMEM;

		shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
		if (IS_ERR(shm_arg)) {
		rc = PTR_ERR(shm_arg);
		goto out;
		}

		optee_fill_pages_list(pages_list, pages, num_pages,
		tee_shm_get_page_offset(shm));

		msg_arg->cmd = OPTEE_MSG_CMD_REGISTER_SHM;
		msg_arg->params->attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT \|
		OPTEE_MSG_ATTR_NONCONTIG;
		msg_arg->params->u.tmem.shm_ref = (unsigned long)shm;
		msg_arg->params->u.tmem.size = tee_shm_get_size(shm);
		/*
		* In the least bits of msg_arg->params->u.tmem.buf_ptr we
		* store buffer offset from 4k page, as described in OP-TEE ABI.
		*/
		msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) \|
		(tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));

		if (optee_do_call_with_arg(ctx, msg_parg) \|\|
		msg_arg->ret != TEEC_SUCCESS)
		rc = -EINVAL;

		tee_shm_free(shm_arg);
		out:
		optee_free_pages_list(pages_list, num_pages);
		return rc;
		}

		int optee_shm_unregister(struct tee_context ctx, struct tee_shm shm)
		{
		struct tee_shm *shm_arg;
		struct optee_msg_arg *msg_arg;
		phys_addr_t msg_parg;
		int rc = 0;

		shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
		if (IS_ERR(shm_arg))
		return PTR_ERR(shm_arg);

		msg_arg->cmd = OPTEE_MSG_CMD_UNREGISTER_SHM;

		msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
		msg_arg->params[0].u.rmem.shm_ref = (unsigned long)shm;

		if (optee_do_call_with_arg(ctx, msg_parg) \|\|
		msg_arg->ret != TEEC_SUCCESS)
		rc = -EINVAL;
		tee_shm_free(shm_arg);
		return rc;
		}

		int optee_shm_register_supp(struct tee_context ctx, struct tee_shm shm,
		struct page **pages, size_t num_pages,
		unsigned long start)
		{
		/*
		* We don't want to register supplicant memory in OP-TEE.
		* Instead information about it will be passed in RPC code.
		*/
		return check_mem_type(start, num_pages);
		}

		int optee_shm_unregister_supp(struct tee_context ctx, struct tee_shm shm)
		{
		return 0;
		}

drivers/tee/optee/core.c

+75 −645

File changed.

Preview size limit exceeded, changes collapsed.

drivers/tee/optee/device.c

+22 −0

Original line number	Diff line number	Diff line
		@@ -53,6 +53,13 @@ static int get_devices(struct tee_context *ctx, u32 session,
		return 0;
		}

		static void optee_release_device(struct device *dev)
		{
		struct tee_client_device *optee_device = to_tee_client_device(dev);

		kfree(optee_device);
		}

		static int optee_register_device(const uuid_t *device_uuid)
		{
		struct tee_client_device *optee_device = NULL;
		@@ -63,6 +70,7 @@ static int optee_register_device(const uuid_t *device_uuid)
		return -ENOMEM;

		optee_device->dev.bus = &tee_bus_type;
		optee_device->dev.release = optee_release_device;
		if (dev_set_name(&optee_device->dev, "optee-ta-%pUb", device_uuid)) {
		kfree(optee_device);
		return -ENOMEM;
		@@ -154,3 +162,17 @@ int optee_enumerate_devices(u32 func)
		{
		return __optee_enumerate_devices(func);
		}

		static int __optee_unregister_device(struct device dev, void data)
		{
		if (!strncmp(dev_name(dev), "optee-ta", strlen("optee-ta")))
		device_unregister(dev);

		return 0;
		}

		void optee_unregister_devices(void)
		{
		bus_for_each_dev(&tee_bus_type, NULL, NULL,
		__optee_unregister_device);
		}

drivers/tee/optee/ffa_abi.c

0 → 100644

+911 −0

File added.

Preview size limit exceeded, changes collapsed.