lkml.org 
[lkml]   [2018]   [Jul]   [13]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    Date
    SubjectRe: [RESEND PATCH] tee: add kernel internal client interface
    On Fri, 13 Jul 2018 at 14:54, Jens Wiklander <jens.wiklander@linaro.org> wrote:
    >
    > [+Sumit]
    >
    > On Mon, Jul 09, 2018 at 08:15:49AM +0200, Jens Wiklander wrote:
    > > Adds a kernel internal TEE client interface to be used by other drivers.
    > >
    > > Signed-off-by: Jens Wiklander <jens.wiklander@linaro.org>
    > > ---

    Thanks Jens for this patch. I have reviewed and tested this patch on
    Developerbox [1]. Following is brief description of my test-case:

    Developerbox doesn't have support for hardware based TRNG. But it does
    have 7 on-chip thermal sensors accessible from Secure world only. So I
    wrote OP-TEE static TA to collect Entropy using thermal noise from
    these sensors.
    After using the interface provided by this patch, I am able to write
    "hw_random" char driver for Developerbox to get Entropy from OP-TEE
    static TA which could be further used by user-space daemon (rngd).

    Reviewed-by: Sumit Garg <sumit.garg@linaro.org>
    Tested-by: Sumit Garg <sumit.garg@linaro.org>

    [1] https://www.96boards.org/product/developerbox/

    -Sumit

    > > drivers/tee/tee_core.c | 113 +++++++++++++++++++++++++++++++++++++---
    > > include/linux/tee_drv.h | 73 ++++++++++++++++++++++++++
    > > 2 files changed, 179 insertions(+), 7 deletions(-)
    > >
    > > diff --git a/drivers/tee/tee_core.c b/drivers/tee/tee_core.c
    > > index dd46b758852a..7b2bb4c50058 100644
    > > --- a/drivers/tee/tee_core.c
    > > +++ b/drivers/tee/tee_core.c
    > > @@ -38,15 +38,13 @@ static DEFINE_SPINLOCK(driver_lock);
    > > static struct class *tee_class;
    > > static dev_t tee_devt;
    > >
    > > -static int tee_open(struct inode *inode, struct file *filp)
    > > +static struct tee_context *teedev_open(struct tee_device *teedev)
    > > {
    > > int rc;
    > > - struct tee_device *teedev;
    > > struct tee_context *ctx;
    > >
    > > - teedev = container_of(inode->i_cdev, struct tee_device, cdev);
    > > if (!tee_device_get(teedev))
    > > - return -EINVAL;
    > > + return ERR_PTR(-EINVAL);
    > >
    > > ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
    > > if (!ctx) {
    > > @@ -57,16 +55,16 @@ static int tee_open(struct inode *inode, struct file *filp)
    > > kref_init(&ctx->refcount);
    > > ctx->teedev = teedev;
    > > INIT_LIST_HEAD(&ctx->list_shm);
    > > - filp->private_data = ctx;
    > > rc = teedev->desc->ops->open(ctx);
    > > if (rc)
    > > goto err;
    > >
    > > - return 0;
    > > + return ctx;
    > > err:
    > > kfree(ctx);
    > > tee_device_put(teedev);
    > > - return rc;
    > > + return ERR_PTR(rc);
    > > +
    > > }
    > >
    > > void teedev_ctx_get(struct tee_context *ctx)
    > > @@ -100,6 +98,18 @@ static void teedev_close_context(struct tee_context *ctx)
    > > teedev_ctx_put(ctx);
    > > }
    > >
    > > +static int tee_open(struct inode *inode, struct file *filp)
    > > +{
    > > + struct tee_context *ctx;
    > > +
    > > + ctx = teedev_open(container_of(inode->i_cdev, struct tee_device, cdev));
    > > + if (IS_ERR(ctx))
    > > + return PTR_ERR(ctx);
    > > +
    > > + filp->private_data = ctx;
    > > + return 0;
    > > +}
    > > +
    > > static int tee_release(struct inode *inode, struct file *filp)
    > > {
    > > teedev_close_context(filp->private_data);
    > > @@ -928,6 +938,95 @@ void *tee_get_drvdata(struct tee_device *teedev)
    > > }
    > > EXPORT_SYMBOL_GPL(tee_get_drvdata);
    > >
    > > +struct match_dev_data {
    > > + struct tee_ioctl_version_data *vers;
    > > + const void *data;
    > > + int (*match)(struct tee_ioctl_version_data *, const void *);
    > > +};
    > > +
    > > +static int match_dev(struct device *dev, const void *data)
    > > +{
    > > + const struct match_dev_data *match_data = data;
    > > + struct tee_device *teedev = container_of(dev, struct tee_device, dev);
    > > +
    > > + teedev->desc->ops->get_version(teedev, match_data->vers);
    > > + return match_data->match(match_data->vers, match_data->data);
    > > +}
    > > +
    > > +struct tee_context *
    > > +tee_client_open_context(struct tee_context *start,
    > > + int (*match)(struct tee_ioctl_version_data *,
    > > + const void *),
    > > + const void *data, struct tee_ioctl_version_data *vers)
    > > +{
    > > + struct device *dev = NULL;
    > > + struct device *put_dev = NULL;
    > > + struct tee_context *ctx = NULL;
    > > + struct tee_ioctl_version_data v;
    > > + struct match_dev_data match_data = { vers ? vers : &v, data, match };
    > > +
    > > + if (start)
    > > + dev = &start->teedev->dev;
    > > +
    > > + do {
    > > + dev = class_find_device(tee_class, dev, &match_data, match_dev);
    > > + if (!dev) {
    > > + ctx = ERR_PTR(-ENOENT);
    > > + break;
    > > + }
    > > +
    > > + put_device(put_dev);
    > > + put_dev = dev;
    > > +
    > > + ctx = teedev_open(container_of(dev, struct tee_device, dev));
    > > + } while (IS_ERR(ctx) && PTR_ERR(ctx) != -ENOMEM);
    > > +
    > > + put_device(put_dev);
    > > + return ctx;
    > > +}
    > > +EXPORT_SYMBOL_GPL(tee_client_open_context);
    > > +
    > > +void tee_client_close_context(struct tee_context *ctx)
    > > +{
    > > + teedev_close_context(ctx);
    > > +}
    > > +EXPORT_SYMBOL_GPL(tee_client_close_context);
    > > +
    > > +void tee_client_get_version(struct tee_context *ctx,
    > > + struct tee_ioctl_version_data *vers)
    > > +{
    > > + ctx->teedev->desc->ops->get_version(ctx->teedev, vers);
    > > +}
    > > +EXPORT_SYMBOL_GPL(tee_client_get_version);
    > > +
    > > +int tee_client_open_session(struct tee_context *ctx,
    > > + struct tee_ioctl_open_session_arg *arg,
    > > + struct tee_param *param)
    > > +{
    > > + if (!ctx->teedev->desc->ops->open_session)
    > > + return -EINVAL;
    > > + return ctx->teedev->desc->ops->open_session(ctx, arg, param);
    > > +}
    > > +EXPORT_SYMBOL_GPL(tee_client_open_session);
    > > +
    > > +int tee_client_close_session(struct tee_context *ctx, u32 session)
    > > +{
    > > + if (!ctx->teedev->desc->ops->close_session)
    > > + return -EINVAL;
    > > + return ctx->teedev->desc->ops->close_session(ctx, session);
    > > +}
    > > +EXPORT_SYMBOL_GPL(tee_client_close_session);
    > > +
    > > +int tee_client_invoke_func(struct tee_context *ctx,
    > > + struct tee_ioctl_invoke_arg *arg,
    > > + struct tee_param *param)
    > > +{
    > > + if (!ctx->teedev->desc->ops->invoke_func)
    > > + return -EINVAL;
    > > + return ctx->teedev->desc->ops->invoke_func(ctx, arg, param);
    > > +}
    > > +EXPORT_SYMBOL_GPL(tee_client_invoke_func);
    > > +
    > > static int __init tee_init(void)
    > > {
    > > int rc;
    > > diff --git a/include/linux/tee_drv.h b/include/linux/tee_drv.h
    > > index a2b3dfcee0b5..6cfe05893a76 100644
    > > --- a/include/linux/tee_drv.h
    > > +++ b/include/linux/tee_drv.h
    > > @@ -453,6 +453,79 @@ static inline int tee_shm_get_id(struct tee_shm *shm)
    > > */
    > > struct tee_shm *tee_shm_get_from_id(struct tee_context *ctx, int id);
    > >
    > > +/**
    > > + * tee_client_open_context() - Open a TEE context
    > > + * @start: if not NULL, continue search after this context
    > > + * @match: function to check TEE device
    > > + * @data: data for match function
    > > + * @vers: if not NULL, version data of TEE device of the context returned
    > > + *
    > > + * This function does an operation similar to open("/dev/teeX") in user space.
    > > + * A returned context must be released with tee_client_close_context().
    > > + *
    > > + * Returns a TEE context of the first TEE device matched by the match()
    > > + * callback or an ERR_PTR.
    > > + */
    > > +struct tee_context *
    > > +tee_client_open_context(struct tee_context *start,
    > > + int (*match)(struct tee_ioctl_version_data *,
    > > + const void *),
    > > + const void *data, struct tee_ioctl_version_data *vers);
    > > +
    > > +/**
    > > + * tee_client_close_context() - Close a TEE context
    > > + * @ctx: TEE context to close
    > > + *
    > > + * Note that all sessions previously opened with this context will be
    > > + * closed when this function is called.
    > > + */
    > > +void tee_client_close_context(struct tee_context *ctx);
    > > +
    > > +/**
    > > + * tee_client_get_version() - Query version of TEE
    > > + * @ctx: TEE context to TEE to query
    > > + * @vers: Pointer to version data
    > > + */
    > > +void tee_client_get_version(struct tee_context *ctx,
    > > + struct tee_ioctl_version_data *vers);
    > > +
    > > +/**
    > > + * tee_client_open_session() - Open a session to a Trusted Application
    > > + * @ctx: TEE context
    > > + * @arg: Open session arguments, see description of
    > > + * struct tee_ioctl_open_session_arg
    > > + * @param: Parameters passed to the Trusted Application
    > > + *
    > > + * Returns < 0 on error else see @arg->ret for result. If @arg->ret
    > > + * is TEEC_SUCCESS the session identifier is available in @arg->session.
    > > + */
    > > +int tee_client_open_session(struct tee_context *ctx,
    > > + struct tee_ioctl_open_session_arg *arg,
    > > + struct tee_param *param);
    > > +
    > > +/**
    > > + * tee_client_close_session() - Close a session to a Trusted Application
    > > + * @ctx: TEE Context
    > > + * @session: Session id
    > > + *
    > > + * Return < 0 on error else 0, regardless the session will not be
    > > + * valid after this function has returned.
    > > + */
    > > +int tee_client_close_session(struct tee_context *ctx, u32 session);
    > > +
    > > +/**
    > > + * tee_client_invoke_func() - Invoke a function in a Trusted Application
    > > + * @ctx: TEE Context
    > > + * @arg: Invoke arguments, see description of
    > > + * struct tee_ioctl_invoke_arg
    > > + * @param: Parameters passed to the Trusted Application
    > > + *
    > > + * Returns < 0 on error else see @arg->ret for result.
    > > + */
    > > +int tee_client_invoke_func(struct tee_context *ctx,
    > > + struct tee_ioctl_invoke_arg *arg,
    > > + struct tee_param *param);
    > > +
    > > static inline bool tee_param_is_memref(struct tee_param *param)
    > > {
    > > switch (param->attr & TEE_IOCTL_PARAM_ATTR_TYPE_MASK) {
    > > --
    > > 2.17.1
    > >
    \
     
     \ /
      Last update: 2018-07-15 22:06    [W:3.236 / U:0.616 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site