From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.9 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6B254C4743D for ; Fri, 11 Jun 2021 07:45:33 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 34C4E60BD3 for ; Fri, 11 Jun 2021 07:45:33 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 34C4E60BD3 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=C5f9aT0sDqnm2FLpeEzXJA7Z8hbJGRiFmdYNwJAyBoE=; b=dh71xY5D++Kdbr ctdkGo+8kHwNxm9TcO/7zYdnZuKA387eJ2fuFhCxl/easZEUZF6r2+KCe1QDaQYKS8Uz6xGG6qmrh 8P3k0S6JSkjBajiBc6xw9sCiXW4ks00SnmuTkJgBIRFoaPT3DJR/+0j65N4nd1COUc0scXXspu8Iy KzO43Aa2dko5JL9Idtf02NOzT+ZF86GLPBnpUQkhxvGr33VJmQXpQkXqzzq2GdKZUgOaC2JRHFomK BUg4WHsxMBkMFa4Jrof5EmawTcVKJoWP53sppacxBM8RPobOIUlYOMNN+asefXgUUhWm01My6aPd6 8LXa/t62TRnozfzQzN5g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1lrboz-004BpV-SE; Fri, 11 Jun 2021 07:43:18 +0000 Received: from mail-lj1-f172.google.com ([209.85.208.172]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1lrbov-004Box-03 for linux-arm-kernel@lists.infradead.org; Fri, 11 Jun 2021 07:43:15 +0000 Received: by mail-lj1-f172.google.com with SMTP id e11so8326063ljn.13 for ; Fri, 11 Jun 2021 00:43:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:in-reply-to; bh=Kw+FU3qzojv4u0PEEcHRHhktciBtC+NnGgOLFwUlevc=; b=xBqE3gDnwQUpn13sxz3j4KlHPql7Yk2k++4Y1gKplwCDH3eyOVtyROql+rNoOvIMon hjlgE2Sab4qve0FQ9kgetFH/niSP6cwDu1GeWUqwed7k2wFpclJKjTYimam+k4X2cntN LeJZzMfkGtV/BZwWItVdDt1JISSZQ3AJGgXQ25MqDC5vIQJ0yhI7nqh8X7jskMwZcI7V foqmSBKgCuMMOpdOSxbR3NJHQ/jbO249LPhdAeKXIoKrHwRltakCy2+W6CBFqlvMJXLQ uPFY0IYM2prqvEfLT9yFgoRg6SmFHtKMyGQYIdvFDIZbE2VfS76YSpu9eMwx6wq7JSha kGsg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:in-reply-to; bh=Kw+FU3qzojv4u0PEEcHRHhktciBtC+NnGgOLFwUlevc=; b=QH+AwamElFUrWCcjQPwZGZM89Q8Mp72OomQQlN4NqL/S6yT+S5izxtGu6zGsYvr83G kpWi8HQB2kbuefWryJchIeHB0TD32KISICD9vV+wE5SkLgqlbB6gZoFAgT1a2N45Gwta zQ2vLPpCoWK92fGc1KQLHefzEiCKnef88EmAiw51rifvOVLU5OVZQHaXRFlf7s2pbgDP o4OCpiWFT6FSpv2OOY3nO9J/6Op2P4jU/IMIZ+iSAjpjgKfHYVeUapxnNUqC1xuNlR1g zstBaikJr4fccYz/44dupxyy3A2PLRxSLPhryZoukUZndYkgd5qMfbCw+yIxTn7lE2xU zYlw== X-Gm-Message-State: AOAM530fWNsmMWDFFnuvOO5tfV5HdTSi6C94bP60HHogiCV84aS7Wdhm TOzezarVoXbqzKM1xdA/Jofn4g== X-Google-Smtp-Source: ABdhPJz0Tmd6bITHxsZeWMp4hDaufXQA9CP2DO0GrXArxsPGdH3Vr8n+QmRPOibMwaaHEMrF+Tt35g== X-Received: by 2002:a2e:b5b5:: with SMTP id f21mr1981357ljn.479.1623397328996; Fri, 11 Jun 2021 00:42:08 -0700 (PDT) Received: from jade (h-79-136-85-3.A175.priv.bahnhof.se. [79.136.85.3]) by smtp.gmail.com with ESMTPSA id g20sm608632lja.2.2021.06.11.00.42.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 11 Jun 2021 00:42:08 -0700 (PDT) Date: Fri, 11 Jun 2021 09:42:07 +0200 From: Jens Wiklander To: Tyler Hicks Cc: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, op-tee@lists.trustedfirmware.org, Sumit Garg , Herbert Xu , Sakkinen , Sasha Levin , Thirupathaiah Annapureddy , Vikas Gupta , "David S . Miller" Subject: Re: [PATCH 7/7] tee: replace tee_shm_alloc() Message-ID: <20210611074207.GE2753553@jade> References: <20210609102324.2222332-1-jens.wiklander@linaro.org> <20210609102324.2222332-8-jens.wiklander@linaro.org> <20210609153215.GK4910@sequoia> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20210609153215.GK4910@sequoia> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210611_004313_091611_D08A7895 X-CRM114-Status: GOOD ( 41.58 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org On Wed, Jun 09, 2021 at 10:32:15AM -0500, Tyler Hicks wrote: > On 2021-06-09 12:23:24, Jens Wiklander wrote: > > tee_shm_alloc() is replaced by three new functions, > > > > tee_shm_alloc_user_buf() - for user mode allocations, replacing passing > > the flags TEE_SHM_MAPPED | TEE_SHM_DMA_BUF > > > > tee_shm_alloc_kernel_buf() - for kernel mode allocations, slightly > > optimized compared to using the flags TEE_SHM_MAPPED | TEE_SHM_DMA_BUF > > since we now can avoid using the dma-buf registration. > > > > tee_shm_alloc_anon_kernel_buf() - for TEE driver internal use only > > allowing decoupling a shared memory object from its original > > tee_context. > > > > This also makes the interface easier to use as we can get rid of the > > somewhat hard to use flags parameter. > > > > The TEE subsystem and the TEE drivers are updated to use the new > > functions instead. > > > > Signed-off-by: Jens Wiklander > > --- > > drivers/tee/optee/call.c | 16 ++-- > > drivers/tee/optee/core.c | 4 +- > > drivers/tee/optee/device.c | 5 +- > > drivers/tee/optee/rpc.c | 8 +- > > drivers/tee/tee_core.c | 2 +- > > drivers/tee/tee_shm.c | 186 +++++++++++++++++++++++++++---------- > > include/linux/tee_drv.h | 19 +--- > > 7 files changed, 156 insertions(+), 84 deletions(-) > > > > diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c > > index 6132cc8d014c..f31257649c0e 100644 > > --- a/drivers/tee/optee/call.c > > +++ b/drivers/tee/optee/call.c > > @@ -183,8 +183,8 @@ static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params, > > struct tee_shm *shm; > > struct optee_msg_arg *ma; > > > > - shm = tee_shm_alloc(ctx, OPTEE_MSG_GET_ARG_SIZE(num_params), > > - TEE_SHM_MAPPED); > > + shm = tee_shm_alloc_anon_kernel_buf(ctx, > > + OPTEE_MSG_GET_ARG_SIZE(num_params)); > > The error handling in get_msg_arg() should be updated to call > tee_shm_free_anon_kernel_buf() instead of tee_shm_free(). You're right, I'll fix. > > > if (IS_ERR(shm)) > > return shm; > > > > @@ -281,7 +281,7 @@ int optee_open_session(struct tee_context *ctx, > > arg->ret_origin = msg_arg->ret_origin; > > } > > out: > > - tee_shm_free(shm); > > + tee_shm_free_anon_kernel_buf(ctx, shm); > > > > return rc; > > } > > @@ -312,7 +312,7 @@ int optee_close_session(struct tee_context *ctx, u32 session) > > msg_arg->session = session; > > optee_do_call_with_arg(ctx, msg_parg); > > > > - tee_shm_free(shm); > > + tee_shm_free_anon_kernel_buf(ctx, shm); > > return 0; > > } > > > > @@ -358,7 +358,7 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg, > > arg->ret = msg_arg->ret; > > arg->ret_origin = msg_arg->ret_origin; > > out: > > - tee_shm_free(shm); > > + tee_shm_free_anon_kernel_buf(ctx, shm); > > return rc; > > } > > > > @@ -386,7 +386,7 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session) > > msg_arg->cancel_id = cancel_id; > > optee_do_call_with_arg(ctx, msg_parg); > > > > - tee_shm_free(shm); > > + tee_shm_free_anon_kernel_buf(ctx, shm); > > return 0; > > } > > > > @@ -625,7 +625,7 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm, > > msg_arg->ret != TEEC_SUCCESS) > > rc = -EINVAL; > > > > - tee_shm_free(shm_arg); > > + tee_shm_free_anon_kernel_buf(ctx, shm_arg); > > out: > > optee_free_pages_list(pages_list, num_pages); > > return rc; > > @@ -650,7 +650,7 @@ int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm) > > if (optee_do_call_with_arg(ctx, msg_parg) || > > msg_arg->ret != TEEC_SUCCESS) > > rc = -EINVAL; > > - tee_shm_free(shm_arg); > > + tee_shm_free_anon_kernel_buf(ctx, shm_arg); > > return rc; > > } > > > > diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c > > index 0c287345f9fe..a15dc3881636 100644 > > --- a/drivers/tee/optee/core.c > > +++ b/drivers/tee/optee/core.c > > @@ -277,7 +277,7 @@ static void optee_release(struct tee_context *ctx) > > if (!ctxdata) > > return; > > > > - shm = tee_shm_alloc(ctx, sizeof(struct optee_msg_arg), TEE_SHM_MAPPED); > > + shm = tee_shm_alloc_anon_kernel_buf(ctx, sizeof(struct optee_msg_arg)); > > if (!IS_ERR(shm)) { > > arg = tee_shm_get_va(shm, 0); > > /* > > @@ -305,7 +305,7 @@ static void optee_release(struct tee_context *ctx) > > kfree(ctxdata); > > > > if (!IS_ERR(shm)) > > - tee_shm_free(shm); > > + tee_shm_free_anon_kernel_buf(ctx, shm); > > > > ctx->data = NULL; > > > > diff --git a/drivers/tee/optee/device.c b/drivers/tee/optee/device.c > > index ec1d24693eba..5a5bf86b1b95 100644 > > --- a/drivers/tee/optee/device.c > > +++ b/drivers/tee/optee/device.c > > @@ -113,10 +113,9 @@ static int __optee_enumerate_devices(u32 func) > > if (rc < 0 || !shm_size) > > goto out_sess; > > > > - device_shm = tee_shm_alloc(ctx, shm_size, > > - TEE_SHM_MAPPED | TEE_SHM_DMA_BUF); > > + device_shm = tee_shm_alloc_kernel_buf(ctx, shm_size); > > The error handling in the 'err' label needs to use > tee_shm_free_anon_kernel_buf() instead of tee_shm_free(). I'll update with tee_shm_free_kernel_buf() as suggested in your next mail. > > > if (IS_ERR(device_shm)) { > > - pr_err("tee_shm_alloc failed\n"); > > + pr_err("tee_shm_alloc_kernel_buf failed\n"); > > rc = PTR_ERR(device_shm); > > goto out_sess; > > } > > diff --git a/drivers/tee/optee/rpc.c b/drivers/tee/optee/rpc.c > > index 1849180b0278..9108aedb3eee 100644 > > --- a/drivers/tee/optee/rpc.c > > +++ b/drivers/tee/optee/rpc.c > > @@ -314,7 +314,7 @@ static void handle_rpc_func_cmd_shm_alloc(struct tee_context *ctx, > > shm = cmd_alloc_suppl(ctx, sz); > > break; > > case OPTEE_RPC_SHM_TYPE_KERNEL: > > - shm = tee_shm_alloc(ctx, sz, TEE_SHM_MAPPED); > > + shm = tee_shm_alloc_anon_kernel_buf(ctx, sz); > > The error handling in the 'bad' label still uses tee_shm_free(). I guess > it needs to do something like handle_rpc_func_cmd_shm_free()? Thanks, I'll fix. > > > break; > > default: > > arg->ret = TEEC_ERROR_BAD_PARAMETERS; > > @@ -424,7 +424,7 @@ static void handle_rpc_func_cmd_shm_free(struct tee_context *ctx, > > cmd_free_suppl(ctx, shm); > > break; > > case OPTEE_RPC_SHM_TYPE_KERNEL: > > - tee_shm_free(shm); > > + tee_shm_free_anon_kernel_buf(ctx, shm); > > break; > > default: > > arg->ret = TEEC_ERROR_BAD_PARAMETERS; > > @@ -502,7 +502,7 @@ void optee_handle_rpc(struct tee_context *ctx, struct optee_rpc_param *param, > > > > switch (OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0)) { > > case OPTEE_SMC_RPC_FUNC_ALLOC: > > - shm = tee_shm_alloc(ctx, param->a1, TEE_SHM_MAPPED); > > + shm = tee_shm_alloc_anon_kernel_buf(ctx, param->a1); > > if (!IS_ERR(shm) && !tee_shm_get_pa(shm, 0, &pa)) { > > reg_pair_from_64(¶m->a1, ¶m->a2, pa); > > reg_pair_from_64(¶m->a4, ¶m->a5, > > @@ -516,7 +516,7 @@ void optee_handle_rpc(struct tee_context *ctx, struct optee_rpc_param *param, > > break; > > case OPTEE_SMC_RPC_FUNC_FREE: > > shm = reg_pair_to_ptr(param->a1, param->a2); > > - tee_shm_free(shm); > > + tee_shm_free_anon_kernel_buf(ctx, shm); > > break; > > case OPTEE_SMC_RPC_FUNC_FOREIGN_INTR: > > /* > > diff --git a/drivers/tee/tee_core.c b/drivers/tee/tee_core.c > > index 480d294a23ab..4f5c7c17a434 100644 > > --- a/drivers/tee/tee_core.c > > +++ b/drivers/tee/tee_core.c > > @@ -293,7 +293,7 @@ static int tee_ioctl_shm_alloc(struct tee_context *ctx, > > if (data.flags) > > return -EINVAL; > > > > - shm = tee_shm_alloc(ctx, data.size, TEE_SHM_MAPPED | TEE_SHM_DMA_BUF); > > + shm = tee_shm_alloc_user_buf(ctx, data.size); > > if (IS_ERR(shm)) > > return PTR_ERR(shm); > > > > diff --git a/drivers/tee/tee_shm.c b/drivers/tee/tee_shm.c > > index 63fce8d39d8b..d134e2778a3a 100644 > > --- a/drivers/tee/tee_shm.c > > +++ b/drivers/tee/tee_shm.c > > @@ -96,25 +96,14 @@ static const struct dma_buf_ops tee_shm_dma_buf_ops = { > > .mmap = tee_shm_op_mmap, > > }; > > > > -struct tee_shm *tee_shm_alloc(struct tee_context *ctx, size_t size, u32 flags) > > +static struct tee_shm *shm_alloc_helper(struct tee_context *ctx, size_t size, > > + size_t align, u32 flags) > > { > > struct tee_device *teedev = ctx->teedev; > > struct tee_shm *shm; > > - size_t align; > > void *ret; > > int rc; > > > > - if (!(flags & TEE_SHM_MAPPED)) { > > - dev_err(teedev->dev.parent, > > - "only mapped allocations supported\n"); > > - return ERR_PTR(-EINVAL); > > - } > > - > > - if ((flags & ~(TEE_SHM_MAPPED | TEE_SHM_DMA_BUF))) { > > - dev_err(teedev->dev.parent, "invalid shm flags 0x%x", flags); > > - return ERR_PTR(-EINVAL); > > - } > > - > > if (!tee_device_get(teedev)) > > return ERR_PTR(-EINVAL); > > > > @@ -131,17 +120,14 @@ struct tee_shm *tee_shm_alloc(struct tee_context *ctx, size_t size, u32 flags) > > } > > > > shm->flags = flags | TEE_SHM_POOL; > > + > > + /* > > + * We're assigning this as it is needed if the shm is to be > > + * registered. If this function returns OK then the caller expected > > + * to call teedev_ctx_get() or clear shm->ctx in case it's not > > + * needed any longer. > > + */ > > shm->ctx = ctx; > > - if (flags & TEE_SHM_DMA_BUF) { > > - align = PAGE_SIZE; > > - /* > > - * Request to register the shm in the pool allocator below > > - * if supported. > > - */ > > - shm->flags |= TEE_SHM_REGISTER; > > - } else { > > - align = 2 * sizeof(long); > > - } > > > > rc = teedev->pool->ops->alloc(teedev->pool, shm, size, align); > > if (rc) { > > @@ -149,48 +135,71 @@ struct tee_shm *tee_shm_alloc(struct tee_context *ctx, size_t size, u32 flags) > > goto err_kfree; > > } > > > > + return shm; > > +err_kfree: > > + kfree(shm); > > +err_dev_put: > > + tee_device_put(teedev); > > + return ret; > > +} > > > > - if (flags & TEE_SHM_DMA_BUF) { > > - DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > > +/** > > + * tee_shm_alloc_user_buf() - Allocate shared memory for user space > > + * @ctx: Context that allocates the shared memory > > + * @size: Requested size of shared memory > > + * > > + * Memory allocated as user space shared memory is automatically freed when > > + * the TEE file pointer is closed. The primary usage of this function is > > + * when the TEE driver doesn't support registering ordinary user space > > + * memory. > > + * > > + * @returns a pointer to 'struct tee_shm' > > + */ > > +struct tee_shm *tee_shm_alloc_user_buf(struct tee_context *ctx, size_t size) > > +{ > > + u32 flags = TEE_SHM_MAPPED | TEE_SHM_DMA_BUF | TEE_SHM_REGISTER; > > Why not TEE_SHM_USER_MAPPED instead of TEE_SHM_MAPPED here? The name TEE_SHM_USER_MAPPED is perhaps not the best, it means that it's normal user space memory that we have pinned. We're allocating memory which later can be mapped by user space (via dma-buf) here. > > > + struct tee_device *teedev = ctx->teedev; > > + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); > > + struct tee_shm *shm; > > + void *ret; > > > > - mutex_lock(&teedev->mutex); > > - shm->id = idr_alloc(&teedev->idr, shm, 1, 0, GFP_KERNEL); > > - mutex_unlock(&teedev->mutex); > > - if (shm->id < 0) { > > - ret = ERR_PTR(shm->id); > > - goto err_pool_free; > > - } > > + shm = shm_alloc_helper(ctx, size, PAGE_SIZE, flags); > > + if (IS_ERR(shm)) > > + return shm; > > > > - exp_info.ops = &tee_shm_dma_buf_ops; > > - exp_info.size = shm->size; > > - exp_info.flags = O_RDWR; > > - exp_info.priv = shm; > > + mutex_lock(&teedev->mutex); > > + shm->id = idr_alloc(&teedev->idr, shm, 1, 0, GFP_KERNEL); > > + mutex_unlock(&teedev->mutex); > > + if (shm->id < 0) { > > + ret = ERR_PTR(shm->id); > > + goto err_pool_free; > > + } > > > > - shm->dmabuf = dma_buf_export(&exp_info); > > - if (IS_ERR(shm->dmabuf)) { > > - ret = ERR_CAST(shm->dmabuf); > > - goto err_rem; > > - } > > + exp_info.ops = &tee_shm_dma_buf_ops; > > + exp_info.size = shm->size; > > + exp_info.flags = O_RDWR; > > + exp_info.priv = shm; > > + > > + shm->dmabuf = dma_buf_export(&exp_info); > > + if (IS_ERR(shm->dmabuf)) { > > + ret = ERR_CAST(shm->dmabuf); > > + goto err_rem; > > } > > > > teedev_ctx_get(ctx); > > - > > return shm; > > err_rem: > > - if (flags & TEE_SHM_DMA_BUF) { > > - mutex_lock(&teedev->mutex); > > - idr_remove(&teedev->idr, shm->id); > > - mutex_unlock(&teedev->mutex); > > - } > > + mutex_lock(&teedev->mutex); > > + idr_remove(&teedev->idr, shm->id); > > + mutex_unlock(&teedev->mutex); > > err_pool_free: > > teedev->pool->ops->free(teedev->pool, shm); > > -err_kfree: > > kfree(shm); > > -err_dev_put: > > tee_device_put(teedev); > > return ret; > > + > > } > > -EXPORT_SYMBOL_GPL(tee_shm_alloc); > > +EXPORT_SYMBOL_GPL(tee_shm_alloc_user_buf); > > > > /** > > * tee_shm_alloc_kernel_buf() - Allocate shared memory for kernel buffer > > @@ -206,10 +215,85 @@ EXPORT_SYMBOL_GPL(tee_shm_alloc); > > */ > > struct tee_shm *tee_shm_alloc_kernel_buf(struct tee_context *ctx, size_t size) > > { > > - return tee_shm_alloc(ctx, size, TEE_SHM_MAPPED | TEE_SHM_DMA_BUF); > > + u32 flags = TEE_SHM_MAPPED | TEE_SHM_REGISTER; > > Similar question as above... why not TEE_SHM_KERNEL_MAPPED instead of > TEE_SHM_MAPPED? Also here is the name a bit unfortunate, it means that the memory originated as kernel owned memory where we've called get_kernel_pages(). > > > + struct tee_shm *shm; > > + > > + shm = shm_alloc_helper(ctx, size, PAGE_SIZE, flags); > > + if (IS_ERR(shm)) > > + return shm; > > + > > + teedev_ctx_get(ctx); > > + return shm; > > } > > EXPORT_SYMBOL_GPL(tee_shm_alloc_kernel_buf); > > > > +/** > > + * tee_shm_alloc_anon_kernel_buf() - Allocate shared memory for anonymous > > + * kernel buffer > > + * @ctx: Context that allocates the shared memory > > + * @size: Requested size of shared memory > > + * > > + * This function returns similar shared memory as tee_shm_alloc_kernel_buf(), > > + * but with two differences: > > + * 1. The memory might not be registered in secure world > > + * in case the driver supports passing memory not registered in advance. > > + * 2. The memory is not directly associated with the passed tee_context, > > + * rather the tee_device used by the context. > > + * > > + * This function should normally only be used internally in the TEE > > + * drivers. The memory must later only be freed using > > + * tee_shm_free_anon_kernel_buf() with a tee_contex with the same internal > > + * tee_device as when the memory was allocated. > > + * > > + * This allows allocating the shared memory using one context which is > > + * destroyed while the memory continues to live and finally freed using > > + * another context. > > + * > > + * @returns a pointer to 'struct tee_shm' > > + */ > > +struct tee_shm *tee_shm_alloc_anon_kernel_buf(struct tee_context *ctx, > > + size_t size) > > +{ > > + struct tee_shm *shm; > > + > > + shm = shm_alloc_helper(ctx, size, sizeof(long) * 2, TEE_SHM_MAPPED); > > The generic TEE_SHM_MAPPED is used here, as well. Yes, it's needed by tee_shm_va2pa() and friends. Thanks for the review, Jens _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel