TEE-TA学习轨迹第二篇：pseudo内置TA的注册和启动

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

SCATTERED_ARRAY_DEFINE_PG_ITEM(pseudo_tas, struct pseudo_ta_head) = 
{
    .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
};

__SCT_ARRAY_DEF_PG_ITEM1(pseudo_tas, 0, 0, struct pseudo_ta_head) = 
{ /* 初始化参数同上 */ };

• 变量名：__scattered_array_ ## id ## _ ## array_name → __scattered_array_0_pseudo_tas
• 段名：".scattered_array_" #array_name "_1_" #order → ".scattered_array_pseudo_tas_1_0"

__SCT_ARRAY_DEF_PG_ITEM3(
    struct pseudo_ta_head,
    __scattered_array_0_pseudo_tas,
    ".scattered_array_pseudo_tas_1_0"
) = { /* 初始化参数同上 */ };

static const struct pseudo_ta_head __scattered_array_0_pseudo_tas __used
    __section(".scattered_array_pseudo_tas_1_0")
= {
    .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
};

• static const：文件内可见，只读不可修改，最终放入只读数据段，运行时无法篡改。
• __used：编译器层面保活，即使没有代码显式引用，也不会被当成死代码优化删除。
• __section(...)：强制将该结构体放到指定链接段中，所有内置TA都会被放到同名前缀的段内。

• __start_scattered_array_pseudo_tas：数组起始地址
• __end_scattered_array_pseudo_tas：数组结束地址

1. service_init宏展开后，生成一个struct initcall结构体，里面保存了函数指针verify_pseudo_tas_conformance。
2. 该结构体被放到.scattered_array_service_initcall_2_*段中。
3. 链接期所有service阶段的初始化函数合并为service_initcall分散数组，启动时批量执行。

#ifndef __INITCALL_H
#define __INITCALL_H

#include <scattered_array.h>
#include <tee_api_types.h>
#include <trace.h>

struct initcall {
	TEE_Result (*func)(void);
#if TRACE_LEVEL >= TRACE_DEBUG
	int level;
	const char *func_name;
#endif
};

