OP-TEE dispatcher와 BL32 최초 진입

보조 CPU 시작 때에도 OP-TEE 초기화가 연결됩니다

전통적인 opteed 구성에서는 PSCI CPU 시작 마무리의 svc_on_finish 콜백이 opteed_cpu_on_finish_handler로 연결됩니다. 새 CPU에서 OP-TEE의 cpu_on_entry를 실행해 보안 상태를 준비한 뒤 TF-A로 돌아옵니다. 이후 비보안 Linux의 secondary_entry로 나갑니다. 최초 BL32 초기화와 각 CPU의 이 처리를 구분해야 합니다. FF-A/SPMC 구성은 같은 dispatcher 경로로 단정하지 않습니다.

양쪽 코드를 이어서 읽기

QUESTION

OP-TEE dispatcher와 BL32 최초 진입 단계에서 실제로 바뀌는 상태는 무엇인가?

STRUCTURE

객체와 주소가 놓이는 구조

CALL PATH

실행 흐름

STATE LEDGER

단계별 입력과 출력

호출 순서를 함수 이름으로만 외우지 않고, 각 단계가 무엇을 받아 무엇을 공개하는지 적은 표다. 실제 소스에서 생산 필드가 다르면 표를 고치는 방식으로 사용한다.

분석 범위의 전제와 비교해, 다음 단계의 입력 조건을 처음 어긴 생산 단계부터 조사한다.

VISUAL WALKTHROUGH

주소와 객체의 이동을 그림으로 읽기

아래 그림은 호출 이름보다 주소, 객체 수명과 handoff 경계를 먼저 볼 수 있도록 구성했다. 실제 주소와 크기는 사용 중인 보드의 bdinfo, map과 linker symbol을 대입한다.

UPSTREAM SOURCE

원본 코드

아래 코드는 Trusted Firmware-A LTS 2.14.3의 services/spd/opteed/opteed_main.c에서 126-214줄을 그대로 가져온 것이다. 설명을 위해 실제 코드를 가짜 의사 코드로 바꾸지 않았다.

