嵌入式开发论坛

 找回密码
 立即注册
搜索
热搜: 活动 交友 discuz
查看: 58|回复: 0

28. OP-TEE驱动篇----tee_supplicant接口在驱动中的实现

[复制链接]

59

主题

62

帖子

249

积分

版主

Rank: 7Rank: 7Rank: 7

积分
249
发表于 2018-11-25 14:19:51 | 显示全部楼层 |阅读模式
在《22. OP-TEE中TA与CA执行流程-------tee-supplicant(一)》一文中介绍了tee_supplicant主要作用,用来实现secure world端操作REE侧文件系统,EMMC的rpmb分区,网络socket操作,数据库操作的需求。tee_supplicant与secure world之间的交互模式类似于生产者与消费者的方式进行配合来是实现上述需求。完成上述需求的整个过程包含三部分:1. 驱动获取来自TEE侧的请求。2.tee_supplicant从驱动中获取TEE侧的请求。3.驱动返回请求操作结果给TEE侧。其整个过程的框图如下:
​​当libtee调用驱动来与OP-TEE进行数据的交互的时候,最终会调用optee_do_call_with_arg函数完成完成smc的操作,而该函数中有一个loop循环,每次触发smc操作之后会对从secure world中返回的参数res.a0进行判断,判定当前从secure world返回的数据是要执行RPC操作还是直接返回到CA。如果是来自TEE的RPC请求,则会将请求存放到请求队列req中。然后block住,直到tee_supplicant处理完请求并将req->c标记为完成之后才会进入下一个loop,重新出发smc操作,将处理结果返回给TEE.
1. 驱动获取来自TEE侧的请求
  当libteec调用了需要做smc操作的请求之后,最终会调用到驱动的optee_do_call_with_arg函数,该函数会进入到死循环,第一条语句就会调用smc操作,进userspace的请求发送到secure world,待从secure world中返回之后。会对返回值进行判定。如果返回的res.a0参数是需要驱动做RPC操作,则该函数会调用到optee_handle_rpc操作。经过各种参数分析和函数调用之后,程序最后会调用optee_supp_thrd_req函数来将来自TEE的请求存放到tee_supplicant的请求队列中。该函数的内容如下:
  1. u32 optee_supp_thrd_req(struct tee_context *ctx, u32 func, size_t num_params,
  2.                         struct tee_param *param)

  3. {
  4.         struct optee *optee = tee_get_drvdata(ctx->teedev);
  5.         struct optee_supp *supp = &optee->supp;
  6.         struct optee_supp_req *req = kzalloc(sizeof(*req), GFP_KERNEL);
  7.         bool interruptable;
  8.         u32 ret;

  9.         if (!req)
  10.                 return TEEC_ERROR_OUT_OF_MEMORY;

  11. /* 初始化该请求消息的c成员并配置请求数据 */
  12.         init_completion(&req->c);
  13.         req->func = func;
  14.         req->num_params = num_params;
  15.         req->param = param;

  16.         /* Insert the request in the request list */
  17. /* 将接受到的请求添加到驱动的TEE请求消息队列中 */
  18.         mutex_lock(&supp->mutex);
  19.         list_add_tail(&req->link, &supp->reqs);
  20.         mutex_unlock(&supp->mutex);

  21.         /* Tell an eventual waiter there's a new request */
  22. /* 将supp->reqs_c置位,通知tee_supplicant的receve操作,当前驱动中
  23.    有一个来自TEE的请求 */
  24.         complete(&supp->reqs_c);

  25.         /*
  26.          * Wait for supplicant to process and return result, once we've
  27.          * returned from wait_for_completion(&req->c) successfully we have
  28.          * exclusive access again.
  29.          */
  30. /* block在这里,通过判定req->c是否被置位来判定当前请求是否被处理完毕,
  31.     而req->c的置位是有tee_supplicant的send调用来完成的,如果被置位,则进入到
  32.    while循环中进行返回值的设定并跳出while*/
  33.         while (wait_for_completion_interruptible(&req->c)) {
  34.                 mutex_lock(&supp->mutex);
  35.                 interruptable = !supp->ctx;
  36.                 if (interruptable) {
  37.                         /*
  38.                          * There's no supplicant available and since the
  39.                          * supp->mutex currently is held none can
  40.                          * become available until the mutex released
  41.                          * again.
  42.                          *
  43.                          * Interrupting an RPC to supplicant is only
  44.                          * allowed as a way of slightly improving the user
  45.                          * experience in case the supplicant hasn't been
  46.                          * started yet. During normal operation the supplicant
  47.                          * will serve all requests in a timely manner and
  48.                          * interrupting then wouldn't make sense.
  49.                          */
  50.                         interruptable = !req->busy;
  51.                         if (!req->busy)
  52.                                 list_del(&req->link);
  53.                 }
  54.                 mutex_unlock(&supp->mutex);

  55.                 if (interruptable) {
  56.                         req->ret = TEEC_ERROR_COMMUNICATION;
  57.                         break;
  58.                 }
  59.         }

  60.         ret = req->ret;
  61.         kfree(req);

  62.         return ret;
  63. }
