⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/linux/-/tree/dev-optee-mpxy

Commit ID: df5dc01764820f113312f7a39f221b49985bbd7a

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// arch/riscv/kernel/mpxy-sbi.c

struct sbi_mpxy {
	void *shmem;
	phys_addr_t shmem_phys_addr;
	bool active;
};

// Define per-cpu varible: sbi_mpxy.
DEFINE_PER_CPU(struct sbi_mpxy, sbi_mpxy);

• do_initcalls()
  • …
    • sbi_mpxy_init()

• sbi_mpxy_init()

  • Check SBI version and if MPXY extension is supported by OpenSBI.

  • Setup CPUHP notifier to setup shared memory on all CPUs.

    1 2 3 4 5 6

    // arch/riscv/kernel/mpxy-sbi.c cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "riscv/mpxy-sbi:cpu-shmem-init", __sbi_mpxy_setup_shmem, sbi_mpxy_exit);

    • cpuhp_thread_fun()
      • cpuhp_invoke_callback()
        • __sbi_mpxy_setup_shmem()
• __sbi_mpxy_setup_shmem()
  • Allocates 4KB shared memory (4KB aligned).
  • Call sbi_mpxy_set_shmem SBI call to set up MPXY shared memory for the current core. This will invoke OpenSBI’s sbi_mpxy_set_shmem() to save the shared memory address and size into current hart domain’s mpxy_state (Untrusted domain).
• sbi_mpxy_tee_probe()
  • Check SBI version and whether MPXY extension is supported by OpenSBI.
  • Get channel ID from DTS property: riscv,sbi-mpxy-channel-id.
  • Read MPXY protocol ID attribute (SBI_MPXY_ATTR_MSG_PROT_ID (0x0)) from channel with sbi_mpxy_read_attrs() .
  • Check if the returned MPXY protocol ID equals SBI_MPXY_MSGPROTO_TEE_ID (0x2). Throw an error if not.
• sbi_mpxy_read_attrs()
  • Disable preemption (get_cpu()).
    • Shared memory is per-core. We only need to disable the preemption to prevent the shared memory of current CPU from being corrupted by the other tasks.
  • Issue SBI call: SBI_EXT_MPXY_READ_ATTRS to read the attribute.
  • If successful, copy the attribute from the shared memory to the buffer.
  • Enable preemption (put_cpu()).
• sbi_mpxy_write_attrs()
  • Disable preemption (get_cpu()).
    • Shared memory is per-core. We only need to disable the preemption to prevent the shared memory of current CPU from being corrupted by the other tasks.
  • Copy the attribute from the buffer to the shared memory.
  • Issue SBI call: SBI_EXT_MPXY_WRITE_ATTRS to write the attribute.
  • Enable preemption (put_cpu()).
• sbi_mpxy_send_message_withresp()
  • Disable preemption (get_cpu()).
    • Shared memory is per-core. We only need to disable the preemption to prevent the shared memory of current CPU from being corrupted by the other tasks.
  • Issue SBI call: SBI_EXT_MPXY_SEND_MSG_WITH_RESP with message ID: OPTEED_MSG_COMMUNICATE (0x1) to send the message to tdomain and get the response.
    • This will switch to OpenSBI: If message ID is OPTEED_MSG_COMMUNICATE (0x1) (Called from udomain):. OpenSBI will then switch to the tdomain.
  • Enable preemption (put_cpu()).

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/linux/-/tree/dev-optee-mpxy

Commit ID: df5dc01764820f113312f7a39f221b49985bbd7a

• TEE supplicant
  • /etc/init.d/S30-tee-supplicant
  • /dev/teepriv0

• main()
  • process_one_request()
• process_one_request()
  • read_request()
    • Issue TEE_IOC_SUPPL_RECV ioctl to receive the TEE supplicant request from OP-TEE.
    • This will be blocked until TEE supplicant request is received.
  • Spawn a new thread to process for the new request: thread_main()
    • process_one_request()
  • The original thread will continue to handle the TEE supplicant request from OP-TEE:
    • If RPC command:
      • OPTEE_MSG_RPC_CMD_LOAD_TA:
        • Call load_ta() to load the TA according to the UUID.
          • load_ta() will call TEECI_LoadSecureModule() to load the TA.
            • TEECI_LoadSecureModule() will call fopen(), ftell() to open TA and get the size of TA.
            • If the buffer size (ta_size) is not enough to hold the TA, return the required size to let the caller increase the buffer size and try again.
            • Otherwise, call fread() to read TA and save it to the buffer.
      • …
    • Call write_response() to send the TEE supplicant response to OP-TEE.
• write_response()
  • Issue TEE_IOC_SUPPL_SEND ioctl to send the TEE supplicant response to OP-TEE.
    • This will unblock Call wait_for_completion_interruptible(**&req->c**) to wait for TEE supplicant to process.

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/linux/-/tree/dev-optee-mpxy

Commit ID: df5dc01764820f113312f7a39f221b49985bbd7a

• OP-TEE provides a pseudo Trusted Application (PTA): drivers/tee/optee/device.c in order to support device enumeration. In other words, OP-TEE driver invokes this application to retrieve a list of Trusted Applications which can be registered as devices on the TEE bus.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// drivers/tee/optee/optee_private.h

/**
 * struct optee - main service struct
 * @supp_teedev:	supplicant device
 * @teedev:		client device
 * @ops:		internal callbacks for different ways to reach secure
 *			world
 * @ctx:		driver internal TEE context
 * @smc:		specific to SMC ABI
 * @ffa:		specific to FF-A ABI
 * @call_queue:		queue of threads waiting to call @invoke_fn
 * @notif:		notification synchronization struct
 * @supp:		supplicant synchronization struct for RPC to supplicant
 * @pool:		shared memory pool
 * @rpc_param_count:	If > 0 number of RPC parameters to make room for
 * @scan_bus_done	flag if device registation was already done.
 * @scan_bus_work	workq to scan optee bus and register optee drivers
 */
struct optee {
	struct tee_device *supp_teedev;
	struct tee_device *teedev;
	const struct optee_ops *ops;
	struct tee_context *ctx;
	union {
		struct optee_smc smc;
		struct optee_ffa ffa;
	};
	struct optee_shm_arg_cache shm_arg_cache;
	struct optee_call_queue call_queue;
	struct optee_notif notif;
	struct optee_supp supp;
	struct tee_shm_pool *pool;
	unsigned int rpc_param_count;
	bool   scan_bus_done;
	struct work_struct scan_bus_work;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// drivers/tee/optee/optee_private.h

/**
 * struct optee_ops - OP-TEE driver internal operations
 * @do_call_with_arg:	enters OP-TEE in secure world
 * @to_msg_param:	converts from struct tee_param to OPTEE_MSG parameters
 * @from_msg_param:	converts from OPTEE_MSG parameters to struct tee_param
 *
 * These OPs are only supposed to be used internally in the OP-TEE driver
 * as a way of abstracting the different methogs of entering OP-TEE in
 * secure world.
 */
struct optee_ops {
	int (*do_call_with_arg)(struct tee_context *ctx,
				struct tee_shm *shm_arg, u_int offs,
				bool system_thread);
	int (*to_msg_param)(struct optee *optee,
			    struct optee_msg_param *msg_params,
			    size_t num_params, const struct tee_param *params);
	int (*from_msg_param)(struct optee *optee, struct tee_param *params,
			      size_t num_params,
			      const struct optee_msg_param *msg_params);
};

• do_initcalls()
  • …
    • optee_core_init()

• optee_core_init()

  • optee_smc_abi_register()
  • optee_ffa_abi_register()
    • Not supported in RISC-V.

• optee_smc_abi_register()

  • Register optee_driver.

    1 2 3 4 5 6 7 8 9 10 11

    // drivers/tee/optee/smc_abi.c static struct platform_driver optee_driver = { .probe = optee_probe, .remove_new = optee_smc_remove, .shutdown = optee_shutdown, .driver = { .name = "optee", .of_match_table = optee_dt_match, }, };

    • …
      • optee_probe()

• optee_probe()

  • sbi_mpxy_tee_probe()

  • Get invoke function.

    • E.g. optee_smccc_smc()
      • P.S. SMCCC = SMC Calling Convention, defined by ARM.

  • optee_msg_api_uid_is_optee_api()

    • Check UUID:
      • Call the invoke function, e.g. optee_smccc_smc() with function ID: OPTEE_SMC_CALLS_UID to retrieve the UUID.
        • OP-TEE will return UUID. Return true if the returned UUID is OPTEE_MSG_UID (384fb3e0-e7f8-11e3-af63-0002a5d5c51b), false otherwise.

  • optee_msg_get_os_revision()

    • Get OS revision
      • Call the invoke function, e.g. optee_smccc_smc() with function ID: OPTEE_SMC_CALL_GET_OS_REVISION to get OS version.
        • OP-TEE will return the OS revision.

  • optee_msg_api_revision_is_compatible()

    • Check whether the API revision is compatible:
      • Call the invoke function, e.g. optee_smccc_smc() with function ID: OPTEE_SMC_CALLS_REVISION to retrieve the API revision.
        • OP-TEE will return the API revision. Return true if the returned API revision is OPTEE_MSG_REVISION (2.0), false otherwise.

  • optee_msg_get_thread_count()

    • Get OP-TEE thread count:
      • Call the invoke function, e.g. optee_smccc_smc() with function ID: OPTEE_SMC_GET_THREAD_COUNT to get the OP-TEE thread count.

  • optee_msg_exchange_capabilities()