126
127/*
128 * Registers an interrupt handler for S-EL1 interrupts when generated during
129 * code executing in the non-secure state. Panics if it fails to do so.
130 */
131static void register_opteed_interrupt_handler(void)
132{
133	u_register_t flags;
134	uint64_t rc;
135
136	flags = 0;
137	set_interrupt_rm_flag(flags, NON_SECURE);
138	rc = register_interrupt_type_handler(INTR_TYPE_S_EL1,
139			opteed_sel1_interrupt_handler,
140			flags);
141	if (rc)
142		panic();
143}
144
145/*******************************************************************************
146 * OPTEE Dispatcher setup. The OPTEED finds out the OPTEE entrypoint and type
147 * (aarch32/aarch64) if not already known and initialises the context for entry
148 * into OPTEE for its initialization.
149 ******************************************************************************/
150static int32_t opteed_setup(void)
151{
152#if OPTEE_ALLOW_SMC_LOAD
153	opteed_allow_load = true;
154	INFO("Delaying OP-TEE setup until we receive an SMC call to load it\n");
155	/*
156	 * We must register the interrupt handler now so that the interrupt
157	 * priorities are not changed after starting the linux kernel.
158	 */
159	register_opteed_interrupt_handler();
160	return 0;
161#else
162	entry_point_info_t *optee_ep_info;
163	uint32_t linear_id;
164	uint64_t arg0;
165	uint64_t arg1;
166	uint64_t arg2;
167	uint64_t arg3;
168	struct transfer_list_header __maybe_unused *tl = NULL;
169	struct transfer_list_entry __maybe_unused *te = NULL;
170	void __maybe_unused *dt = NULL;
171
172	linear_id = plat_my_core_pos();
173
174	/*
175	 * Get information about the Secure Payload (BL32) image. Its
176	 * absence is a critical failure.  TODO: Add support to
177	 * conditionally include the SPD service
178	 */
179	optee_ep_info = bl31_plat_get_next_image_ep_info(SECURE);
180	if (!optee_ep_info) {
181		WARN("No OPTEE provided by BL2 boot loader, Booting device"
182			" without OPTEE initialization. SMC`s destined for OPTEE"
183			" will return SMC_UNK\n");
184		return 1;
185	}
186
187	/*
188	 * If there's no valid entry point for SP, we return a non-zero value
189	 * signalling failure initializing the service. We bail out without
190	 * registering any handlers
191	 */
192	if (!optee_ep_info->pc)
193		return 1;
194
195#if TRANSFER_LIST
196	tl = (void *)optee_ep_info->args.arg3;
197
198	if (transfer_list_check_header(tl)) {
199		te = transfer_list_find(tl, TL_TAG_FDT);
200		dt = transfer_list_entry_data(te);
201
202		opteed_rw = GET_RW(optee_ep_info->spsr);
203		if (opteed_rw == OPTEE_AARCH64) {
204			if (optee_ep_info->args.arg1 !=
205			    TRANSFER_LIST_HANDOFF_X1_VALUE(
206				    REGISTER_CONVENTION_VERSION))
207				return 1;
208
209			arg0 = (uint64_t)dt;
210			arg2 = 0;
211		} else {
212			if (optee_ep_info->args.arg1 !=
213			    TRANSFER_LIST_HANDOFF_R1_VALUE(
214				    REGISTER_CONVENTION_VERSION))

READING CONTRACT

발췌 범위와 읽기 기준

원문 126-214줄에는 앞뒤 문맥이 포함됩니다. 기준 구문 static int32_t opteed_setup(void)은 L150에 있습니다. 발췌 첫 줄을 함수 정의의 시작으로 해석하지 않습니다.

OP-TEE는 BL31과 같은 EL에서 실행되지 않는다. EL3 dispatcher가 S-EL1 context를 소유하고 Normal World SMC마다 어느 context를 복원하는지 본다.

RELATED SOURCE

함께 읽어야 하는 원본 코드

첫 코드 조각만으로 동작이 완성되지 않는 경우 호출 매크로, 객체 정의와 실제 실행 목록을 같은 페이지에 묶었다. 각 조각은 같은 기준 commit에서 가져왔다.

596	return rc;
597}
598#endif  /* OPTEE_ALLOW_SMC_LOAD */
599
600/*******************************************************************************
601 * This function is responsible for handling all SMCs in the Trusted OS/App
602 * range from the non-secure state as defined in the SMC Calling Convention
603 * Document. It is also responsible for communicating with the Secure
604 * payload to delegate work and return results back to the non-secure
605 * state. Lastly it will also return any information that OPTEE needs to do
606 * the work assigned to it.
607 ******************************************************************************/
608static uintptr_t opteed_smc_handler(uint32_t smc_fid,
609			 u_register_t x1,
610			 u_register_t x2,
611			 u_register_t x3,
612			 u_register_t x4,
613			 void *cookie,
614			 void *handle,
615			 u_register_t flags)
616{
617	cpu_context_t *ns_cpu_context;
618	uint32_t linear_id = plat_my_core_pos();
619	optee_context_t *optee_ctx = &opteed_sp_context[linear_id];
620
621	/*
622	 * Determine which security state this SMC originated from
623	 */
624
625	if (is_caller_non_secure(flags)) {
626#if OPTEE_ALLOW_SMC_LOAD
627		if (opteed_allow_load && smc_fid == NSSMC_OPTEED_CALL_UID) {
628			/* Provide the UUID of the image loading service. */
629			SMC_UUID_RET(handle, optee_image_load_uuid);
630		}
631		if (smc_fid == NSSMC_OPTEED_CALL_LOAD_IMAGE) {
632			/*
633			 * TODO: Consider wiping the code for SMC loading from
634			 * memory after it has been invoked similar to what is
635			 * done under RECLAIM_INIT, but extended to happen
636			 * later.
637			 */
638			if (!opteed_allow_load) {
639				SMC_RET1(handle, -EPERM);
640			}
641
642			opteed_allow_load = false;
643			uint64_t data_size = dual32to64(x1, x2);
644			uint64_t data_pa = dual32to64(x3, x4);
645			if (!data_size || !data_pa) {
646				/*
647				 * This is invoked when the OP-TEE image didn't
648				 * load correctly in the kernel but we want to
649				 * block off loading of it later for security
650				 * reasons.
651				 */
652				SMC_RET1(handle, -EINVAL);
653			}
654			SMC_RET1(handle, opteed_handle_smc_load(
655					data_size, data_pa));
656		}
657#endif  /* OPTEE_ALLOW_SMC_LOAD */
658		/*
659		 * This is a fresh request from the non-secure client.
660		 * The parameters are in x1 and x2. Figure out which
661		 * registers need to be preserved, save the non-secure
662		 * state and send the request to the secure payload.
663		 */
664		assert(handle == cm_get_context(NON_SECURE));
665
666		cm_el1_sysregs_context_save(NON_SECURE);
667
668		/*
669		 * We are done stashing the non-secure context. Ask the
670		 * OP-TEE to do the work now. If we are loading vi an SMC,
671		 * then we also need to init this CPU context if not done
672		 * already.
673		 */
674		if (optee_vector_table == NULL) {
675			SMC_RET1(handle, -EINVAL);
676		}
677
678		if (get_optee_pstate(optee_ctx->state) ==
679		    OPTEE_PSTATE_UNKNOWN) {
680			opteed_cpu_on_finish_handler(0);
681		}
682
683		/*
684		 * Verify if there is a valid context to use, copy the
685		 * operation type and parameters to the secure context
686		 * and jump to the fast smc entry point in the secure
687		 * payload. Entry into S-EL1 will take place upon exit
688		 * from this function.
689		 */
690		assert(&optee_ctx->cpu_ctx == cm_get_context(SECURE));
691
692		/* Set appropriate entry for SMC.
693		 * We expect OPTEE to manage the PSTATE.I and PSTATE.F
694		 * flags as appropriate.
695		 */
696		if (GET_SMC_TYPE(smc_fid) == SMC_TYPE_FAST) {
697			cm_set_elr_el3(SECURE, (uint64_t)
698					&optee_vector_table->fast_smc_entry);
699		} else {
700			cm_set_elr_el3(SECURE, (uint64_t)
701					&optee_vector_table->yield_smc_entry);
702		}
703
704		cm_el1_sysregs_context_restore(SECURE);
705		cm_set_next_eret_context(SECURE);
706
707		write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx),
708			      CTX_GPREG_X4,
709			      read_ctx_reg(get_gpregs_ctx(handle),
710					   CTX_GPREG_X4));
711		write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx),
712			      CTX_GPREG_X5,
713			      read_ctx_reg(get_gpregs_ctx(handle),
714					   CTX_GPREG_X5));
715		write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx),
716			      CTX_GPREG_X6,
717			      read_ctx_reg(get_gpregs_ctx(handle),
718					   CTX_GPREG_X6));
719		/* Propagate hypervisor client ID */
720		write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx),
721			      CTX_GPREG_X7,
722			      read_ctx_reg(get_gpregs_ctx(handle),
723					   CTX_GPREG_X7));
724
725		SMC_RET4(&optee_ctx->cpu_ctx, smc_fid, x1, x2, x3);
726	}