复制代码
当请求被处理完成之后,函数返回处理后的数据到optee_do_call_with_arg函数中,并进入optee_do_call_with_arg函数中while中的下一次循环,将处理结果返回给secure world.
2. tee_supplicant从驱动中获取TEE侧的请求
在tee_supplicant会调用read_request函数来从驱动的请求队列中获取当前存在的来自TEE的请求。该函数最终会调用到驱动中的optee_supp_recv函数。该函数的内容如下:
  1. int optee_supp_recv(struct tee_context *ctx, u32 *func, u32 *num_params,
  2.                     struct tee_param *param)
  3. {
  4.         struct tee_device *teedev = ctx->teedev;
  5.         struct optee *optee = tee_get_drvdata(teedev);
  6.         struct optee_supp *supp = &optee->supp;
  7.         struct optee_supp_req *req = NULL;
  8.         int id;
  9.         size_t num_meta;
  10.         int rc;

  11. /* 对被用来存放TEE请求参数的数据的buffer进行检查 */
  12.         rc = supp_check_recv_params(*num_params, param, &num_meta);
  13.         if (rc)
  14.                 return rc;

  15. /* 进入到loop循环中,从 驱动的请求消息队列中获取来自TEE中的请求,直到获取之后才会
  16. 跳出该loop*/
  17.         while (true) {
  18.                 mutex_lock(&supp->mutex);
  19. /* 尝试从驱动的请求消息队列中获取来自TEE的一条请求 */
  20.                 req = supp_pop_entry(supp, *num_params - num_meta, &id);
  21.                 mutex_unlock(&supp->mutex);

  22. /* 判定是否获取到请求如果获取到了则跳出该loop */
  23.                 if (req) {
  24.                         if (IS_ERR(req))
  25.                                 return PTR_ERR(req);
  26.                         break;
  27.                 }

  28.                 /*
  29.                  * If we didn't get a request we'll block in
  30.                  * wait_for_completion() to avoid needless spinning.
  31.                  *
  32.                  * This is where supplicant will be hanging most of
  33.                  * the time, let's make this interruptable so we
  34.                  * can easily restart supplicant if needed.
  35.                  */
  36. /* block在这里,直到在optee_supp_thrd_req函数中发送了
  37. complete(&supp->reqs_c)操作后才继续往下执行 */
  38.                 if (wait_for_completion_interruptible(&supp->reqs_c))
  39.                         return -ERESTARTSYS;
  40.         }

  41. /* 设定参数进行异步处理请求的条件 */
  42.         if (num_meta) {
  43.                 /*
  44.                  * tee-supplicant support meta parameters -> requsts can be
  45.                  * processed asynchronously.
  46.                  */
  47.                 param->attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT |
  48.                               TEE_IOCTL_PARAM_ATTR_META;
  49.                 param->u.value.a = id;
  50.                 param->u.value.b = 0;
  51.                 param->u.value.c = 0;
  52.         } else {
  53.                 mutex_lock(&supp->mutex);
  54.                 supp->req_id = id;
  55.                 mutex_unlock(&supp->mutex);
  56.         }

  57. /* 解析参数,设定tee_supplicant将要执行的具体(加载TA,操作文件系统,操作EMMC的
  58. rpmb分区等)操作和相关参数 */
  59.         *func = req->func;
  60.         *num_params = req->num_params + num_meta;
  61.         memcpy(param + num_meta, req->param,
  62.                sizeof(struct tee_param) * req->num_params);

  63.         return 0;
  64. }
