OP-TEE dispatcher와 BL32 최초 진입

rc를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 optee_context_t / opteed_sp_context를 정리하거나 다음 단계로 진행하는지 확인한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

#endif 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. architecture 또는 build stage 조건을 여닫는다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

#endif /* OPTEE_ALLOW_SMC_LOAD */까지의 동작과 /*******************************************************************************에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'This function is responsible for handling all SMCs in the Trusted OS/App'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'range from the non-secure state as defined in the SMC Calling Convention'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'Document. It is also responsible for communicating with the Secure'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'payload to delegate work and return results back to the non-secure'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'state. Lastly it will also return any information that OPTEE needs to do'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'the work assigned to it.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

opteed_smc_handler(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 609번 줄의 u_register_t x1,는 앞의 static uintptr_t opteed_smc_handler(uint32_t smc_fid, 결과를 받아 다음 u_register_t x2,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 610번 줄의 u_register_t x2,는 앞의 u_register_t x1, 결과를 받아 다음 u_register_t x3,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 611번 줄의 u_register_t x3,는 앞의 u_register_t x2, 결과를 받아 다음 u_register_t x4,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 612번 줄의 u_register_t x4,는 앞의 u_register_t x3, 결과를 받아 다음 void *cookie,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 613번 줄의 void *cookie,는 앞의 u_register_t x4, 결과를 받아 다음 void *handle,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 614번 줄의 void *handle,는 앞의 void *cookie, 결과를 받아 다음 u_register_t flags)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 615번 줄의 u_register_t flags)는 앞의 void *handle, 결과를 받아 다음 {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

바로 위 함수·조건·초기화의 block이 열린다. 이 scope 안에서 만들어지는 지역 객체와 오류 이동 지점을 optee_context_t / opteed_sp_context의 수명에 맞춰 묶어 읽는다.

원본 617번 줄의 cpu_context_t *ns_cpu_context;는 앞의 { 결과를 받아 다음 uint32_t linear_id = plat_my_core_pos();로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

uint32_t linear_id에 plat_my_core_pos()를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

optee_context_t *optee_ctx에 &opteed_sp_context[linear_id]를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

optee_context_t *optee_ctx = &opteed_sp_context[linear_id];까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'Determine which security state this SMC originated from'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

*/까지의 동작과 if (is_caller_non_secure(flags)) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

is_caller_non_secure(flags)를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

#if 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. architecture 또는 build stage 조건을 여닫는다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

opteed_allow_load && smc_fid == NSSMC_OPTEED_CALL_UID를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

원본 주석이 'Provide the UUID of the image loading service.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

SMC_UUID_RET(handle, optee_image_load_uuid)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

smc_fid == NSSMC_OPTEED_CALL_LOAD_IMAGE를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'TODO: Consider wiping the code for SMC loading from'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'memory after it has been invoked similar to what is'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'done under RECLAIM_INIT, but extended to happen'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'later.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

!opteed_allow_load를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

SMC_RET1(handle, -EPERM)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

}까지의 동작과 opteed_allow_load = false;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

opteed_allow_load에 false를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

uint64_t data_size에 dual32to64(x1, x2)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

uint64_t data_pa에 dual32to64(x3, x4)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

!data_size || !data_pa를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'This is invoked when the OP-TEE image didn't'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'load correctly in the kernel but we want to'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block off loading of it later for security'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'reasons.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

SMC_RET1(handle, -EINVAL)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

opteed_handle_smc_load(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 655번 줄의 data_size, data_pa));는 앞의 SMC_RET1(handle, opteed_handle_smc_load( 결과를 받아 다음 }로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

#endif 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. architecture 또는 build stage 조건을 여닫는다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'This is a fresh request from the non-secure client.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'The parameters are in x1 and x2. Figure out which'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'registers need to be preserved, save the non-secure'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'state and send the request to the secure payload.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

assert(handle에 = cm_get_context(NON_SECURE))를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

assert(handle == cm_get_context(NON_SECURE));까지의 동작과 cm_el1_sysregs_context_save(NON_SECURE);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

cm_el1_sysregs_context_save(NON_SECURE)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

cm_el1_sysregs_context_save(NON_SECURE);까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'We are done stashing the non-secure context. Ask the'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'OP-TEE to do the work now. If we are loading vi an SMC,'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'then we also need to init this CPU context if not done'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'already.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

optee_vector_table == NULL를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

SMC_RET1(handle, -EINVAL)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

}까지의 동작과 if (get_optee_pstate(optee_ctx->state) ==에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

get_optee_pstate(optee_ctx->state)를 호출한다. 반환 결과는 현재 줄 또는 다음 OPTEE_PSTATE_UNKNOWN) {에서 검사되는 흐름이다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 679번 줄의 OPTEE_PSTATE_UNKNOWN) {는 앞의 if (get_optee_pstate(optee_ctx->state) == 결과를 받아 다음 opteed_cpu_on_finish_handler(0);로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

opteed_cpu_on_finish_handler(0)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

}까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'Verify if there is a valid context to use, copy the'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'operation type and parameters to the secure context'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'and jump to the fast smc entry point in the secure'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'payload. Entry into S-EL1 will take place upon exit'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'from this function.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

assert(&optee_ctx->cpu_ctx에 = cm_get_context(SECURE))를 = 연산으로 반영해 optee_context_t / opteed_sp_context와 연결된 field를 갱신한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

assert(&optee_ctx->cpu_ctx == cm_get_context(SECURE));까지의 동작과 /* Set appropriate entry for SMC.에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'Set appropriate entry for SMC.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'We expect OPTEE to manage the PSTATE.I and PSTATE.F'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'flags as appropriate.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

GET_SMC_TYPE(smc_fid) == SMC_TYPE_FAST를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

cm_set_elr_el3(SECURE, (uint64_t)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 698번 줄의 &optee_vector_table->fast_smc_entry);는 앞의 cm_set_elr_el3(SECURE, (uint64_t) 결과를 받아 다음 } else {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 699번 줄의 } else {는 앞의 &optee_vector_table->fast_smc_entry); 결과를 받아 다음 cm_set_elr_el3(SECURE, (uint64_t)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

cm_set_elr_el3(SECURE, (uint64_t)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 701번 줄의 &optee_vector_table->yield_smc_entry);는 앞의 cm_set_elr_el3(SECURE, (uint64_t) 결과를 받아 다음 }로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

}까지의 동작과 cm_el1_sysregs_context_restore(SECURE);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

cm_el1_sysregs_context_restore(SECURE)를 호출한다. 반환 결과는 현재 줄 또는 다음 cm_set_next_eret_context(SECURE);에서 검사되는 흐름이다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

cm_set_next_eret_context(SECURE)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

cm_set_next_eret_context(SECURE);까지의 동작과 write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx),에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

get_gpregs_ctx(&optee_ctx->cpu_ctx)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 708번 줄의 CTX_GPREG_X4,는 앞의 write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx), 결과를 받아 다음 read_ctx_reg(get_gpregs_ctx(handle),로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

get_gpregs_ctx(handle)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 710번 줄의 CTX_GPREG_X4));는 앞의 read_ctx_reg(get_gpregs_ctx(handle), 결과를 받아 다음 write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx),로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

get_gpregs_ctx(&optee_ctx->cpu_ctx)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 712번 줄의 CTX_GPREG_X5,는 앞의 write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx), 결과를 받아 다음 read_ctx_reg(get_gpregs_ctx(handle),로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

get_gpregs_ctx(handle)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 714번 줄의 CTX_GPREG_X5));는 앞의 read_ctx_reg(get_gpregs_ctx(handle), 결과를 받아 다음 write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx),로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

get_gpregs_ctx(&optee_ctx->cpu_ctx)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 716번 줄의 CTX_GPREG_X6,는 앞의 write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx), 결과를 받아 다음 read_ctx_reg(get_gpregs_ctx(handle),로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

get_gpregs_ctx(handle)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 718번 줄의 CTX_GPREG_X6));는 앞의 read_ctx_reg(get_gpregs_ctx(handle), 결과를 받아 다음 /* Propagate hypervisor client ID */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 주석이 'Propagate hypervisor client ID'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

get_gpregs_ctx(&optee_ctx->cpu_ctx)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 721번 줄의 CTX_GPREG_X7,는 앞의 write_ctx_reg(get_gpregs_ctx(&optee_ctx->cpu_ctx), 결과를 받아 다음 read_ctx_reg(get_gpregs_ctx(handle),로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

get_gpregs_ctx(handle)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 723번 줄의 CTX_GPREG_X7));는 앞의 read_ctx_reg(get_gpregs_ctx(handle), 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

CTX_GPREG_X7));까지의 동작과 SMC_RET4(&optee_ctx->cpu_ctx, smc_fid, x1, x2, x3);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