    • Exchange capabilities between Linux and OP-TEE:
      • Linux sets:
        • If UP, OPTEE_SMC_NSEC_CAP_UNIPROCESSOR.
      • Call the invoke function, e.g. optee_smccc_smc() with function ID: OPTEE_SMC_EXCHANGE_CAPABILITIES to exchange the capabilities between Linux and OP-TEE.
      • OP-TEE sets:
        • If reserved shared memory is enabled in secure world: OPTEE_ABI_SEC_CAP_HAVE_RESERVED_SHM.
        • If dynamic shared memory is enabled in secure world: OPTEE_ABI_SEC_CAP_DYNAMIC_SHM.
        • If virtualization is enabled in secure world: OPTEE_ABI_SEC_CAP_VIRTUALIZATION.
        • Shared memory with a NULL reference is supported in secure world: OPTEE_ABI_SEC_CAP_MEMREF_NULL.
        • If asynchronous notification of normal world is supported in secure world: OPTEE_ABI_SEC_CAP_ASYNC_NOTIF.
        • Pre-allocating RPC arg struct is supported in secure world: OPTEE_ABI_SEC_CAP_RPC_ARG.

  • If the capabilities has OPTEE_ABI_SEC_CAP_DYNAMIC_SHM, create page-based allocator pool based on alloc_pages().

  • If the capabilities has OPTEE_ABI_SEC_CAP_HAVE_RESERVED_SHM, use the static memory pool.

    • Call the invoke function, e.g. optee_smccc_smc() with function ID: OPTEE_SMC_GET_SHM_CONFIG to get the base address and the size of the static memory pool allocated by OP-TEE.
      • OP-TEE returns default_nsec_shm_paddr and default_nsec_shm_size indicating the physical base address and the size of the non-secure shared memory initialized in teecore_init_pub_ram().

        • Non-secured shared memory is declared statically in OP-TEE:

          1 2 3 4 5

          // core/arch/riscv/kernel/sbi_mpxy.c #ifdef CFG_CORE_RESERVED_SHM register_phys_mem(MEM_AREA_NSEC_SHM, TEE_SHMEM_START, TEE_SHMEM_SIZE); #endif

        • teecore_init_pub_ram() is declared with early_init() when CFG_CORE_RESERVED_SHM is defined.

  • Allocate struct optee:

    • optee->ops = &optee_ops

    1 2 3 4 5 6 7

    // drivers/tee/optee/smc_abi.c static const struct optee_ops optee_ops = { .do_call_with_arg = optee_smc_do_call_with_arg, .to_msg_param = optee_to_msg_param, .from_msg_param = optee_from_msg_param, };

  • Call tee_device_alloc() to allocate a new struct tee_device instance for TEE client device: optee-clnt with optee_clnt_desc. struct optee is passed as driver_data.

    1 2 3 4 5 6 7

    // drivers/tee/optee/smc_abi.c static const struct tee_desc optee_clnt_desc = { .name = DRIVER_NAME "-clnt", .ops = &optee_clnt_ops, .owner = THIS_MODULE, };

    1 2 3 4 5 6 7 8 9 10 11 12 13 14

    // drivers/tee/optee/smc_abi.c static const struct tee_driver_ops optee_clnt_ops = { .get_version = optee_get_version, .open = optee_smc_open, .release = optee_release, .open_session = optee_open_session, .close_session = optee_close_session, .system_session = optee_system_session, .invoke_func = optee_invoke_func, .cancel_req = optee_cancel_req, .shm_register = optee_shm_register, .shm_unregister = optee_shm_unregister, };

    • The allocated TEE client device is assigned to optee->teedev.

  • Call tee_device_alloc() to allocate a new struct tee_device instance for TEE supplicant device: optee-supp with optee_supp_desc. struct optee is passed as driver_data.

    1 2 3 4 5 6 7 8 9 10 11

    // drivers/tee/optee/smc_abi.c static const struct tee_desc optee_supp_desc = { .name = DRIVER_NAME "-supp", .ops = &optee_supp_ops, .owner = THIS_MODULE, // If TEE_DESC_PRIVILEGED is set, the name of // tee_device will be: teeprivX. // Otherwise, the name of tee_device will be: teeX. .flags = TEE_DESC_PRIVILEGED, };

    1 2 3 4 5 6 7 8 9 10 11

    // drivers/tee/optee/smc_abi.c static const struct tee_driver_ops optee_supp_ops = { .get_version = optee_get_version, .open = optee_smc_open, .release = optee_release_supp, .supp_recv = optee_supp_recv, .supp_send = optee_supp_send, .shm_register = optee_shm_register_supp, .shm_unregister = optee_shm_unregister_supp, };

    • The allocated TEE supplicant device is assigned to optee->supp_teedev.

  • Call tee_device_register() to register optee-clnt device.

  • Call tee_device_register() to register optee-supp device.

  • Call platform_set_drvdata() to set optee device driver data to: struct optee.

  • Open OP-TEE client device (optee->teedev):

    • tee_open()
      • This will call optee_clnt_desc->open():
        • optee_smc_open()
          • optee_open()

  • If OPTEE_SMC_SEC_CAP_ASYNC_NOTIF capability is supported:

    • Call platform_get_irq() to get (non-secure) IRQ 0.
    • Call optee_smc_notif_init_irq() to request IRQ.
      • If irq_is_percpu_devid():
        • init_pcpu_irq()
          • request_percpu_irq()
            • IRQ handler: notif_pcpu_irq_handler()
              • irq_handler()
          • Init work: optee->smc.notif_pcpu_work:
            • Handler: notif_pcpu_irq_work_fn()
              • optee_do_bottom_half()
          • Create work queue: optee->smc.notif_pcpu_wq
            • optee->smc.notif_pcpu_work is queued into optee->scm.notif_pcpu_wq in notif_pcpu_irq_handler()
      • Otherwise:
        • init_irq()
          • request_threaded_irq()
            • IRQ handler: notif_irq_handler()
              • irq_handler()
            • Handler thread: notif_irq_thread_fn()
              • optee_do_bottom_half()
    • Call optee_enumerate_devices() to enumerate PTA devices (PTA_CMD_GET_DEVICES).

• optee_smccc_smc()

  • Call sbi_mpxy_send_message_withresp() to message ID: OPTEED_MSG_COMMUNICATE (0x01).

• optee_open()

  • Allocate struct optee_context_data.
  • If tee_device is a OP-TEE supplicant devices:
    • If !optee->scan_bus_done:
      • Initialize scan_bus_work work queue.
      • Handler: optee_bus_scan()
      • Schedule the work queue.
      • Set optee->scan_bus_done to true.
  • Assign the allocated struct optee_context_data to tee_context->data.

• optee_open_session()

  • Call optee_get_msg_arg() to allocate the shared memory for the message arg (struct optee_msg_arg).

  • Call tee_session_calc_client_uuid() to create Linux environment client UUID from the session arg.

  • Initialize message arg and add the meta parameters needed when opening a session with the session arg and Linux environment client UUID.

  • Call optee->ops->to_msg_param() to convert the passed-in struct tee_param to OPTEE_MSG parameters (struct optee_msg_arg). Save the converted OPTEE_MSG parameters to message arg.

    • E.g. optee_to_msg_param()

  • Call optee->ops->do_call_with_arg() with the command: OPTEE_MSG_CMD_OPEN_SESSION to enter OP-TEE in secure world with the message arg.

    • E.g. optee_smc_do_call_with_arg()
    • OP-TEE will call entry_open_session() to open the session based on the UUID (tee_ioctl_open_session_arg->uuid, e.g. PTA UUID) passed from Linux. The UUID is used to look up or initialize the TA with the same UUID. The opened session ID is saved to the message arg and passed back to Linux.

  • If optee_smc_do_call_with_arg() returns success, add the session to the sessions list (ctxdata->sess_list)

  • Call optee->ops->from_msg_param() to convert the returned session OPTEE_MSG parameters to struct tee_param. Update the results to session arg.

    • E.g. optee_from_msg_param()
      • Store the open session ID to struct tee_ioctl_open_session_arg->session.
    • If conversion fails, call optee_close_session() to close the session.

  • Call optee_free_msg_arg() to free the allocated message arg.

• optee_smc_do_call_with_arg()

  • Initialize RPC parameter (struct optee_rpc_param) from the message arg.
    • message arg is stored in the shared memory indicated by shm and offs.
  • Call optee->smc.invoke_fn() to enter OP-TEE in secure world with the message arg.
  • If SMC return is a RPC:
    • Call optee_handle_rpc() to handle the RPC from OP-TEE.

• optee_invoke_func()

  • Similar flow to optee_open_session(). Except calling optee->ops->do_call_with_arg() with the command: OPTEE_MSG_CMD_INVOKE_COMMAND to enter OP-TEE in secure world with the message arg.
    • E.g. optee_smc_do_call_with_arg()
    • OP-TEE will call entry_invoke_command() to invoke the command based on the passed-in function (e.g. PTA_CMD_GET_DEVICES) in the opened session.
      • E.g. If the opened session is registered for pseudo TA (OP-TEE: core/pta/pseudo_ta.c). The enter_invoke_cmd() callback in OP-TEE is: pseudo_ta_enter_invoke_cmd().

• optee_bus_scan()

  • Call optee_enumerate_devices() to enumerate PTA supplicant devices (PTA_CMD_GET_DEVICES_SUPP).

• optee_do_bottom_half()

  • Call optee->ops->do_call_with_arg() with the command: OPTEE_MSG_CMD_DO_BOTTOM_HALF to schedule bottom half processing of a driver.

• optee_enumerate_devices()

  • Enumerate the TA devices.
  • __optee_enumerate_devices()

    • PTA UUID:

      1 2 3 4 5