复制代码
 从请求消息队列中获取到来自TEE的请求之后,返回到tee_supplicant中继续执行。根据返回的func值和参数执行TEE要求在REE端需要的操作。
3. 驱动返回请求操作的结果给TEE侧
当tee_supplicant执行完TEE请求的操作之后,会调用write_response函数来实现将数据返回给TEE。而write_response函数最终会调用到驱动的optee_supp_send函数。该函数主要是调用complete(&req->c);操作来完成对该请求的c成员的置位,告诉optee_supp_thrd_req函数执行下一步操作,返回到optee_do_call_with_arg函数中进入该函数中的下一轮loop中,调用smc操作将结果返回给TEE侧。optee_supp_send函数的内容如下:
  1. int optee_supp_send(struct tee_context *ctx, u32 ret, u32 num_params,
  2.                     struct tee_param *param)
  3. {
  4.         struct tee_device *teedev = ctx->teedev;
  5.         struct optee *optee = tee_get_drvdata(teedev);
  6.         struct optee_supp *supp = &optee->supp;
  7.         struct optee_supp_req *req;
  8.         size_t n;
  9.         size_t num_meta;

  10.         mutex_lock(&supp->mutex);
  11. /* 驱动中请求队列的pop操作 */
  12.         req = supp_pop_req(supp, num_params, param, &num_meta);
  13.         mutex_unlock(&supp->mutex);

  14.         if (IS_ERR(req)) {
  15.                 /* Something is wrong, let supplicant restart. */
  16.                 return PTR_ERR(req);
  17.         }

  18.         /* Update out and in/out parameters */
  19. /* 使用传入的参数,更新请求的参数区域,将需要返回给TEE侧的数据填入到对应的位置 */
  20.         for (n = 0; n < req->num_params; n++) {
  21.                 struct tee_param *p = req->param + n;

  22.                 switch (p->attr & TEE_IOCTL_PARAM_ATTR_TYPE_MASK) {
  23.                 case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
  24.                 case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
  25.                         p->u.value.a = param[n + num_meta].u.value.a;
  26.                         p->u.value.b = param[n + num_meta].u.value.b;
  27.                         p->u.value.c = param[n + num_meta].u.value.c;
  28.                         break;
  29.                 case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
  30.                 case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
  31.                         p->u.memref.size = param[n + num_meta].u.memref.size;
  32.                         break;
  33.                 default:
  34.                         break;
  35.                 }
  36.         }
  37.         req->ret = ret;

  38.         /* Let the requesting thread continue */
  39. /* 通知optee_supp_thrd_req函数,一个来自TEE侧的请求已经被处理完毕,
  40. 可以继续往下执行 */
  41.         complete(&req->c);
  42.         return 0;
  43. }
复制代码
总结
 从tee_supplicant处理来自TEE侧的请求来看主要是有三个点。
  第一是驱动在触发smc操作之后会进入到loop循环中,根据secure world中的返回值来判定该返回时来自TEE的RPC请求还是最终处理结果,如果是RPC请求,也就是需要驱动或者tee_supplicant执行其他操作,驱动将RPC请求会保存到驱动的请求消息队列中,然后block住等待请求处理结果。
  第二是在tee_supplicant作为一个常驻进程存在于REE中,它会不停的尝试从驱动的请求消息队列中获取到来自TEE侧的请求。如果请求消息队列中并没有请求则会block住,直到拿到了请求才返回。拿到请求之后会对请求进行解析,然后根据func执行具体的操作。
  第三是在tee_supplicant处理完来自TEE的请求后,会调用send操作将处理结果存放到该消息队列的参数区域,并使用complete函数通知驱动该请求已经被处理完毕。驱动block住的地方可以继续往下执行,调用smc操作将结果返回给TEE侧



回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|TEE and Virtualization

GMT+8, 2019-3-19 00:19 , Processed in 0.084195 second(s), 19 queries .

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表