Merge tag 'tee-drv-dynamic-shm-for-v4.16' of... (bad19e0d) · Commits · 戴 / test

drivers/tee/optee/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -4,3 +4,4 @@ optee-objs += core.o
		optee-objs += call.o
		optee-objs += rpc.o
		optee-objs += supp.o
		optee-objs += shm_pool.o

drivers/tee/optee/call.c

+178 −1

Original line number	Diff line number	Diff line
		@@ -11,6 +11,7 @@
		* GNU General Public License for more details.
		*
		*/
		#include <asm/pgtable.h>
		#include <linux/arm-smccc.h>
		#include <linux/device.h>
		#include <linux/err.h>
		@@ -135,6 +136,7 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
		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;
		@@ -159,13 +161,14 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
		param.a1 = res.a1;
		param.a2 = res.a2;
		param.a3 = res.a3;
		optee_handle_rpc(ctx, &param);
		optee_handle_rpc(ctx, &param, &call_ctx);
		} else {
		ret = res.a0;
		break;
		}
		}

		optee_rpc_finalize_call(&call_ctx);
		/*
		* We're done with our thread in secure world, if there's any
		* thread waiters wake up one.
		@@ -442,3 +445,177 @@ void optee_disable_shm_cache(struct optee *optee)
		}
		optee_cq_wait_final(&optee->call_queue, &w);
		}

		#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));
		}

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

		if (!num_pages)
		return -EINVAL;

		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)
		{
		/*
		* We don't want to register supplicant memory in OP-TEE.
		* Instead information about it will be passed in RPC code.
		*/
		return 0;
		}

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

drivers/tee/optee/core.c