SMC_RET4(&optee_ctx->cpu_ctx, smc_fid, x1, x2, x3)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

#include 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. architecture 또는 build stage 조건을 여닫는다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

#include 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. architecture 또는 build stage 조건을 여닫는다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

#include <lib/utils.h>까지의 동작과 #include "opteed_private.h"에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 secure stack/context 상태가 아래 블록의 입력으로 사용되는 경계다.

#include 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. architecture 또는 build stage 조건을 여닫는다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

#include "opteed_private.h"까지의 동작과 /*******************************************************************************에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'Given a OPTEE entrypoint info pointer, entry point PC, register width,'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'cpu id & pointer to a context data structure, this function will'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'initialize OPTEE context and entry point info for OPTEE.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

opteed_init_optee_ep_state(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 23번 줄의 uint32_t rw, uint64_t pc, uint64_t arg0,는 앞의 void opteed_init_optee_ep_state(struct entry_point_info *optee_entry_point, 결과를 받아 다음 uint64_t arg1, uint64_t arg2, uint64_t arg3,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 24번 줄의 uint64_t arg1, uint64_t arg2, uint64_t arg3,는 앞의 uint32_t rw, uint64_t pc, uint64_t arg0, 결과를 받아 다음 optee_context_t *optee_ctx)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 25번 줄의 optee_context_t *optee_ctx)는 앞의 uint64_t arg1, uint64_t arg2, uint64_t arg3, 결과를 받아 다음 {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

바로 위 함수·조건·초기화의 block이 열린다. 이 scope 안에서 만들어지는 지역 객체와 오류 이동 지점을 optee_context_t / opteed_sp_context의 수명에 맞춰 묶어 읽는다.

원본 27번 줄의 uint32_t ep_attr;는 앞의 { 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

uint32_t ep_attr;까지의 동작과 /* Passing a NULL context is a critical programming error */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'Passing a NULL context is a critical programming error'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

assert(optee_ctx)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

assert(optee_entry_point)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

assert(pc)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

assert(pc);까지의 동작과 /* Associate this context with the cpu specified */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'Associate this context with the cpu specified'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

optee_ctx->mpidr에 read_mpidr_el1()를 = 연산으로 반영해 optee_context_t / opteed_sp_context와 연결된 field를 갱신한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

optee_ctx->state에 0를 = 연산으로 반영해 optee_context_t / opteed_sp_context와 연결된 field를 갱신한다. 바로 다음 set_optee_pstate(optee_ctx->state, OPTEE_PSTATE_OFF);가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

set_optee_pstate(optee_ctx->state, OPTEE_PSTATE_OFF)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

set_optee_pstate(optee_ctx->state, OPTEE_PSTATE_OFF);까지의 동작과 cm_set_context(&optee_ctx->cpu_ctx, SECURE);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

cm_set_context(&optee_ctx->cpu_ctx, SECURE)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

cm_set_context(&optee_ctx->cpu_ctx, SECURE);까지의 동작과 /* initialise an entrypoint to set up the CPU context */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'initialise an entrypoint to set up the CPU context'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

ep_attr에 SECURE | EP_ST_ENABLE를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

read_sctlr_el3() & SCTLR_EE_BIT를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

ep_attr에 EP_EE_BIG를 |= 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 바로 다음 SET_PARAM_HEAD(optee_entry_point, PARAM_EP, VERSION_1, ep_attr);가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

SET_PARAM_HEAD(optee_entry_point, PARAM_EP, VERSION_1, ep_attr)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

optee_entry_point->pc에 pc를 = 연산으로 반영해 optee_context_t / opteed_sp_context와 연결된 field를 갱신한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

rw == OPTEE_AARCH64를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

SPSR_64(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 49번 줄의 DISABLE_ALL_EXCEPTIONS);는 앞의 optee_entry_point->spsr = SPSR_64(MODE_EL1, MODE_SP_ELX, 결과를 받아 다음 else로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 50번 줄의 else는 앞의 DISABLE_ALL_EXCEPTIONS); 결과를 받아 다음 optee_entry_point->spsr = SPSR_MODE32(MODE32_svc, SPSR_T_ARM,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

SPSR_MODE32(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

원본 52번 줄의 SPSR_E_LITTLE,는 앞의 optee_entry_point->spsr = SPSR_MODE32(MODE32_svc, SPSR_T_ARM, 결과를 받아 다음 DAIF_FIQ_BIT |로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 53번 줄의 DAIF_FIQ_BIT |는 앞의 SPSR_E_LITTLE, 결과를 받아 다음 DAIF_IRQ_BIT |로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 54번 줄의 DAIF_IRQ_BIT |는 앞의 DAIF_FIQ_BIT | 결과를 받아 다음 DAIF_ABT_BIT);로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

원본 55번 줄의 DAIF_ABT_BIT);는 앞의 DAIF_IRQ_BIT | 결과를 받아 다음 zeromem(&optee_entry_point->args, sizeof(optee_entry_point->args));로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

zeromem(&optee_entry_point->args, sizeof(optee_entry_point->args))를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

optee_entry_point->args.arg0에 arg0를 = 연산으로 반영해 optee_context_t / opteed_sp_context와 연결된 field를 갱신한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

optee_entry_point->args.arg1에 arg1를 = 연산으로 반영해 optee_context_t / opteed_sp_context와 연결된 field를 갱신한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

optee_entry_point->args.arg2에 arg2를 = 연산으로 반영해 optee_context_t / opteed_sp_context와 연결된 field를 갱신한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

optee_entry_point->args.arg3에 arg3를 = 연산으로 반영해 optee_context_t / opteed_sp_context와 연결된 field를 갱신한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

}까지의 동작과 /*******************************************************************************에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'This function takes an OPTEE context pointer and:'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 '1. Applies the S-EL1 system register context from optee_ctx->cpu_ctx.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 '2. Saves the current C runtime state (callee saved registers) on the stack'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'frame and saves a reference to this state.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 '3. Calls el3_exit() so that the EL3 system and general purpose registers'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'from the optee_ctx->cpu_ctx are used to enter the OPTEE image.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

opteed_synchronous_sp_entry 함수 정의가 시작된다. 입력은 optee_context_t *optee_ctx이며, EL3 SPD initialization context에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

바로 위 함수·조건·초기화의 block이 열린다. 이 scope 안에서 만들어지는 지역 객체와 오류 이동 지점을 optee_context_t / opteed_sp_context의 수명에 맞춰 묶어 읽는다.

원본 73번 줄의 uint64_t rc;는 앞의 { 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'BL32 entry, SPSR, pageable/DT arguments와 secure stack이 유효해야 하며 초기 진입이 반환된 뒤에만 OP-TEE service를 runtime에 공개해야 한다' 조건이 유지되는지 확인한다.

uint64_t rc;까지의 동작과 assert(optee_ctx != NULL);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

assert(optee_ctx !에 NULL)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

assert(optee_ctx->c_rt_ctx에 = 0)를 = 연산으로 반영해 optee_context_t / opteed_sp_context와 연결된 field를 갱신한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

assert(optee_ctx->c_rt_ctx == 0);까지의 동작과 /* Apply the Secure EL1 system register context and switch to it */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'Apply the Secure EL1 system register context and switch to it'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

assert(cm_get_context(SECURE)에 = &optee_ctx->cpu_ctx)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

cm_el1_sysregs_context_restore(SECURE)를 호출한다. 반환 결과는 현재 줄 또는 다음 cm_set_next_eret_context(SECURE);에서 검사되는 흐름이다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

cm_set_next_eret_context(SECURE)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 optee_context_t / opteed_sp_context의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SPD service 항목과 대조한다.

cm_set_next_eret_context(SECURE);까지의 동작과 rc = opteed_enter_sp(&optee_ctx->c_rt_ctx);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

rc에 opteed_enter_sp(&optee_ctx->c_rt_ctx)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

#if 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. architecture 또는 build stage 조건을 여닫는다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

optee_ctx->c_rt_ctx에 0를 = 연산으로 반영해 optee_context_t / opteed_sp_context와 연결된 field를 갱신한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

#endif 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. architecture 또는 build stage 조건을 여닫는다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

#endif까지의 동작과 return rc;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

rc를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 optee_context_t / opteed_sp_context를 정리하거나 다음 단계로 진행하는지 확인한다.

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

}까지의 동작과 다음 block 경계에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

이전 block 경계까지의 동작과 /*******************************************************************************에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SPD service 상태가 아래 블록의 입력으로 사용되는 경계다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'This function takes an OPTEE context pointer and:'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 '1. Saves the S-EL1 system register context tp optee_ctx->cpu_ctx.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 '2. Restores the current C runtime state (callee saved registers) from the'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'stack frame using the reference to this state saved in opteed_enter_sp().'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 '3. It does not need to save any general purpose or EL3 system register state'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'as the generic smc entry routine should have saved those.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

opteed_synchronous_sp_exit 함수 정의가 시작된다. 입력은 optee_context_t *optee_ctx, uint64_t ret이며, EL3 SPD initialization context에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

바로 위 함수·조건·초기화의 block이 열린다. 이 scope 안에서 만들어지는 지역 객체와 오류 이동 지점을 optee_context_t / opteed_sp_context의 수명에 맞춰 묶어 읽는다.

assert(optee_ctx !에 NULL)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 OP-TEE init return 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.