12#include <lib/el3_runtime/context_mgmt.h>
13#include <lib/utils.h>
14
15#include "opteed_private.h"
16
17/*******************************************************************************
18 * Given a OPTEE entrypoint info pointer, entry point PC, register width,
19 * cpu id & pointer to a context data structure, this function will
20 * initialize OPTEE context and entry point info for OPTEE.
21 ******************************************************************************/
22void opteed_init_optee_ep_state(struct entry_point_info *optee_entry_point,
23				uint32_t rw, uint64_t pc, uint64_t arg0,
24				uint64_t arg1, uint64_t arg2, uint64_t arg3,
25				optee_context_t *optee_ctx)
26{
27	uint32_t ep_attr;
28
29	/* Passing a NULL context is a critical programming error */
30	assert(optee_ctx);
31	assert(optee_entry_point);
32	assert(pc);
33
34	/* Associate this context with the cpu specified */
35	optee_ctx->mpidr = read_mpidr_el1();
36	optee_ctx->state = 0;
37	set_optee_pstate(optee_ctx->state, OPTEE_PSTATE_OFF);
38
39	cm_set_context(&optee_ctx->cpu_ctx, SECURE);
40
41	/* initialise an entrypoint to set up the CPU context */
42	ep_attr = SECURE | EP_ST_ENABLE;
43	if (read_sctlr_el3() & SCTLR_EE_BIT)
44		ep_attr |= EP_EE_BIG;
45	SET_PARAM_HEAD(optee_entry_point, PARAM_EP, VERSION_1, ep_attr);
46	optee_entry_point->pc = pc;
47	if (rw == OPTEE_AARCH64)
48		optee_entry_point->spsr = SPSR_64(MODE_EL1, MODE_SP_ELX,
49						  DISABLE_ALL_EXCEPTIONS);
50	else
51		optee_entry_point->spsr = SPSR_MODE32(MODE32_svc, SPSR_T_ARM,
52						      SPSR_E_LITTLE,
53						      DAIF_FIQ_BIT |
54							DAIF_IRQ_BIT |
55							DAIF_ABT_BIT);
56	zeromem(&optee_entry_point->args, sizeof(optee_entry_point->args));
57	optee_entry_point->args.arg0 = arg0;
58	optee_entry_point->args.arg1 = arg1;
59	optee_entry_point->args.arg2 = arg2;
60	optee_entry_point->args.arg3 = arg3;
61}
62
63/*******************************************************************************
64 * This function takes an OPTEE context pointer and:
65 * 1. Applies the S-EL1 system register context from optee_ctx->cpu_ctx.
66 * 2. Saves the current C runtime state (callee saved registers) on the stack
67 *    frame and saves a reference to this state.
68 * 3. Calls el3_exit() so that the EL3 system and general purpose registers
69 *    from the optee_ctx->cpu_ctx are used to enter the OPTEE image.
70 ******************************************************************************/
71uint64_t opteed_synchronous_sp_entry(optee_context_t *optee_ctx)
72{
73	uint64_t rc;
74
75	assert(optee_ctx != NULL);
76	assert(optee_ctx->c_rt_ctx == 0);
77
78	/* Apply the Secure EL1 system register context and switch to it */
79	assert(cm_get_context(SECURE) == &optee_ctx->cpu_ctx);
80	cm_el1_sysregs_context_restore(SECURE);
81	cm_set_next_eret_context(SECURE);
82
83	rc = opteed_enter_sp(&optee_ctx->c_rt_ctx);
84#if ENABLE_ASSERTIONS
85	optee_ctx->c_rt_ctx = 0;
86#endif
87
88	return rc;
89}
90
91
92/*******************************************************************************
93 * This function takes an OPTEE context pointer and:
94 * 1. Saves the S-EL1 system register context tp optee_ctx->cpu_ctx.
95 * 2. Restores the current C runtime state (callee saved registers) from the
96 *    stack frame using the reference to this state saved in opteed_enter_sp().
97 * 3. It does not need to save any general purpose or EL3 system register state
98 *    as the generic smc entry routine should have saved those.
99 ******************************************************************************/
100void opteed_synchronous_sp_exit(optee_context_t *optee_ctx, uint64_t ret)
101{
102	assert(optee_ctx != NULL);

DETAILS

내부 동작을 더 깊게 읽기

IMPLEMENTATION NOTES

구현을 읽을 때 놓치기 쉬운 부분

OBJECT LIFETIME

객체와 수명

FAILURE PATH

실패 지점과 증상

로그가 끊긴 마지막 함수만 고치지 않는다. 그 함수가 받은 주소, size, flag가 만들어진 앞 단계까지 올라가고, 오류 뒤 등록 객체와 hardware 상태가 남았는지도 확인한다.

EVIDENCE

소스 밖에서 확인할 증거

소스 해석은 실제 빌드 산출물과 target 로그로 닫아야 한다. 아래 명령의 보드 이름과 toolchain prefix는 사용 중인 빌드 환경에 맞게 바꾼다.

LAB

직접 확인할 실험

1. 01
   BL32 entry와 OP-TEE _start 주소 대조

   opteed_setup 진입 전후에 optee_context_t의 주소·크기·반환값과 timestamp를 함께 남긴다.

2. 02
   init return SMC ID 기록

   secure context init 진입 전후에 BL32 entry_point_info의 주소·크기·반환값과 timestamp를 함께 남긴다.

3. 03
   primary/secondary OP-TEE context 주소 비교

   synchronous BL32 entry 진입 전후에 secure stack/context의 주소·크기·반환값과 timestamp를 함께 남긴다.

PRIMARY REFERENCES

원문과 다음 글