+119 −33

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@
		#include <linux/uaccess.h>
		#include "optee_private.h"
		#include "optee_smc.h"
		#include "shm_pool.h"

		#define DRIVER_NAME "optee"

		@@ -97,6 +98,25 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params,
		return rc;
		}
		break;
		case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:
		case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
		case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
		p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
		attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
		p->u.memref.size = mp->u.rmem.size;
		shm = (struct tee_shm *)(unsigned long)
		mp->u.rmem.shm_ref;

		if (!shm) {
		p->u.memref.shm_offs = 0;
		p->u.memref.shm = NULL;
		break;
		}
		p->u.memref.shm_offs = mp->u.rmem.offs;
		p->u.memref.shm = shm;

		break;

		default:
		return -EINVAL;
		}
		@@ -104,6 +124,46 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params,
		return 0;
		}

		static int to_msg_param_tmp_mem(struct optee_msg_param *mp,
		const struct tee_param *p)
		{
		int rc;
		phys_addr_t pa;

		mp->attr = OPTEE_MSG_ATTR_TYPE_TMEM_INPUT + p->attr -
		TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;

		mp->u.tmem.shm_ref = (unsigned long)p->u.memref.shm;
		mp->u.tmem.size = p->u.memref.size;

		if (!p->u.memref.shm) {
		mp->u.tmem.buf_ptr = 0;
		return 0;
		}

		rc = tee_shm_get_pa(p->u.memref.shm, p->u.memref.shm_offs, &pa);
		if (rc)
		return rc;

		mp->u.tmem.buf_ptr = pa;
		mp->attr \|= OPTEE_MSG_ATTR_CACHE_PREDEFINED <<
		OPTEE_MSG_ATTR_CACHE_SHIFT;

		return 0;
		}

		static int to_msg_param_reg_mem(struct optee_msg_param *mp,
		const struct tee_param *p)
		{
		mp->attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT + p->attr -
		TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;

		mp->u.rmem.shm_ref = (unsigned long)p->u.memref.shm;
		mp->u.rmem.size = p->u.memref.size;
		mp->u.rmem.offs = p->u.memref.shm_offs;
		return 0;
		}

		/**
		* optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters
		* @msg_params: OPTEE_MSG parameters
		@@ -116,7 +176,6 @@ int optee_to_msg_param(struct optee_msg_param *msg_params, size_t num_params,
		{
		int rc;
		size_t n;
		phys_addr_t pa;

		for (n = 0; n < num_params; n++) {
		const struct tee_param *p = params + n;
		@@ -139,22 +198,12 @@ int optee_to_msg_param(struct optee_msg_param *msg_params, size_t num_params,
		case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
		case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
		case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
		mp->attr = OPTEE_MSG_ATTR_TYPE_TMEM_INPUT +
		p->attr -
		TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
		mp->u.tmem.shm_ref = (unsigned long)p->u.memref.shm;
		mp->u.tmem.size = p->u.memref.size;
		if (!p->u.memref.shm) {
		mp->u.tmem.buf_ptr = 0;
		break;
		}
		rc = tee_shm_get_pa(p->u.memref.shm,
		p->u.memref.shm_offs, &pa);
		if (tee_shm_is_registered(p->u.memref.shm))
		rc = to_msg_param_reg_mem(mp, p);
		else
		rc = to_msg_param_tmp_mem(mp, p);
		if (rc)
		return rc;
		mp->u.tmem.buf_ptr = pa;
		mp->attr \|= OPTEE_MSG_ATTR_CACHE_PREDEFINED <<
		OPTEE_MSG_ATTR_CACHE_SHIFT;
		break;
		default:
		return -EINVAL;
		@@ -171,6 +220,10 @@ static void optee_get_version(struct tee_device *teedev,
		.impl_caps = TEE_OPTEE_CAP_TZ,
		.gen_caps = TEE_GEN_CAP_GP,
		};
		struct optee *optee = tee_get_drvdata(teedev);

		if (optee->sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
		v.gen_caps \|= TEE_GEN_CAP_REG_MEM;
		*vers = v;
		}

		@@ -264,6 +317,8 @@ static const struct tee_driver_ops optee_ops = {
		.close_session = optee_close_session,
		.invoke_func = optee_invoke_func,
		.cancel_req = optee_cancel_req,
		.shm_register = optee_shm_register,
		.shm_unregister = optee_shm_unregister,
		};

		static const struct tee_desc optee_desc = {
		@@ -278,6 +333,8 @@ static const struct tee_driver_ops optee_supp_ops = {
		.release = optee_release,
		.supp_recv = optee_supp_recv,
		.supp_send = optee_supp_send,
		.shm_register = optee_shm_register_supp,
		.shm_unregister = optee_shm_unregister_supp,
		};

		static const struct tee_desc optee_supp_desc = {
		@@ -342,21 +399,22 @@ static bool optee_msg_exchange_capabilities(optee_invoke_fn *invoke_fn,
		}

		static struct tee_shm_pool *
		optee_config_shm_memremap(optee_invoke_fn invoke_fn, void *memremaped_shm)
		optee_config_shm_memremap(optee_invoke_fn invoke_fn, void *memremaped_shm,
		u32 sec_caps)
		{
		union {
		struct arm_smccc_res smccc;
		struct optee_smc_get_shm_config_result result;
		} res;
		struct tee_shm_pool *pool;
		unsigned long vaddr;
		phys_addr_t paddr;
		size_t size;
		phys_addr_t begin;
		phys_addr_t end;
		void *va;
		struct tee_shm_pool_mem_info priv_info;
		struct tee_shm_pool_mem_info dmabuf_info;
		struct tee_shm_pool_mgr *priv_mgr;
		struct tee_shm_pool_mgr *dmabuf_mgr;
		void *rc;

		invoke_fn(OPTEE_SMC_GET_SHM_CONFIG, 0, 0, 0, 0, 0, 0, 0, &res.smccc);
		if (res.result.status != OPTEE_SMC_RETURN_OK) {
		@@ -386,22 +444,49 @@ optee_config_shm_memremap(optee_invoke_fn invoke_fn, void *memremaped_shm)
		}
		vaddr = (unsigned long)va;

		priv_info.vaddr = vaddr;
		priv_info.paddr = paddr;
		priv_info.size = OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE;
		dmabuf_info.vaddr = vaddr + OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE;
		dmabuf_info.paddr = paddr + OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE;
		dmabuf_info.size = size - OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE;

		pool = tee_shm_pool_alloc_res_mem(&priv_info, &dmabuf_info);
		if (IS_ERR(pool)) {
		memunmap(va);
		goto out;
		}
		/*
		* If OP-TEE can work with unregistered SHM, we will use own pool
		* for private shm
		*/
		if (sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM) {
		rc = optee_shm_pool_alloc_pages();
		if (IS_ERR(rc))
		goto err_memunmap;
		priv_mgr = rc;
		} else {
		const size_t sz = OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE;

		rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, sz,
		3 /* 8 bytes aligned */);
		if (IS_ERR(rc))
		goto err_memunmap;
		priv_mgr = rc;

		vaddr += sz;
		paddr += sz;
		size -= sz;
		}

		rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, size, PAGE_SHIFT);
		if (IS_ERR(rc))
		goto err_free_priv_mgr;
		dmabuf_mgr = rc;

		rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
		if (IS_ERR(rc))
		goto err_free_dmabuf_mgr;

		*memremaped_shm = va;
		out:
		return pool;

		return rc;

		err_free_dmabuf_mgr:
		tee_shm_pool_mgr_destroy(dmabuf_mgr);
		err_free_priv_mgr:
		tee_shm_pool_mgr_destroy(priv_mgr);
		err_memunmap:
		memunmap(va);
		return rc;
		}

		/* Simple wrapper functions to be able to use a function pointer */
		@@ -479,7 +564,7 @@ static struct optee optee_probe(struct device_node np)
		if (!(sec_caps & OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM))
		return ERR_PTR(-EINVAL);

		pool = optee_config_shm_memremap(invoke_fn, &memremaped_shm);
		pool = optee_config_shm_memremap(invoke_fn, &memremaped_shm, sec_caps);
		if (IS_ERR(pool))
		return (void *)pool;

		@@ -490,6 +575,7 @@ static struct optee optee_probe(struct device_node np)
		}

		optee->invoke_fn = invoke_fn;
		optee->sec_caps = sec_caps;

		teedev = tee_device_alloc(&optee_desc, NULL, pool, optee);
		if (IS_ERR(teedev)) {

drivers/tee/optee/optee_msg.h

+32 −6

Original line number	Diff line number	Diff line
		@@ -67,11 +67,32 @@
		#define OPTEE_MSG_ATTR_META BIT(8)

		/*
		* The temporary shared memory object is not physically contigous and this
		* temp memref is followed by another fragment until the last temp memref
		* that doesn't have this bit set.
		* Pointer to a list of pages used to register user-defined SHM buffer.
		* Used with OPTEE_MSG_ATTR_TYPE_TMEM_*.
		* buf_ptr should point to the beginning of the buffer. Buffer will contain
		* list of page addresses. OP-TEE core can reconstruct contiguous buffer from
		* that page addresses list. Page addresses are stored as 64 bit values.
		* Last entry on a page should point to the next page of buffer.
		* Every entry in buffer should point to a 4k page beginning (12 least
		* significant bits must be equal to zero).
		*
		* 12 least significant bints of optee_msg_param.u.tmem.buf_ptr should hold page
		* offset of the user buffer.
		*
		* So, entries should be placed like members of this structure:
		*
		* struct page_data {
		* uint64_t pages_array[OPTEE_MSG_NONCONTIG_PAGE_SIZE/sizeof(uint64_t) - 1];
		* uint64_t next_page_data;
		* };
		*
		* Structure is designed to exactly fit into the page size
		* OPTEE_MSG_NONCONTIG_PAGE_SIZE which is a standard 4KB page.
		*
		* The size of 4KB is chosen because this is the smallest page size for ARM
		* architectures. If REE uses larger pages, it should divide them to 4KB ones.
		*/
		#define OPTEE_MSG_ATTR_FRAGMENT BIT(9)
		#define OPTEE_MSG_ATTR_NONCONTIG BIT(9)

		/*
		* Memory attributes for caching passed with temp memrefs. The actual value
		@@ -94,6 +115,11 @@
		#define OPTEE_MSG_LOGIN_APPLICATION_USER 0x00000005
		#define OPTEE_MSG_LOGIN_APPLICATION_GROUP 0x00000006

		/*
		* Page size used in non-contiguous buffer entries
		*/
		#define OPTEE_MSG_NONCONTIG_PAGE_SIZE 4096

		/**
		* struct optee_msg_param_tmem - temporary memory reference parameter
		* @buf_ptr: Address of the buffer
		@@ -145,8 +171,8 @@ struct optee_msg_param_value {
		*
		* @attr & OPTEE_MSG_ATTR_TYPE_MASK indicates if tmem, rmem or value is used in
		* the union. OPTEE_MSG_ATTR_TYPE_VALUE_* indicates value,
		* OPTEE_MSG_ATTR_TYPE_TMEM_* indicates tmem and
		* OPTEE_MSG_ATTR_TYPE_RMEM_* indicates rmem.
		* OPTEE_MSG_ATTR_TYPE_TMEM_* indicates @tmem and
		* OPTEE_MSG_ATTR_TYPE_RMEM_* indicates @rmem,
		* OPTEE_MSG_ATTR_TYPE_NONE indicates that none of the members are used.
		*/
		struct optee_msg_param {

drivers/tee/optee/optee_private.h

+26 −1

Original line number	Diff line number	Diff line
		@@ -84,6 +84,8 @@ struct optee_supp {
		* @supp: supplicant synchronization struct for RPC to supplicant
		* @pool: shared memory pool
		* @memremaped_shm virtual address of memory in shared memory pool
		* @sec_caps: secure world capabilities defined by
		* OPTEE_SMC_SEC_CAP_* in optee_smc.h
		*/
		struct optee {
		struct tee_device *supp_teedev;
		@@ -94,6 +96,7 @@ struct optee {
		struct optee_supp supp;
		struct tee_shm_pool *pool;
		void *memremaped_shm;
		u32 sec_caps;
		};

		struct optee_session {
		@@ -118,7 +121,16 @@ struct optee_rpc_param {
		u32 a7;
		};

		void optee_handle_rpc(struct tee_context ctx, struct optee_rpc_param param);
		/* Holds context that is preserved during one STD call */
		struct optee_call_ctx {
		/* information about pages list used in last allocation */
		void *pages_list;
		size_t num_entries;
		};

		void optee_handle_rpc(struct tee_context ctx, struct optee_rpc_param param,
		struct optee_call_ctx *call_ctx);
		void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx);

		void optee_wait_queue_init(struct optee_wait_queue *wq);
		void optee_wait_queue_exit(struct optee_wait_queue *wq);
		@@ -149,11 +161,24 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session);
		void optee_enable_shm_cache(struct optee *optee);
		void optee_disable_shm_cache(struct optee *optee);

		int optee_shm_register(struct tee_context ctx, struct tee_shm shm,
		struct page **pages, size_t num_pages);
		int optee_shm_unregister(struct tee_context ctx, struct tee_shm shm);

		int optee_shm_register_supp(struct tee_context ctx, struct tee_shm shm,
		struct page **pages, size_t num_pages);
		int optee_shm_unregister_supp(struct tee_context ctx, struct tee_shm shm);

		int optee_from_msg_param(struct tee_param *params, size_t num_params,
		const struct optee_msg_param *msg_params);
		int optee_to_msg_param(struct optee_msg_param *msg_params, size_t num_params,
		const struct tee_param *params);

		u64 *optee_allocate_pages_list(size_t num_entries);
		void optee_free_pages_list(void *array, size_t num_entries);
		void optee_fill_pages_list(u64 dst, struct page *pages, int num_pages,
		size_t page_offset);

		/*
		* Small helpers
		*/

Admin message