      // drivers/tee/optee/device.c const uuid_t pta_uuid = UUID_INIT(0x7011a688, 0xddde, 0x4053, 0xa5, 0xa9, 0x7b, 0x3c, 0x4d, 0xdf, 0x13, 0xb8);

    • Call tee_client_open_context() to open TEE devices with OP-TEE driver.

    • Prepare session arg (struct tee_ioctl_open_session_arg).

    • Call tee_client_open_session() to open session with device enumeration pseudo Trusted Application with the session arg using PTA UUID.

    • Call get_devices() to get the required shared memory size for UUIDs of pseudo TAs.

      • Shared memory size = sizeof(UUID) * Number of pseudo TAs

    • After retrieving the shared memory size, call tee_shm_alloc_kernel_buf() to allocate the shared memory buffer for UUIDs of pseudo TAs.

    • Call get_devices() again to get the UUIDs of pseudo TAs. The UUIDs of psuedo TA are stored in the allocated shared memory by OP-TEE.

    • For each pseudo TA, call optee_register_device() to register the device to TEE bus (tee_bus_type).

      • This will eventually call tee_client_device_match() to match the driver for the TA device based on UUID. Driver’s probe() callback will be called if matches.

        • For example: optee-rngs driver (drivers/char/hw_random/optee-rngs.c).

          • OP-TEE driver is implemented as a module and is initialized through module_init(). OP-TEE driver sets its bus to tee_bus_type.

          1 2 3 4 5 6 7 8 9 10 11

          // drivers/char/hw_random/optee-rngs.c static struct tee_client_driver optee_rng_driver = { .id_table = optee_rng_id_table, .driver = { .name = DRIVER_NAME, **.bus = &tee_bus_type,** .probe = optee_rng_probe, .remove = optee_rng_remove, }, };

• get_devices()

  • Call tee_client_invoke_func() to invoke the function (e.g. PTA_CMD_GET_DEVICES to get the pseudo TAs) to OP-TEE.

• optee_handle_rpc()
  • If optee_rpc_param->a0:
    • OPTEE_SMC_RPC_FUNC_CMD function:
      • Get arg (struct optee_msg_arg) from the shared memory.
      • handle_rpc_func_cmd() with arg.
    • …
  • Set param->a0 to OPTEE_SMC_CALL_RETURN_FROM_RPC to indicate that we have successfully handled the RPC.
• handle_rpc_func_cmd()
  • If arg->cmd:
    • OPTEE_RPC_CMD_SHM_ALLOC:
      • handle_rpc_func_cmd_shm_alloc()
    • OPTEE_RPC_CMD_SHM_FREE:
      • handle_rpc_func_cmd_shm_free()
    • Otherwise:
      • optee_rpc_cmd()
• optee_rpc_cmd()
  • If arg->cmd:
    • OPTEE_RPC_CMD_GET_TIME:
      • handle_rpc_func_cmd_get_time()
    • …
    • Otherwise:
      • handle_rpc_supp_cmd()
• handle_rpc_supp_cmd()
  • optee_supp_thrd_req()
• optee_supp_thrd_req()
  • Insert the RPC request into the request list (supp->reqs).
  • Call complete(**&supp->reqs_c**) to tell an eventual waiter there’s a new request.
    • This will unblock TEE supplicant: Otherwise, call wait_for_completion_interruptible(**&supp->reqs_c**) to wait for the new request from OP-TEE.
  • Call wait_for_completion_interruptible(**&req->c**) to wait for TEE supplicant to process.
    • This will be blocked until TEE supplicant handles the RPC.
  • Return the result.
• optee_supp_recv() - TEE supplicant waits for OP-TEE’s request
  • Check if we could pop the entry from the request list (supp->reqs). If yes, extract the RPC parameters.
  • Otherwise, call wait_for_completion_interruptible(**&supp->reqs_c**) to wait for the new request from OP-TEE.
• optee_supp_send() - TEE supplicant handles the RPC and sends the response to OP-TEE.
  • Set the return parameters (struct tee_param).
  • Call complete(**&req->c**) to unblock Call wait_for_completion_interruptible(**&req->c**) to wait for TEE supplicant to process.

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/linux/-/tree/dev-optee-mpxy

Commit ID: df5dc01764820f113312f7a39f221b49985bbd7a

• Kernel provides a TEE bus infrastructure where a Trusted Application is represented as a device identified via Universally Unique Identifier (UUID) and client drivers register a table of supported device UUIDs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// include/linux/tee_core.h

/**
 * struct tee_device - TEE Device representation
 * @name:	name of device
 * @desc:	description of device
 * @id:		unique id of device
 * @flags:	represented by TEE_DEVICE_FLAG_REGISTERED above
 * @dev:	embedded basic device structure
 * @cdev:	embedded cdev
 * @num_users:	number of active users of this device
 * @c_no_user:	completion used when unregistering the device
 * @mutex:	mutex protecting @num_users and @idr
 * @idr:	register of user space shared memory objects allocated or
 *		registered on this device
 * @pool:	shared memory pool
 */
struct tee_device {
	char name[TEE_MAX_DEV_NAME_LEN];
	const struct tee_desc *desc;
	int id;
	unsigned int flags;

	struct device dev;
	struct cdev cdev;

	size_t num_users;
	struct completion c_no_users;
	struct mutex mutex;	/* protects num_users and idr */

	struct idr idr;
	struct tee_shm_pool *pool;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// include/linux/tee_core.h

/**
 * struct tee_desc - Describes the TEE driver to the subsystem
 * @name:	name of driver
 * @ops:	driver operations vtable
 * @owner:	module providing the driver
 * @flags:	Extra properties of driver, defined by TEE_DESC_* below
 */
#define TEE_DESC_PRIVILEGED	0x1
struct tee_desc {
	const char *name;
	const struct tee_driver_ops *ops;
	struct module *owner;
	u32 flags;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// include/linux/tee_core.h

/**
 * struct tee_driver_ops - driver operations vtable
 * @get_version:	returns version of driver
 * @open:		called when the device file is opened
 * @release:		release this open file
 * @open_session:	open a new session
 * @close_session:	close a session
 * @system_session:	declare session as a system session
 * @invoke_func:	invoke a trusted function
 * @cancel_req:		request cancel of an ongoing invoke or open
 * @supp_recv:		called for supplicant to get a command
 * @supp_send:		called for supplicant to send a response
 * @shm_register:	register shared memory buffer in TEE
 * @shm_unregister:	unregister shared memory buffer in TEE
 */
struct tee_driver_ops {
	void (*get_version)(struct tee_device *teedev,
			    struct tee_ioctl_version_data *vers);
	int (*open)(struct tee_context *ctx);
	void (*release)(struct tee_context *ctx);
	int (*open_session)(struct tee_context *ctx,
			    struct tee_ioctl_open_session_arg *arg,
			    struct tee_param *param);
	int (*close_session)(struct tee_context *ctx, u32 session);
	int (*system_session)(struct tee_context *ctx, u32 session);
	int (*invoke_func)(struct tee_context *ctx,
			   struct tee_ioctl_invoke_arg *arg,
			   struct tee_param *param);
	int (*cancel_req)(struct tee_context *ctx, u32 cancel_id, u32 session);
	int (*supp_recv)(struct tee_context *ctx, u32 *func, u32 *num_params,
			 struct tee_param *param);
	int (*supp_send)(struct tee_context *ctx, u32 ret, u32 num_params,
			 struct tee_param *param);
	int (*shm_register)(struct tee_context *ctx, struct tee_shm *shm,
			    struct page **pages, size_t num_pages,
			    unsigned long start);
	int (*shm_unregister)(struct tee_context *ctx, struct tee_shm *shm);
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// include/linux/tee_core.h

/**
 * struct tee_shm_pool - shared memory pool
 * @ops:		operations
 * @private_data:	private data for the shared memory manager
 */
struct tee_shm_pool {
	const struct tee_shm_pool_ops *ops;
	void *private_data;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// include/linux/tee_core.h

/**
 * struct tee_shm_pool_ops - shared memory pool operations
 * @alloc:		called when allocating shared memory
 * @free:		called when freeing shared memory
 * @destroy_pool:	called when destroying the pool
 */
struct tee_shm_pool_ops {
	int (*alloc)(struct tee_shm_pool *pool, struct tee_shm *shm,
		     size_t size, size_t align);
	void (*free)(struct tee_shm_pool *pool, struct tee_shm *shm);
	void (*destroy_pool)(struct tee_shm_pool *pool);
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// include/linux/tee_drv.h

/**
 * struct tee_context - driver specific context on file pointer data
 * @teedev:	pointer to this drivers struct tee_device
 * @data:	driver specific context data, managed by the driver
 * @refcount:	reference counter for this structure
 * @releasing:  flag that indicates if context is being released right now.
 *		It is needed to break circular dependency on context during
 *              shared memory release.
 * @supp_nowait: flag that indicates that requests in this context should not
 *              wait for tee-supplicant daemon to be started if not present
 *              and just return with an error code. It is needed for requests
 *              that arises from TEE based kernel drivers that should be
 *              non-blocking in nature.
 * @cap_memref_null: flag indicating if the TEE Client support shared
 *                   memory buffer with a NULL pointer.
 */
struct tee_context {
	struct tee_device *teedev;
	void *data;
	struct kref refcount;
	bool releasing;
	bool supp_nowait;
	bool cap_memref_null;
};

• do_initcalls()
  • …
    • tee_init()

• tee_init()

  • Call class_register() to register tee_class.

    1 2 3 4 5

    // drivers/tee/tee_core.c static const struct class tee_class = { .name = "tee", };

  • Call alloc_chrdev_region() to register a range of char device numbers for TEE devices.

    • 0 ~ TEE_NUM_DEVICES.

  • Call bus_register() to register tee_bus_type.

    1 2 3 4 5 6 7

    // drivers/tee/tee_core.c const struct bus_type tee_bus_type = { .name = "tee", .match = tee_client_device_match, .uevent = tee_client_device_uevent, };

• tee_device_register()

  • Call cdev_device_add() to add the TEE character device to the system.

• tee_open()

  • teedev_open()
  • Assign filp->private_data to the allocated struct tee_context.

• teedev_open()

  • Allocate struct tee_context for the TEE device.
  • Assign tee_context->teedev to TEE device.
  • Call teedev->desc->ops->open().
    • E.g. optee_smc_open()

• tee_client_open_context()

  • Call class_find_device() to look up the TEE devices that match with passed in match() (e.g. optee_ctx_match()) under TEE class (tee_class), then call teedev_open() to open the TEE devices.

• tee_client_open_session()

  • Call ctx->teedev->desc->ops->open_session().
    • E.g. optee_open_session()

• tee_client_invoke_func()

  • Call teedev->desc->ops->invoke_func()
    • E.g. optee_invoke_func()

• tee_ioctl()
  • If cmd:
    • TEE_IOC_OPEN_SESSION:
      • tee_ioctl_open_session()
    • …
    • TEE_IOC_SUPPL_RECV:
      • tee_ioctl_supp_recv()
    • TEE_IOC_SUPPL_SEND:
      • tee_ioctl_supp_send()
• tee_ioctl_open_session()
• tee_ioctl_supp_recv()
  • Call ctx->teedev->desc->ops->supp_recv().
    • E.g. optee_supp_recv() - TEE supplicant waits for OP-TEE’s request
• tee_ioctl_supp_send()
  • Call ctx->teedev->desc->ops->supp_send().
    • E.g. optee_supp_send() - TEE supplicant handles the RPC and sends the response to OP-TEE.

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/opensbi/-/tree/dev-optee-mpxy

Commit ID: 7d4c90953afe3bd86f9e2501bd4c2501e8db1898

• init_coldboot()
  • sbi_mpxy_init()
• sbi_mpxy_init()
  • Allocate struct mpxy_state for each domain.
  • sbi_platform_mpxy_init()
    • Call platform-defined mpxy_init().
      • e.g. For generic platform: fdt_mpxy_init().
• fdt_mpxy_init()
  • Iterate MPXY drivers in fdt_mpxy_drivers[].

    • MPXY drivers are generated at compile time:

      1 2 3 4 5 6 7 8 9 10 11

      // lib/utils/mpxy/objects.mk libsbiutils-objs-$(CONFIG_FDT_MPXY) += mpxy/fdt_mpxy.o libsbiutils-objs-$(CONFIG_FDT_MPXY) += mpxy/fdt_mpxy_drivers.o carray-fdt_mpxy_drivers-$(CONFIG_FDT_MPXY_RPMI_MBOX) += fdt_mpxy_rpmi_mbox libsbiutils-objs-$(CONFIG_FDT_MPXY_RPMI_MBOX) += mpxy/fdt_mpxy_rpmi_mbox.o carray-fdt_mpxy_drivers-$(CONFIG_FDT_MPXY_MM) += fdt_mpxy_mm libsbiutils-objs-$(CONFIG_FDT_MPXY_MM) += mpxy/fdt_mpxy_mm.o carray-fdt_mpxy_drivers-$(CONFIG_FDT_MPXY_OPTEED) += fdt_mpxy_opteed libsbiutils-objs-$(CONFIG_FDT_MPXY_OPTEED) += mpxy/fdt_mpxy_opteed.o

      1 2 3 4 5

      // lib/utils/mpxy/fdt_mpxy_drivers.carray HEADER: sbi_utils/mpxy/fdt_mpxy.h TYPE: struct fdt_mpxy NAME: fdt_mpxy_drivers

      1 2 3 4 5 6 7

      // include/sbi_utils/mpxy/fdt_mpxy.h struct fdt_mpxy { const struct fdt_match *match_table; int (*init)(void *fdt, int nodeoff, const struct fdt_match *match); void (*exit)(void); };

    • Call drv->init().

      • e.g. mpxy_opteed_init()
• sbi_ecall_mpxy_handler()
  • sbi_ecall_mpxy_handler() is the handler for SBI MPXY ecalls, which will call the corresponding function based on SBI function ID, e.g.
    • sbi_mpxy_set_shmem()
    • sbi_mpxy_send_message()

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/opensbi/-/tree/dev-optee-mpxy

Commit ID: 7d4c90953afe3bd86f9e2501bd4c2501e8db1898

• mpxy_opteed_init()

  • Match compatible string: "riscv,sbi-mpxy-opteed".

  • Allocate channel.

  • opteed_domain_setup()

    • Setup domain for OP-TEE dispatcher by looking up the domain specified by opensbi-domain-instance phandle in DTS.
    • Assign the domain name to opteed_domain_name.

  • Get channel ID from DTS property: riscv,sbi-mpxy-channel-id.

  • Initialize channel:

    1 2 3 4 5 6

    // lib/utils/mpxy/fdt_mpxy_opteed.c channel->channel_id = channel_id; channel->send_message = mpxy_opteed_send_message; channel->attrs.msg_proto_id = SBI_MPXY_MSGPROTO_TEE_ID; channel->attrs.msg_data_maxlen = PAGE_SIZE;

  • Register channel: sbi_mpxy_register_channel()

  • Assign tdomain (Trusted domain).

    • Look up the domain with the name specified in opteed_domain_name.

  • Assign udomain (Untrusted domain).

    • Look up the domain with the name "untrusted-domain".
• mpxy_opteed_send_message()
  • If message ID is OPTEED_MSG_COMMUNICATE (0x1) (Called from udomain):
    • If tdomain’s shared memory is NOT valid, return SBI_EINVAL.
    • Otherwise:
      • Direction: udomain -> OpenSBI
      • Copy the source data from udomain to tdomain’s shared memory.
    • Call sbi_ecall_tee_domain_enter() to switch to tdomain.
      • Direction: udomain -> tdomain.
      • The entry point to be switched to is defined by the function type:
        • Function type is defined by the first unsigned long in udomain’s shared memory: ((ulong *)shmem_base)[0].
        • If function type is: ABI_ENTRY_TYPE_FAST (i.e. ARM_SMCCC_FAST_CALL)
          • Entry point ⇒ entry_vector_table->fast_abi_entry
            • entry_vector_table ⇒ thread_vector_table is defined in OP-TEE. Therefore, entry_vector_table->fast_abi_entry ⇒ vector_fast_abi_entry()
        • Otherwise:
          • Entry point ⇒ entry_vector_table->yield_abi_entry
            • entry_vector_table ⇒ thread_vector_table is defined in OP-TEE. Therefore, entry_vector_table->yield_abi_entry ⇒ vector_std_abi_entry()
  • If message ID is OPTEED_MSG_COMPLETE (0x2) (Called from tdomain):
    • If udomain’s shared memory is NOT valid:
      • Direction: tdomain -> OpenSBI.
      • If ((ulong *)msgbuf)[0] (from tdomain’s shared memory, i.e. $a0) is TEEABI_OPTEED_RETURN_CALL_DONE (0xbe000000):
        • Register OP-TEE entry table:
          • Set entry_vector_table to ((ulong *)msgbuf)[1] (i.e. $a1), i.e. thread_vector_table defined in OP-TEE.
    • Otherwise, copy the source data from tdomain to udomain’s shared memory.
      • Direction: tdomain -> udomain.
      • Only $a1 ~ $a4 (from tdomain’s shared memory) are copied to udomain’s shared memory, $a0 is skipped.
    • Call sbi_ecall_tee_domain_exit() to exit from the current tdomain.
      • The domain to switch to:
        • Switch to the previous domain
        • Switch to the use-define next domain.
        • Fallback to the root domain.
  • P.S. Domain switching only involves domain contexts save and restore. The mode is switched by mret in the trap handler.

• sbi_mpxy_register_channel()
  • Initialize channel’s attributes: mpxy_std_attrs_init()
    • Check whether MSI, SSE and Events State capabilities are available in the domain.
  • Add the allocated channel to mpxy_channel_list list.
• sbi_mpxy_set_shmem()
  • Validate passed in shared memory address and size.
  • Set current hart’s sbi_domain shared memory address and size.
• sbi_mpxy_send_message()
  • Call channel->send_message().
    • e.g. mpxy_opteed_send_message()

• sbi_ecall_tee_domain_enter()
  • The domain is tdomain.
  • sbi_domain_context_set_mepc()
    • Set mepc to the entry point.
  • sbi_domain_context_enter()
    • Switch to tdomain.

• Example DTS:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  chosen { opensbi-domains { ..... trusted-domain { compatible = "opensbi,domain,instance"; regions = <0x04 0x3f>; possible-harts = <0x03 0x01>; next-addr = <0x00 0xf1000000>; next-mode = <0x01>; phandle = <0x02>; }; ..... }; }; sbi-mpxy-opteed { opensbi-domain-instance = <0x02>; riscv,sbi-mpxy-channel-id = <0x02>; compatible = "riscv,sbi-mpxy-opteed"; };

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

• Base addresses:

  • U-Boot SPL: 0x80000000
  • OpenSBI: 0x80100000
  • OP-TEE: 0xf1000000
  • U-Boot proper: 0x81200000 / Relocated to: 0x17f76f000, relocate offset = 0xfe558000
    • E.g. 0x81217b66 → 0x17f76fb66; 0x81232884 → 0x17f78a884
  • Linux Kernel: 0x80200000 / 0xffffffff80000000

  1 2 3

  (gdb) add-symbol-file u-boot-spl 0x80000000 (gdb) add-symbol-file fw_dynamic.elf 0x80100000 (gdb) add-symbol-file tee.elf 0xf1000000

  1 2	# For the relocated U-Boot (gdb) add-symbol-file u-boot -o 0xfe558000

• When traps, mscratch/sscratch:
  • If 0: Trap from kernel.
  • If !0: Trap from user.
  • See thread_init_per_cpu(), thread_trap_vect().
    • thread_init_per_cpu() sets mscratch/sscratch to 0 to indicate that the trap is from kernel.

• Fast Calls and Yielding Calls
  • Fast Calls execute atomic operations. The call appears to be atomic from the perspective of the calling PE, and returns when the requested operation has completed.
  • Yielding Calls start operations that can be pre-empted by a Non-secure interrupt. The call can return before the requested operation has completed.

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

• TEEC_InitializeContext()
  • teec_open_dev()
    • Open /dev/teeX device.
• TEEC_OpenSession()
  • Call ioctl() with TEE_IOC_OPEN_SESSION command.
    • This will eventually trap to Linux Kernel’s tee_ioctl().
• TEEC_InvokeCommand()
  • Call ioctl() with TEE_IOC_INVOKE command. The command ID for TA is passed through arg->func.
• TEEC_CloseSession()
  • Call ioctl() with TEE_IOC_CLOSE_SESSION command.
• TEEC_FinalizeContext()
  • Close /dev/teeX device.

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

• std_abi_entry()
  • If args->a0:
    • OPTEE_ABI_CALL_WITH_ARG or OPTEE_ABI_CALL_WITH_RPC_ARG:
      • std_entry_with_parg()
        • call_entry_std()
          • tee_entry_std()
            • __tee_entry_std()
    • OPTEE_ABI_CALL_WITH_REGD_ARG:
      • std_entry_with_regd_arg()
• __tee_entry_std()
  • Call thread_set_foreign_intr() to enable all foreign interrupts.
  • If arg->cmd:
    • OPTEE_MSG_CMD_OPEN_SESSION:
      • entry_open_session()
    • OPTEE_MSG_CMD_CLOSE_SESSION:
      • entry_close_session()
    • OPTEE_MSG_CMD_INVOKE_COMMAND:
      • entry_invoke_command()
    • OPTEE_MSG_CMD_CANCEL:
      • entry_cancel()
    • OPTEE_MSG_CMD_REGISTER_SHM:
      • register_shm()
    • OPTEE_MSG_CMD_UNREGISTER_SHM:
      • unregister_shm()
    • …

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

• thread_rpc_cmd()
  • Call thread_rpc() with rpc_args (rv[THREAD_RPC_NUM_ARGS]). rpc_args’s first element is set to OPTEE_ABI_RETURN_RPC_CMD function.
• thread_rpc()
  • Call __thread_rpc()
• __thread_rpc()
  • Call xstatus_for_xret() to get xstatus with xstatus.PIE set to 0, xstatus.PP set to S-mode.
    • The returned xstatus is passed to thread_rpc_xstatus().
  • Call thread_rpc_xstatus().

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110

// core/arch/riscv/kernel/thread_optee_abi_rv.S

/*
 * void thread_rpc_xstatus(uint32_t rv[THREAD_RPC_NUM_ARGS],
 *                         unsigned long status);
 */
FUNC thread_rpc_xstatus , :
	// Allocate stack space for 8 registers.
	 /* Use stack for temporary storage */
	addi	sp, sp, -REGOFF(8)

	/* Read xSTATUS */
	csrr	a2, CSR_XSTATUS

	/* Mask all maskable exceptions before switching to temporary stack */
	csrw	CSR_XIE, x0

	/* Save return address xSTATUS and pointer to rv */
	// $a0: rv[THREAD_RPC_NUM_ARGS]
	// $a1: xstatus to restore
	// $a2: current xstatus
	STR	a0, REGOFF(0)(sp)
	STR	a1, REGOFF(1)(sp)
	STR	s0, REGOFF(2)(sp)
	STR	ra, REGOFF(3)(sp)
	STR	a2, REGOFF(4)(sp)
#ifdef CFG_UNWIND
	addi	s0, sp, REGOFF(8)
#endif

	/* Save thread state */
	jal	thread_get_ctx_regs
	// $a0 = current thread's struct thread_ctx.

	// Restore $ra.
	LDR	ra, REGOFF(3)(sp)
	/* Save ra, sp, gp, tp, and s0~s11 */
	store_xregs a0, THREAD_CTX_REG_RA, REG_RA, REG_TP
	store_xregs a0, THREAD_CTX_REG_S0, REG_S0, REG_S1
	store_xregs a0, THREAD_CTX_REG_S2, REG_S2, REG_S11

	/* Get to tmp stack */
	jal	thread_get_tmp_sp
	// $a0 = tmp stack.

	/* Get pointer to rv */
	LDR	s1, REGOFF(0)(sp)
	// $s1 = rv[THREAD_RPC_NUM_ARGS]

	/* xSTATUS to restore */
	LDR	a1, REGOFF(1)(sp)
	// $a1 = xstatus to restore

	/* Switch to tmp stack */
	mv	sp, a0

	/* Early load rv[] into s2-s4 */
	lw	s2, 0(s1)
	lw	s3, 4(s1)
	lw	s4, 8(s1)

	li	a0, THREAD_FLAGS_COPY_ARGS_ON_RETURN
	la	a2, .thread_rpc_return

	// We are about to return to untrusted domain for RPC,
	// suspend the current thread.
	jal	[thread_state_suspend](/posts/optee-threads/)
	// $a0 = thread index before suspend.

	mv	a4, a0	/* thread index */
	mv	a1, s2	/* rv[0] */
	mv	a2, s3	/* rv[1] */
	mv	a3, s4	/* rv[2] */
	li	a0, TEEABI_OPTEED_RETURN_CALL_DONE
	mv	a5, zero

	/* Return to untrusted domain */
	// $a0: TEEABI_OPTEED_RETURN_CALL_DONE
	// $a1: rv[0], e.g. OPTEE_ABI_RETURN_RPC_CMD
	// $a2: rv[1]
	// $a3: rv[2]
	// $a4: thread index before suspend.
	jal	[thread_return_to_udomain](/posts/optee-threads/)
.thread_rpc_return:
	/*
	 * Jumps here from thread_resume() above when RPC has returned.
	 * At this point has the stack pointer been restored to the value
	 * stored in THREAD_CTX above.
	 */

	/* Get pointer to rv[] */
	LDR	a4, REGOFF(0)(sp)

	/* Store a0-a3 into rv[] */
	sw	a0, 0(a4)
	sw	a1, 4(a4)
	sw	a2, 8(a4)
	sw	a3, 12(a4)

	/* Pop saved XSTATUS from stack */
	LDR	s0, REGOFF(4)(sp)
	csrw	CSR_XSTATUS, s0

	/* Pop s0 from stack */
	LDR	s0, REGOFF(2)(sp)