#if TRACE_LEVEL >= TRACE_DEBUG
#define __define_initcall(type, lvl, fn) \
	SCATTERED_ARRAY_DEFINE_PG_ITEM_ORDERED(type ## call, lvl, \
					       struct initcall) = \
		{ .func = (fn), .level = (lvl), .func_name = #fn, }
#else
#define __define_initcall(type, lvl, fn) \
	SCATTERED_ARRAY_DEFINE_PG_ITEM_ORDERED(type ## call, lvl, \
					       struct initcall) = \
		{ .func = (fn), }
#endif

#define preinitcall_begin \
			SCATTERED_ARRAY_BEGIN(preinitcall, struct initcall)
#define preinitcall_end SCATTERED_ARRAY_END(preinitcall, struct initcall)

#define early_initcall_begin \
			SCATTERED_ARRAY_BEGIN(early_initcall, struct initcall)
#define early_initcall_end \
			SCATTERED_ARRAY_END(early_initcall, struct initcall)

#define service_initcall_begin \
			SCATTERED_ARRAY_BEGIN(service_initcall, struct initcall)
#define service_initcall_end \
			SCATTERED_ARRAY_END(service_initcall, struct initcall)

#define driver_initcall_begin \
			SCATTERED_ARRAY_BEGIN(driver_initcall, struct initcall)
#define driver_initcall_end \
			SCATTERED_ARRAY_END(driver_initcall, struct initcall)

#define finalcall_begin	SCATTERED_ARRAY_BEGIN(finalcall, struct initcall)
#define finalcall_end	SCATTERED_ARRAY_END(finalcall, struct initcall)

/*
 * The preinit_*(), *_init() and boot_final() macros are used to register
 * callback functions to be called at different stages during
 * initialization.
 *
 * Functions registered with preinit_*() are always called before functions
 * registered with *_init().
 *
 * Functions registered with boot_final() are called before exiting to
 * normal world the first time.
 *
 * Without virtualization this happens in the order of the defines below.
 *
 * However, with virtualization things are a bit different. boot_final()
 * functions are called first before exiting to normal world the first
 * time. Functions registered with boot_final() can only operate on the
 * nexus. preinit_*() functions are called early before the first yielding
 * call into the partition, in the newly created partition. *_init()
 * functions are called at the first yielding call.
 *
 *  +-------------------------------+-----------------------------------+
 *  | Without virtualization        | With virtualization               |
 *  +-------------------------------+-----------------------------------+
 *  | At the end of boot_init_primary_late() just before the print:     |
 *  | "Primary CPU switching to normal world boot"                      |
 *  +-------------------------------+-----------------------------------+
 *  | 1. call_preinitcalls()        | In the nexus, final calls         |
 *  | 2. call_initcalls()           +-----------------------------------+
 *  | 3. call_finalcalls()          | 1. nex_*init*() / boot_final()    |
 *  +-------------------------------+-----------------------------------+
 *  | "Primary CPU switching to normal world boot" is printed           |
 *  +-------------------------------+-----------------------------------+
 *                                  | A guest is created and            |
 *                                  | virt_guest_created() is called.   |
 *                                  | After the partition has been      |
 *                                  | created and activated.            |
 *                                  +-----------------------------------+
 *                                  | 2. call_preinitcalls()            |
 *                                  +-----------------------------------+
 *                                  | When the partition is receiving   |
 *                                  | the first yielding call           |
 *                                  | virt_on_stdcall() is called.      |
 *                                  +-----------------------------------+
 *                                  | 3. call_initcalls()               |
 *                                  +-----------------------------------+
 */

#define preinit_early(fn)		__define_initcall(preinit, 1, fn)
#define preinit(fn)			__define_initcall(preinit, 2, fn)
#define preinit_late(fn)		__define_initcall(preinit, 3, fn)

#define early_init(fn)			__define_initcall(early_init, 1, fn)
#define early_init_late(fn)		__define_initcall(early_init, 2, fn)
#define service_init_crypto(fn)		__define_initcall(service_init, 1, fn)
#define service_init(fn)		__define_initcall(service_init, 2, fn)
#define service_init_late(fn)		__define_initcall(service_init, 3, fn)
#define driver_init(fn)			__define_initcall(driver_init, 1, fn)
#define driver_init_late(fn)		__define_initcall(driver_init, 2, fn)
#define release_init_resource(fn)	__define_initcall(driver_init, 3, fn)

static TEE_Result verify_pseudo_tas_conformance(void)
{
	const struct pseudo_ta_head *start =
		SCATTERED_ARRAY_BEGIN(pseudo_tas, struct pseudo_ta_head);
	const struct pseudo_ta_head *end =
		SCATTERED_ARRAY_END(pseudo_tas, struct pseudo_ta_head);
	const struct pseudo_ta_head *pta;

	for (pta = start; pta < end; pta++) {
		const struct pseudo_ta_head *pta2;

		/* PTAs must all have a specific UUID */
		for (pta2 = pta + 1; pta2 < end; pta2++) {
			if (!memcmp(&pta->uuid, &pta2->uuid, sizeof(TEE_UUID)))
				goto err;
		}

		if (!pta->name ||
		    (pta->flags & PTA_MANDATORY_FLAGS) != PTA_MANDATORY_FLAGS ||
		    pta->flags & ~PTA_ALLOWED_FLAGS ||
		    !pta->invoke_command_entry_point)
			goto err;
	}
	return TEE_SUCCESS;
err:
	DMSG("pseudo TA error at %p", (void *)pta);
	panic("PTA");
}

service_init(verify_pseudo_tas_conformance);

_start (entry_a64.S 汇编入口)
  ↓
boot_init_primary_late / boot_init_primary_final
  ↓
call_service_initcalls()  ← 内置TA合规校验在此阶段执行
  ↓
后续初始化与首次切出

// 基于分散数组范式的注册逻辑，与校验复用同一张数组
const struct pseudo_ta_head *pta;
SCATTERED_ARRAY_FOREACH(pta, pseudo_tas, struct pseudo_ta_head) {
    tee_ta_register_pseudo_ta(pta); // 插入全局UUID哈希表
}

1. UUID唯一性校验：双重遍历所有内置TA，两两比对UUID，禁止重复UUID，防止TA冲突与恶意注入。
2. 字段合法性校验：检查每个TA的name非空、必填标志位正确、无非法标志位、invoke_command_entry_point处理函数非空。
3. 失败即终止：任意一项校验不通过，直接触发panic终止启动，避免异常TA进入运行态带来安全风险。

NS-EL0 用户应用（Android App / HAL 服务）
    ↓ 标准 GlobalPlatform TEEC API
libteec 客户端库
    ↓ ioctl 系统调用
NS-EL1 Linux OP-TEE 字符设备驱动
    ↓ smc #0 触发同步异常
EL3 ATF OPTEED 安全监控器
    ↓ eret 切入安全世界
S-EL1 OP-TEE Fast SMC 入口
    ↓ UUID 哈希表匹配调度
内置 TA 内核态函数执行

TEEC_Context ctx;
TEEC_Session sess;
TEEC_Operation op;
uint32_t origin;

// 1. 初始化上下文，打开/dev/tee设备
TEEC_InitializeContext(NULL, &ctx);
// 2. 打开会话，通过UUID匹配目标TA
TEEC_OpenSession(&ctx, &sess, &pta_rtc_uuid, TEEC_LOGIN_PUBLIC, NULL, NULL, &origin);

// 3. 填充参数，调用具体命令
memset(&op, 0, sizeof(op));
op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_OUTPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
TEEC_InvokeCommand(&sess, PTA_RTC_CMD_GET_TIME, &op, &origin);

1. libteec完成参数格式校验、类型转换，通过ioctl陷入Linux内核，调用OP-TEE字符设备驱动。
2. Linux驱动完成参数合法性校验，大数据场景下分配共享内存并完成映射，按OP-TEE SMC ABI构造参数。
3. 驱动执行smc #0指令，硬件触发同步异常，特权级从NS-EL1上升到EL3。

1. EL3异常向量表根据SMC的OEN（归属实体号），路由到opteed_smc_handler处理函数。
2. 保存非安全世界完整的系统寄存器与通用寄存器上下文，防止被安全世界破坏。
3. 内置TA调用通常走Fast SMC路径（原子短耗时、不可抢占），从全局保存的optee_vector_table中取出fast_smc_entry地址，写入ELR_EL3。
4. 恢复安全世界系统寄存器，执行eret指令，特权级降至S-EL1，PC跳转到OP-TEE的vector_fast_smc_entry。

LOCAL_FUNC vector_fast_smc_entry , : , .identity_map
    readjust_pc          // ASLR地址重定位，修正PC到运行时虚拟地址
    sub	sp, sp, #THREAD_SMC_ARGS_SIZE
    store_xregs sp, THREAD_SMC_ARGS_X0, 0, 7  // x0~x7入栈保存
    mov	x0, sp
    bl	thread_handle_fast_smc     // 进入C语言分发逻辑
    ...

1. thread_handle_fast_smc解析SMC功能号，识别为TA调用请求，提取UUID、命令ID、参数类型与值。
2. 查询全局UUID哈希表，命中对应的内置TA实例。
3. 首次调用时执行TA注册的open_session_entry_point，创建会话上下文。
4. 直接调用invoke_command_entry_point处理函数，执行业务逻辑。

• 全程在当前异常栈执行，不创建新线程、不切换地址空间、屏蔽外部中断，原子执行。
• 运行在S-EL1内核特权级，可直接访问硬件加密引擎、efuse、安全寄存器等所有内核资源。

1. 安全侧收尾：TA函数执行完成，返回TEE_Result状态码，输出参数回填到栈上的SMC参数结构体；回到汇编入口后，将返回值加载到x1~x4寄存器，x0固定为TEESMC_OPTEED_RETURN_CALL_DONE，执行smc #0重新陷入EL3。
2. EL3转发回非安全世界：OPTEED命中返回分支，保存安全世界上下文，恢复非安全世界的寄存器上下文，将返回值写入非安全侧对应寄存器，执行eret回到NS-EL1 Linux驱动。
3. 非安全侧收尾：驱动读取返回状态，若使用了共享内存则完成数据同步与权限校验，最终ioctl返回用户态；libteec解析结果与参数，交付给上层应用。

1. 完全解耦的模块化设计：新增内置TA仅需新建源文件+一行注册宏，无需修改内核核心代码，自动被编译、注册、校验，扩展性与可审计性极强。
2. 统一的分散数组范式：PTA注册、初始化函数、驱动注册全复用同一套分散数组框架，代码极简、逻辑一致，最小化可信计算基（TCB）。
3. 启动期强制安全校验：通过service阶段的合规校验，从机制上保证所有内置TA的UUID唯一、字段合法，从启动源头阻断异常TA。
4. 极致性能与高权限：内置TA运行在内核态，零加载开销、零地址空间切换开销，适合高频基础服务、硬件抽象、根密钥管理等高安全、高性能需求场景。