	addi	sp, sp, REGOFF(8)
	ret
END_FUNC thread_rpc_xstatus
DECLARE_KEEP_PAGER thread_rpc_xstatus

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

• ldelf_hex.c is generated by scripts/gen_ldelf_hex.py from the input file: ldelf.elf and is included by OP-TEE, i.e. ldelf_data[], ldelf_code_size, ldelf_data_size, and ldelf_entry.
  • ldelf sources: <optee-src>/ldelf/
  • ldelf is running in U-mode.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

// core/kernel/ldelf_loader.c

/*
 * This function may leave a few mappings behind on error, but that's taken
 * care of by tee_ta_init_user_ta_session() since the entire context is
 * removed then.
 */
TEE_Result ldelf_load_ldelf(struct user_mode_ctx *uctx)
{
	TEE_Result res = TEE_SUCCESS;
	vaddr_t stack_addr = 0;
	vaddr_t code_addr = 0;
	vaddr_t rw_addr = 0;
	vaddr_t bb_addr = 0;
	uint32_t prot = 0;

	uctx->is_32bit = is_32bit;

	// Allocate memory for bounce buffer.
	res = alloc_and_map_fobj(uctx, BOUNCE_BUFFER_SIZE, TEE_MATTR_PRW, 0,
				 &bb_addr);
	if (res)
		return res;
	uctx->bbuf = (void *)bb_addr;
	uctx->bbuf_size = BOUNCE_BUFFER_SIZE;

	// Allocate stack memory for ldelf.
	res = alloc_and_map_fobj(uctx, LDELF_STACK_SIZE,
				 TEE_MATTR_URW | TEE_MATTR_PRW, VM_FLAG_LDELF,
				 &stack_addr);
	if (res)
		return res;
	uctx->ldelf_stack_ptr = stack_addr + LDELF_STACK_SIZE;

  // Allocate code section memory for ldelf.
	res = alloc_and_map_fobj(uctx, ldelf_code_size, TEE_MATTR_PRW,
				 VM_FLAG_LDELF, &code_addr);
	if (res)
		return res;
	// Assign uctx->entry_func to ldelf's entry point, i.e. [_ldelf_start()](/posts/optee-ldelf/).
	uctx->entry_func = code_addr + ldelf_entry;

	// Allocate data section memory for ldelf.
	rw_addr = ROUNDUP(code_addr + ldelf_code_size, SMALL_PAGE_SIZE);
	res = alloc_and_map_fobj(uctx, ldelf_data_size,
				 TEE_MATTR_URW | TEE_MATTR_PRW, VM_FLAG_LDELF,
				 &rw_addr);
	if (res)
		return res;

	vm_set_ctx(uctx->ts_ctx);

	// Copy ldelf codes.
	// ldelf_data[] includes both ldelf's codes and data.
	// ldelf_data[] is generated by script/gen_ldelf_hex.py.
	memcpy((void *)code_addr, ldelf_data, ldelf_code_size);

	// Copy ldelf data.
	res = copy_to_user((void *)rw_addr, ldelf_data + ldelf_code_size,
			   ldelf_data_size);
	if (res)
		return res;

	prot = TEE_MATTR_URX;
	if (IS_ENABLED(CFG_CORE_BTI))
		prot |= TEE_MATTR_GUARDED;

	res = vm_set_prot(uctx, code_addr,
			  ROUNDUP(ldelf_code_size, SMALL_PAGE_SIZE), prot);
	if (res)
		return res;

	DMSG("ldelf load address %#"PRIxVA, code_addr);

	return TEE_SUCCESS;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// core/kernel/ldelf_loader.c

TEE_Result ldelf_init_with_ldelf(struct ts_session *sess,
				 struct user_mode_ctx *uctx)
{
	TEE_Result res = TEE_SUCCESS;
	struct ldelf_arg *arg = NULL;
	uint32_t panic_code = 0;
	uint32_t panicked = 0;
	uaddr_t usr_stack = 0;
	struct ldelf_arg *arg_bbuf = NULL;

	// Set user stack.
	usr_stack = uctx->ldelf_stack_ptr;
	usr_stack -= ROUNDUP(sizeof(*arg), STACK_ALIGNMENT);
	arg = (struct ldelf_arg *)usr_stack;
	// Temporay overwrites handle_scall() with [scall_handle_ldelf()](/posts/optee-ldelf/).
	sess->handle_scall = scall_handle_ldelf;

	res = clear_user(arg, sizeof(*arg));
	if (res)
		return res;

	// Copy UUID to &arg->uuid.
	res = PUT_USER_SCALAR(uctx->ts_ctx->uuid, &arg->uuid);
	if (res)
		return res;

	// uctx->entry_func is set to ldelf's entry point, i.e. [_ldelf_start()](/posts/optee-ldelf/),
	// in [ldelf_load_ldelf()](/posts/optee-ldelf/).
	// Switch to U-mode to execute ldelf.
	// ldelf will fill in arg parameter of the TA ELF.
	// E.g. arg->is_32bit, arg->entry_func, arg->load_addr, arg->stack_ptr... etc.
	res = [thread_enter_user_mode](/posts/optee-threads/)((vaddr_t)arg, 0, 0, 0,
				     usr_stack, uctx->entry_func,
				     is_32bit, &panicked, &panic_code);

	// Restore handle_scall().
	sess->handle_scall = sess->ctx->ops->handle_scall;
	thread_user_clear_vfp(uctx);
	ldelf_sess_cleanup(sess);

	if (panicked) {
		abort_print_current_ts();
		EMSG("ldelf panicked");
		return TEE_ERROR_GENERIC;
	}
	if (res) {
		EMSG("ldelf failed with res: %#"PRIx32, res);
		return res;
	}

	res = BB_MEMDUP_USER(arg, sizeof(*arg), &arg_bbuf);
	if (res)
		return res;

	if (is_user_ta_ctx(uctx->ts_ctx)) {
		/*
		 * This is already checked by the elf loader, but since it runs
		 * in user mode we're not trusting it entirely.
		 */
		if (arg_bbuf->flags & ~TA_FLAGS_MASK)
			return TEE_ERROR_BAD_FORMAT;

		to_user_ta_ctx(uctx->ts_ctx)->ta_ctx.flags = arg_bbuf->flags;
	}

	// Copy TA ELF's information to struct user_mode_ctx.
	uctx->is_32bit = arg_bbuf->is_32bit;
	uctx->entry_func = arg_bbuf->entry_func;
	uctx->load_addr = arg_bbuf->load_addr;
	uctx->stack_ptr = arg_bbuf->stack_ptr;
	uctx->dump_entry_func = arg_bbuf->dump_entry;
#ifdef CFG_FTRACE_SUPPORT
	uctx->ftrace_entry_func = arg_bbuf->ftrace_entry;
	sess->fbuf = arg_bbuf->fbuf;
#endif
	uctx->dl_entry_func = arg_bbuf->dl_entry;

	bb_free(arg_bbuf, sizeof(*arg));

	return TEE_SUCCESS;
}

• scall_handle_ldelf()

  • Handle syscall according to ldelf_syscall_table:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  // core/kernel/syscall.c /* * The ldelf return, log, panic syscalls have the same functionality and syscall * number as the user TAs'. To avoid unnecessary code duplication, the ldelf SVC * handler doesn't implement separate functions for these. */ static const struct syscall_entry ldelf_syscall_table[] = { SYSCALL_ENTRY(syscall_sys_return), SYSCALL_ENTRY(syscall_log), SYSCALL_ENTRY(syscall_panic), SYSCALL_ENTRY(ldelf_syscall_map_zi), SYSCALL_ENTRY(ldelf_syscall_unmap), SYSCALL_ENTRY(ldelf_syscall_open_bin), SYSCALL_ENTRY(ldelf_syscall_close_bin), SYSCALL_ENTRY(ldelf_syscall_map_bin), SYSCALL_ENTRY(ldelf_syscall_copy_from_bin), SYSCALL_ENTRY(ldelf_syscall_set_prot), SYSCALL_ENTRY(ldelf_syscall_remap), SYSCALL_ENTRY(ldelf_syscall_gen_rnd_num), };

• _ldelf_start()
  • ldelf()
    • ta_elf_load_main()
      • load_main()
        • init_elf()
          • sys_open_ta_bin()
            • _ldelf_open_bin()
              • Issue LDELF_OPEN_BIN syscall, which will eventually call ldelf_syscall_open_bin()
  • _ldelf_return()
    • Issue LDELF_RETURN syscall, which will eventually call syscall_sys_return()

• ldelf_syscall_open_bin()

  • If the session is for user TAs, look up user TA ELF by UUID. Currently, there are three ways (TA storages) to load user TA in OP-TEE:

    • Early TA
    • REE filesystem TA
    • REE-FS TA rollback protection

    ---

    • Each TA storage is registered by REGISTER_TA_STORE() and is stored into ta_stores scattered array in the priority order, e.g.

      • Early TA:

        1 2 3 4 5 6 7 8 9 10

        // core/kernel/early_ta.c REGISTER_TA_STORE(2) = { .description = "early TA", .open = early_ta_open, .get_size = emb_ts_get_size, .get_tag = emb_ts_get_tag, .read = emb_ts_read, .close = emb_ts_close, };

      • Secure Storage TA:

        1 2 3 4 5 6 7 8 9 10

        // core/kernel/secstor_ta.c REGISTER_TA_STORE(4) = { .description = "Secure Storage TA", .open = secstor_ta_open, .get_size = secstor_ta_get_size, .get_tag = secstor_ta_get_tag, .read = secstor_ta_read, .close = secstor_ta_close, };

      • REE filesystem TA:

        1 2 3 4 5 6 7 8 9 10

        // core/kernel/ree_fs_ta.c REGISTER_TA_STORE(9) = { .description = "REE", .open = ree_fs_ta_open, .get_size = ree_fs_ta_get_size, .get_tag = ree_fs_ta_get_tag, .read = ree_fs_ta_read, .close = ree_fs_ta_close, };

  • Iterates each TA storage, call their op->open() callback, e.g. ree_fs_ta_open() .

    • Each TA storage’s op->open() is responsible for comparing UUID (either by itself or through thread RPC) to determine whether user TA for UUID can be found or not.
      • Returns TEE_ERROR_ITEM_NOT_FOUND if user TA for UUID cannot be found.

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

• Reference:

  Trusted Applications — OP-TEE documentation documentation

• ree_fs_ta_open()
  • Call rpc_load() to request TA from tee-supplicant.
  • Validate the loaded TA.
• rpc_load()
  • Call thread_rpc_cmd() with OPTEE_RPC_CMD_LOAD_TA RPC command without struct thread_param_memref parameter to request the size of TA.
    • OPTEE_RPC_CMD_LOAD_TA RPC command is saved to struct optee_msg_arg.cmd.
    • struct optee_msg_arg is stored in the shared memory shared with the untrusted domain.
  • Call thread_rpc_alloc_payload() to allocate data for TA.
    • Call thread_rpc_alloc() to allocate shared memory for TA.
      • Call thread_rpc() with rpc_args (rv[THREAD_RPC_NUM_ARGS]). rpc_args’s first element is set to OPTEE_ABI_RETURN_RPC_CMD function. The RPC command is set to OPTEE_RPC_CMD_SHM_ALLOC to allocate the shared memory for TA.
  • Call thread_rpc_cmd() with OPTEE_RPC_CMD_LOAD_TA RPC command again with struct thread_param_memref parameter to load TA.

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

• tee_ta_init_user_ta_session()

  • Initialize user TA for the UUID, assign ctx->ts_ctx.ops to user_ta_ops by calling set_ta_ctx_ops(). user_ta_ops will be the global callbacks for the user TAs; assign tee_ta_session->ts_sess.handle_scall to scall_handle_user_ta(). scall_handle_user_ta() will be the default callback to handle the syscall from user TA:

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

    // core/kernel/user_ta.c TEE_Result tee_ta_init_user_ta_session(const TEE_UUID *uuid, struct tee_ta_session *s) { TEE_Result res = TEE_SUCCESS; struct user_ta_ctx *utc = NULL; ..... // Initialize lists. TAILQ_INIT(&utc->open_sessions); TAILQ_INIT(&utc->cryp_states); TAILQ_INIT(&utc->objects); TAILQ_INIT(&utc->storage_enums); condvar_init(&utc->ta_ctx.busy_cv); utc->ta_ctx.ref_count = 1; /* * Set context TA operation structure. It is required by generic * implementation to identify userland TA versus pseudo TA contexts. */ // utc->ta_ctx->ts_ctx.ops = [user_ta_ops](/posts/optee-user-tas/). set_ta_ctx_ops(&utc->ta_ctx); utc->ta_ctx.ts_ctx.uuid = *uuid; // vm_info_init() will set: utc->uctx->ts_ctx = &utc->ta_ctx.ts_ctx. res = vm_info_init(&utc->uctx, &utc->ta_ctx.ts_ctx); if (res) { condvar_destroy(&utc->ta_ctx.busy_cv); free_utc(utc); return res; } ..... utc->ta_ctx.is_initializing = true; ..... s->ts_sess.ctx = &utc->ta_ctx.ts_ctx; s->ts_sess.handle_scall = s->ts_sess.ctx->ops->handle_scall; /* * Another thread trying to load this same TA may need to wait * until this context is fully initialized. This is needed to * handle single instance TAs. */ TAILQ_INSERT_TAIL(&tee_ctxes, &utc->ta_ctx, link); return TEE_SUCCESS; }

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

    // core/kernel/user_ta.c /* * Note: this variable is weak just to ease breaking its dependency chain * when added to the unpaged area. */ const struct ts_ops user_ta_ops __weak __relrodata_unpaged("user_ta_ops") = { .enter_open_session = user_ta_enter_open_session, .enter_invoke_cmd = user_ta_enter_invoke_cmd, .enter_close_session = user_ta_enter_close_session, #if defined(CFG_TA_STATS) .dump_mem_stats = user_ta_enter_dump_memstats, #endif .dump_state = user_ta_dump_state, #ifdef CFG_FTRACE_SUPPORT .dump_ftrace = user_ta_dump_ftrace, #endif .release_state = user_ta_release_state, .destroy = user_ta_ctx_destroy, .get_instance_id = user_ta_get_instance_id, .handle_scall = scall_handle_user_ta, #ifdef CFG_TA_GPROF_SUPPORT .gprof_set_status = user_ta_gprof_set_status, #endif };

• tee_ta_complete_user_ta_session()
  • Call ldelf_load_ldelf() to load ldelf program to the memory for this User TA.
    • ldelf is responsible for loading the user TA ELF image residing in REE to the memory.
    • If ldelf_load_ldelf() returns TEE_SUCCESS, call ldelf_init_with_ldelf()
      • ldelf_load_ldelf() loads user TA ELF and fill in user TA ELF’s information to struct user_mode_ctx.

• user_ta_enter_open_session()
  • Call user_ta_enter() with function ID: UTEE_ENTRY_FUNC_OPEN_SESSION.

• user_ta_enter_invoke_cmd()
  • Call user_ta_enter() with function ID: UTEE_ENTRY_FUNC_INVOKE_COMMAND.

• user_ta_enter()
  • Call thread_enter_user_mode() to switch to U-mode. utc->utcx.entry_func (user TA’s entry function address, filled by ldelf) will be called after switching to U-mode.
    • E.g. For optee_example_hello_world, i.e. 8aaaf200-2450-11e4-abe2-0002a5d5c51b.elf, the entry_func is 0x400405f8 => __ta_entry().
      • __ta_entry() is the first user TA API called from TEE core (defined in ta/user_ta_header.c).

        • It’s assigned in TA’s Makefile:

          1 2 3

          # ta/link.mk link-ldflags = -e__ta_entry -pie

        • __ta_entry() will call __utee_entry() (defined in lib/libutee/user_ta_entry.c) to invoke the function (e.g. TA_OpenSessionEntryPoint(), TA_InvokeCommandEntryPoint()… etc) defined by user TA based on function ID.

          • User TA is linked with libutee.

        • And the end, __ta_entry() will call __utee_return() (defined in lib/libutee/user_ta_entry.c), to return from user TA.

        • __utee_return() is actually a syscall, syscall ID: TEE_SCN_RETURN. Therefore, tee_ta_session->ts_sess.handle_scall, e.g. scall_handle_user_ta(), will eventually be called.

• scall_handle_user_ta():

  • Handle syscall according to tee_syscall_table:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

  // core/kernel/syscall.c /* * This array is ordered according to the SYSCALL ids TEE_SCN_xxx */ static const struct syscall_entry tee_syscall_table[] = { SYSCALL_ENTRY(syscall_sys_return), SYSCALL_ENTRY(syscall_log), SYSCALL_ENTRY(syscall_panic), SYSCALL_ENTRY(syscall_get_property), SYSCALL_ENTRY(syscall_get_property_name_to_index), SYSCALL_ENTRY(syscall_open_ta_session), SYSCALL_ENTRY(syscall_close_ta_session), SYSCALL_ENTRY(syscall_invoke_ta_command), SYSCALL_ENTRY(syscall_check_access_rights), SYSCALL_ENTRY(syscall_get_cancellation_flag), SYSCALL_ENTRY(syscall_unmask_cancellation), SYSCALL_ENTRY(syscall_mask_cancellation), SYSCALL_ENTRY(syscall_wait), SYSCALL_ENTRY(syscall_get_time), SYSCALL_ENTRY(syscall_set_ta_time), SYSCALL_ENTRY(syscall_cryp_state_alloc), SYSCALL_ENTRY(syscall_cryp_state_copy), SYSCALL_ENTRY(syscall_cryp_state_free), SYSCALL_ENTRY(syscall_hash_init), SYSCALL_ENTRY(syscall_hash_update), SYSCALL_ENTRY(syscall_hash_final), SYSCALL_ENTRY(syscall_cipher_init), SYSCALL_ENTRY(syscall_cipher_update), SYSCALL_ENTRY(syscall_cipher_final), SYSCALL_ENTRY(syscall_cryp_obj_get_info), SYSCALL_ENTRY(syscall_cryp_obj_restrict_usage), SYSCALL_ENTRY(syscall_cryp_obj_get_attr), SYSCALL_ENTRY(syscall_cryp_obj_alloc), SYSCALL_ENTRY(syscall_cryp_obj_close), SYSCALL_ENTRY(syscall_cryp_obj_reset), SYSCALL_ENTRY(syscall_cryp_obj_populate), SYSCALL_ENTRY(syscall_cryp_obj_copy), SYSCALL_ENTRY(syscall_cryp_derive_key), SYSCALL_ENTRY(syscall_cryp_random_number_generate), SYSCALL_ENTRY(syscall_authenc_init), SYSCALL_ENTRY(syscall_authenc_update_aad), SYSCALL_ENTRY(syscall_authenc_update_payload), SYSCALL_ENTRY(syscall_authenc_enc_final), SYSCALL_ENTRY(syscall_authenc_dec_final), SYSCALL_ENTRY(syscall_asymm_operate), SYSCALL_ENTRY(syscall_asymm_verify), SYSCALL_ENTRY(syscall_storage_obj_open), SYSCALL_ENTRY(syscall_storage_obj_create), SYSCALL_ENTRY(syscall_storage_obj_del), SYSCALL_ENTRY(syscall_storage_obj_rename), SYSCALL_ENTRY(syscall_storage_alloc_enum), SYSCALL_ENTRY(syscall_storage_free_enum), SYSCALL_ENTRY(syscall_storage_reset_enum), SYSCALL_ENTRY(syscall_storage_start_enum), SYSCALL_ENTRY(syscall_storage_next_enum), SYSCALL_ENTRY(syscall_storage_obj_read), SYSCALL_ENTRY(syscall_storage_obj_write), SYSCALL_ENTRY(syscall_storage_obj_trunc), SYSCALL_ENTRY(syscall_storage_obj_seek), SYSCALL_ENTRY(syscall_obj_generate_key), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_not_supported), SYSCALL_ENTRY(syscall_cache_operation), };

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

• tee_ta_init_pseudo_ta_session()

  • Look up the pseudo TA based on UUID.

  • Create pseudo TA context for the UUID, assign ctx->ts_ctx.ops to pseudo_ta_ops. pseudo_ta_ops will be the global callbacks for the pseudo TAs:

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

    // core/kernel/pseudo_ta.c TEE_Result tee_ta_init_pseudo_ta_session(const TEE_UUID *uuid, struct tee_ta_session *s) { ..... ctx->ref_count = 1; ctx->flags = ta->flags; stc->pseudo_ta = ta; ctx->ts_ctx.uuid = ta->uuid; ctx->ts_ctx.ops = &pseudo_ta_ops; ..... }

    1 2 3 4 5 6 7 8

    // core/kernel/pseudo_ta.c static const struct ts_ops pseudo_ta_ops = { .enter_open_session = pseudo_ta_enter_open_session, .enter_invoke_cmd = pseudo_ta_enter_invoke_cmd, .enter_close_session = pseudo_ta_enter_close_session, .destroy = pseudo_ta_destroy, };

• pseudo_ta_enter_open_session()
  • Call stc->pseudo_ta->open_session_entry_point() callback, if defined.

    • E.g. If the opened session is for pseudo TA: rtc.pta, open_session_entry_point() callback is: open_session():

      1 2 3 4 5 6 7

      // core/pta/rtc.c pseudo_ta_register(.uuid = PTA_RTC_UUID, .name = PTA_NAME, .flags = PTA_DEFAULT_FLAGS | TA_FLAG_CONCURRENT | TA_FLAG_DEVICE_ENUM, .open_session_entry_point = open_session, .invoke_command_entry_point = invoke_command);

• pseudo_ta_enter_invoke_cmd()
  • Call stc->pseudo_ta->invoke_command_entry_point() callback.

    • E.g. If the opened session is for pseudo TA: device.pta, invoke_command_entry_point() callback is: invoke_command(), which will call get_devices() to retrieve the UUIDs of the pseudo TAs:

      1 2 3 4 5

      // core/pta/device.c pseudo_ta_register(.uuid = PTA_DEVICE_UUID, .name = PTA_NAME, .flags = PTA_DEFAULT_FLAGS, .invoke_command_entry_point = invoke_command);

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

• entry_open_session()
  • Open the session based on the UUID.
  • tee_ta_open_session()
• tee_ta_open_session()
  • tee_ta_init_session()
  • Call ts_ctx->ops->enter_open_session() callback,
    • For pseudo TAs, the callback is: pseudo_ta_enter_open_session()
    • For user TAs, the callback is user_ta_enter_open_session()
• tee_ta_init_session()
  • Look for already loaded TA
    • tee_ta_init_session_with_context()
  • If the TA for this UUID is not loaded yet:
    • Look for secure partition
      • stmm_init_session()
    • Look for pseudo TA
      • tee_ta_init_pseudo_ta_session()
    • Look for user TA
      • tee_ta_init_user_ta_session()
      • If tee_ta_init_user_ta_session() returns TEE_SUCCESS, call tee_ta_complete_user_ta_session()

• entry_invoke_command()
  • Call tee_ta_get_session() to get the opened session from arg->session.
  • Call tee_ta_invoke_command() on the opened session.
    • Call ts_ctx->ops->enter_invoke_cmd():
    • For pseudo TAs, the callback is: pseudo_ta_enter_invoke_cmd()
    • For user TAs, the call back is: user_ta_enter_invoke_cmd()

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

• mpxy_opteed_channel_init()

  • Check if MPXY extension is supported by OpenSBI.
  • Extract MPXY channel ID from DT:

    • compatible = “riscv,sbi-mpxy-opteed";

    • riscv,sbi-mpxy-channel-id ← Defines MPXY channel ID.

      • Save MPXY channel ID to mpxy_opteed_ctx.channel_id.

    • opensbi-domain-instance ← Defines the OpenSBI domain used by OP-TEE (not used by OP-TEE).

      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

      chosen { opensbi-domains { trusted-domain { compatible = "opensbi,domain,instance"; regions = <0x04 0x3f>; possible-harts = <0x03 0x01>; next-addr = <0x00 0xf1000000>; next-mode = <0x01>; phandle = <0x02>; }; }; sbi-mpxy-opteed { opensbi-domain-instance = <0x02>; riscv,sbi-mpxy-channel-id = <0x02>; compatible = "riscv,sbi-mpxy-opteed"; };

• sbi_mpxy_setup_shmem()

  • Allocates 4KB MPXY shared memory (4KB aligned).
  • Call sbi_mpxy_set_shmem SBI call to set up the allocated MPXY shared memory for the current core. This will invoke OpenSBI’s sbi_mpxy_set_shmem() to save the shared memory address and size into current hart tdomain’s mpxy_state.

• thread_return_to_udomain_by_mpxy()

  • Save the args (arg0, arg1, arg2, arg3, arg4) to TX buffer (struct optee_msg_payload).
  • Issue SBI call: Send Message with Response (FID #4) with message ID: OPTEED_MSG_COMPLETE (0x2).
    • sbi_mpxy_send_message_withresp()

• sbi_mpxy_send_message_withresp()

  • Send Message with Response (FID #4)
    1. Copy the message from TX buffer to the shared memory.
    2. Issue the SBI call. Switch to OpenSBI and jump to: sbi_ecall_mpxy_handler()
    3. If ret.error is success:
       1. Copy the response message from the shared memory to the RX buffer.

⚠️ The code is based on: https://gitlab.com/riseproject/riscv-optee/optee_os/-/tree/dev-optee-mpxy

Commit ID: 75df9ba41a404aec897399ead0ff0aebcbff48ca

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// core/arch/riscv/include/kernel/thread_arch.h

struct thread_core_local {
	unsigned long x[4];
	uint32_t hart_id;
	vaddr_t tmp_stack_va_end;
	short int curr_thread;
	uint32_t flags;
	vaddr_t abt_stack_va_end;
#ifdef CFG_TEE_CORE_DEBUG
	unsigned int locked_count; /* Number of spinlocks held */
#endif
#ifdef CFG_CORE_DEBUG_CHECK_STACKS
	bool stackcheck_recursion;
#endif
#ifdef CFG_FAULT_MITIGATION
	struct ftmn_func_arg *ftmn_arg;
#endif
} THREAD_CORE_LOCAL_ALIGNED;

1
2
3
4

// core/kernel/thread.c

// Per-core local threads.
struct thread_core_local thread_core_local[CFG_TEE_CORE_NB_CORE] __nex_bss;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// core/arch/riscv/kernel/entry.S

/*
 * Implement based on the transport method used to communicate between
 * untrusted domain and trusted domain. It could be an SBI/ECALL-based to
 * a security monitor running in M-Mode and panic or messaging-based across
 * domains where we return to a messaging callback which parses and handles
 * messages.
 *
 * void thread_return_to_udomain(unsigned long arg0, unsigned long arg1,
 *                               unsigned long arg2, unsigned long arg3,
 *                               unsigned long arg4, unsigned long arg5);
 */
FUNC thread_return_to_udomain , :
	/* Caller should provide arguments in a0~a5 */
	// E.g. when booting:
	//   $a0: If boot core: TEEABI_OPTEED_RETURN_ENTRY_DONE.
	//        Otherwise: TEEABI_OPTEED_RETURN_ON_DONE.
	//   $a1: If boot core: thread_vector_table.
	//        Otherwise: 0x0 (OPTEE_ABI_RETURN_OK) on success
	//                   or anything else to indicate error condition.
	//   $a2 ~ $a5: 0x0
#if defined(CFG_RISCV_WITH_M_MODE_SM)
	jal	[thread_return_to_udomain_by_mpxy](/posts/optee-sbi-mpxy/)
#else
	/* Other protocol */
#endif
	/* ABI to REE should not return */
	panic_at_abi_return
END_FUNC thread_return_to_udomain

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// core/arch/riscv/kernel/thread_optee_abi_rv.S

/*
 * Vector table supplied to M-mode secure monitor (e.g., openSBI) at
 * initialization.
 *
 * Note that M-mode secure monitor depends on the layout of this vector table,
 * any change in layout has to be synced with M-mode secure monitor.
 */
FUNC thread_vector_table , : , .identity_map, , nobti
	.option push
	.option norvc
	j   [vector_std_abi_entry](/posts/optee-threads/)
	j   [vector_fast_abi_entry](/posts/optee-threads/)
	j   .
	j   .
	j   .
	j   .
	j   vector_fiq_entry
	j   .
	j   .
	.option pop
END_FUNC thread_vector_table
DECLARE_KEEP_PAGER thread_vector_table

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// core/arch/riscv/kernel/thread_optee_abi_rv.S

LOCAL_FUNC vector_std_abi_entry, : , .identity_map
	// sbi_mpxy_get_shmem() returns VA of the shared memory.
	jal	sbi_mpxy_get_shmem
	// Shared memory contents: struct thread_abi_args *arg
	jal	[thread_handle_std_abi](/posts/optee-threads/)
	/*
	 * Normally thread_handle_std_abi() should return via
	 * thread_exit(), thread_rpc(), but if thread_handle_std_abi()
	 * hasn't switched stack (error detected) it will do a normal "C"
	 * return.
	 */
	/* Restore thread_handle_std_abi() return value */
	mv	a1, a0
	li	a2, 0
	li	a3, 0
	li	a4, 0
	// Function ID: This will be placed as the first item in the shared memory.
	li	a0, TEEABI_OPTEED_RETURN_CALL_DONE
	mv	a5, zero

	/* Return to untrusted domain */
	j	[thread_return_to_udomain](/posts/optee-threads/)
END_FUNC vector_std_abi_entry

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// core/arch/riscv/kernel/thread_optee_abi_rv.S

LOCAL_FUNC vector_fast_abi_entry , : , .identity_map
  // sbi_mpxy_get_shmem() returns VA of the shared memory.
	jal	sbi_mpxy_get_shmem
	// Save the shared memory contents to $a0 ~ $a7
	mv	t0, a0
	ld	a0, 0(t0)
	ld	a1, 8(t0)
	ld	a2, 16(t0)
	ld	a3, 24(t0)
	ld	a4, 32(t0)
	ld	a5, 40(t0)
	ld	a6, 48(t0)
	ld	a7, 56(t0)

	// Allocate space on stack to save $a0 ~ $a7.
	addi    sp, sp, -THREAD_ABI_ARGS_SIZE
	// Store $a0 ~ $a7 to stack so that we can pass
	// the pointer to thread_handle_fast_abi()
	store_xregs sp, THREAD_ABI_ARGS_A0, REG_A0, REG_A7
	mv      a0, sp
	jal	thread_handle_fast_abi
	// Restore $a0 ~ $a7 from the stack.
	load_xregs sp, THREAD_ABI_ARGS_A0, REG_A1, REG_A7
	// Release the allocated space.
	addi    sp, sp, THREAD_ABI_ARGS_SIZE

	// Function ID: This will be placed as the first item in the shared memory.
	li	a0, TEEABI_OPTEED_RETURN_CALL_DONE
	/* Return to untrusted domain */
	j	[thread_return_to_udomain](/posts/optee-threads/)
END_FUNC vector_fast_abi_entry