TMEM/RMEM/FMEM shared memory 변환 | OP-TEE OS

QUESTION

TMEM/RMEM/FMEM shared memory 변환 단계에서 실제로 바뀌는 상태는 무엇인가?

buffer 시작 주소만 검사해서는 안 된다. offset+size overflow, page list, cache attribute와 registered memory lifetime을 하나의 범위 계약으로 본다.

TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다. 이 문장을 기준으로 코드를 위에서 아래로 읽으면, 함수 이름을 외우는 대신 어느 시점에 어떤 상태를 신뢰할 수 있는지 판단할 수 있다.

STRUCTURE

객체와 주소가 놓이는 구조

그림 1. TMEM/RMEM/FMEM shared memory 변환에서 입력, 내부 상태, 출력의 경계

입력과 전제내부 상태외부로 공개되는 결과

01optee_msg_param

02mobj

03tee_ta_param

04registered SHM

INVARIANT

TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다.

mobj / optee_msg_param / memref를 중심에 놓고 왼쪽의 입력이 어떤 검사를 거쳐 오른쪽 결과로 공개되는지 표시했다. 실제 디버깅에서는 각 블록의 주소와 크기를 로그에 대입한다.

CALL PATH

실행 흐름

그림 2. 정상 경로의 주요 호출과 상태 전달

message parameter

type/attr decode

mobj lookup

offset/size bounds

TA mapping

화살표는 단순 호출 순서만 뜻하지 않는다. 각 단계가 성공을 반환할 때 다음 단계가 읽을 수 있는 상태가 무엇인지 함께 확인한다. 오류 반환이 발생하면 바로 다음 화살표로 진행하지 않고 해당 단계의 정리 경로를 따라간다.

STATE LEDGER

단계별 입력과 출력

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

#	단계	진입 시 신뢰할 상태	성공 뒤 남아야 할 상태	다음 소비자
01	`message parameter`	secure message parameter conversion	optee_msg_param	type/attr decode
02	`type/attr decode`	message parameter 완료 상태	mobj	mobj lookup
03	`mobj lookup`	type/attr decode 완료 상태	tee_ta_param	offset/size bounds
04	`offset/size bounds`	mobj lookup 완료 상태	registered SHM	TA mapping
05	`TA mapping`	offset/size bounds 완료 상태	registered SHM	최종 최종 부트로더 이미지 또는 다음 stage

공통 불변 조건: TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다. 한 단계의 출력이 다음 단계의 입력 조건을 만족하지 않으면 오류가 실제로 드러난 위치보다 앞의 생산 단계부터 조사한다.

VISUAL WALKTHROUGH

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

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

그림 3. TMEM/RMEM/FMEM shared memory 변환의 실행 순서

각 칸은 제어권이 다음 단계로 넘어가기 전에 확정되어야 하는 상태를 나타낸다.

01message parameter

02type/attr decode

03mobj lookup

04offset/size bounds

05TA mapping

그림 4. memref가 TA virtual address가 되는 과정

왼쪽에서 만든 상태를 오른쪽 단계가 처음 사용하는 관계를 표시한다.

01cookie/PAmobj lookupshared object

02offset+sizeoverflow/boundssubrange

03param attrdirection/cachemapping permission

04mobj refTA mapuser memref

UPSTREAM SOURCE

원본 코드

아래 코드는 OP-TEE OS 4.10.0의 core/tee/entry_std.c에서 160-248줄을 그대로 가져온 것이다. 설명을 위해 실제 코드를 가짜 의사 코드로 바꾸지 않았다.

commit753afbbee1682f5d16fd30e87b31058a4fd4f4b8symbolstatic TEE_Result copy_in_params(const struct optee_msg_param *params

160	size_t req_size = 0;
161	uint64_t shm_ref = READ_ONCE(rmem->shm_ref);
162	size_t sz = READ_ONCE(rmem->size);
163
164	mem->mobj = mobj_reg_shm_get_by_cookie(shm_ref);
165	if (!mem->mobj)
166		return TEE_ERROR_BAD_PARAMETERS;
167
168	mem->offs = READ_ONCE(rmem->offs);
169	mem->size = sz;
170
171	/*
172	 * Check that the supplied offset and size is covered by the
173	 * previously verified MOBJ.
174	 */
175	if (ADD_OVERFLOW(mem->offs, mem->size, &req_size) ||
176	    mem->mobj->size < req_size)
177		return TEE_ERROR_SECURITY;
178
179	return TEE_SUCCESS;
180}
181#endif /*CFG_CORE_DYN_SHM*/
182#endif /*!CFG_CORE_FFA*/
183
184static TEE_Result copy_in_params(const struct optee_msg_param *params,
185				 uint32_t num_params,
186				 struct tee_ta_param *ta_param,
187				 uint64_t *saved_attr)
188{
189	TEE_Result res;
190	size_t n;
191	uint8_t pt[TEE_NUM_PARAMS] = { 0 };
192
193	if (num_params > TEE_NUM_PARAMS)
194		return TEE_ERROR_BAD_PARAMETERS;
195
196	memset(ta_param, 0, sizeof(*ta_param));
197
198	for (n = 0; n < num_params; n++) {
199		uint32_t attr;
200
201		saved_attr[n] = READ_ONCE(params[n].attr);
202
203		if (saved_attr[n] & OPTEE_MSG_ATTR_META)
204			return TEE_ERROR_BAD_PARAMETERS;
205
206		attr = saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK;
207		switch (attr) {
208		case OPTEE_MSG_ATTR_TYPE_NONE:
209			pt[n] = TEE_PARAM_TYPE_NONE;
210			break;
211		case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:
212		case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:
213		case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:
214			pt[n] = TEE_PARAM_TYPE_VALUE_INPUT + attr -
215				OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;
216			ta_param->u[n].val.a = READ_ONCE(params[n].u.value.a);
217			ta_param->u[n].val.b = READ_ONCE(params[n].u.value.b);
218			break;
219#ifdef CFG_CORE_FFA
220		case OPTEE_MSG_ATTR_TYPE_FMEM_INPUT:
221		case OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT:
222		case OPTEE_MSG_ATTR_TYPE_FMEM_INOUT:
223			res = set_fmem_param(&params[n].u.fmem,
224					     &ta_param->u[n].mem);
225			if (res)
226				return res;
227			pt[n] = TEE_PARAM_TYPE_MEMREF_INPUT + attr -
228				OPTEE_MSG_ATTR_TYPE_FMEM_INPUT;
229			break;
230#else /*!CFG_CORE_FFA*/
231		case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
232		case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
233		case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
234			res = set_tmem_param(&params[n].u.tmem, saved_attr[n],
235					     &ta_param->u[n].mem);
236			if (res)
237				return res;
238			pt[n] = TEE_PARAM_TYPE_MEMREF_INPUT + attr -
239				OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
240			break;
241#ifdef CFG_CORE_DYN_SHM
242		case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:
243		case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
244		case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
245			res = set_rmem_param(&params[n].u.rmem,
246					     &ta_param->u[n].mem);
247			if (res)
248				return res;

LINE BY LINE

160-248줄 해설

원본에 보이는 모든 줄을 순서대로 설명한다. 빈 줄도 block 경계로 남겨, 코드와 설명의 위치가 어긋나지 않게 했다.

160size_t req_size = 0;

size_t req_size = 0를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 mobj / optee_msg_param / memref를 직접 소유하는지 pointer만 빌리는지, secure message parameter conversion를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

161uint64_t shm_ref = READ_ONCE(rmem->shm_ref);

uint64_t shm_ref에 READ_ONCE(rmem->shm_ref)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 type/attr decode 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

162size_t sz = READ_ONCE(rmem->size);

size_t sz = READ_ONCE(rmem->size)를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 mobj / optee_msg_param / memref를 직접 소유하는지 pointer만 빌리는지, secure message parameter conversion를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

163(빈 줄)

size_t sz = READ_ONCE(rmem->size);까지의 동작과 mem->mobj = mobj_reg_shm_get_by_cookie(shm_ref);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

164mem->mobj = mobj_reg_shm_get_by_cookie(shm_ref);

mem->mobj에 mobj_reg_shm_get_by_cookie(shm_ref)를 = 연산으로 반영해 mobj / optee_msg_param / memref와 연결된 field를 갱신한다. 바로 다음 if (!mem->mobj)가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

165if (!mem->mobj)

!mem->mobj를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

166return TEE_ERROR_BAD_PARAMETERS;

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

167(빈 줄)

return TEE_ERROR_BAD_PARAMETERS;까지의 동작과 mem->offs = READ_ONCE(rmem->offs);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

168mem->offs = READ_ONCE(rmem->offs);

mem->offs에 READ_ONCE(rmem->offs)를 = 연산으로 반영해 mobj / optee_msg_param / memref와 연결된 field를 갱신한다. 이후 TA mapping 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

169mem->size = sz;

mem->size에 sz를 = 연산으로 반영해 mobj / optee_msg_param / memref와 연결된 field를 갱신한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 TA mapping 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

170(빈 줄)

mem->size = sz;까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

171/*

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

172* Check that the supplied offset and size is covered by the

원본 주석이 'Check that the supplied offset and size is covered by the'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

173* previously verified MOBJ.

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

174*/

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

175if (ADD_OVERFLOW(mem->offs, mem->size, &req_size) ||

ADD_OVERFLOW(mem->offs, mem->size, &req_size)를 호출한다. 반환 결과는 현재 줄 또는 다음 mem->mobj->size < req_size)에서 검사되는 흐름이다. pointer 인자는 mobj / optee_msg_param / memref의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 registered SHM 항목과 대조한다.

176mem->mobj->size < req_size)

원본 176번 줄의 mem->mobj->size < req_size)는 앞의 if (ADD_OVERFLOW(mem->offs, mem->size, &req_size) || 결과를 받아 다음 return TEE_ERROR_SECURITY;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

177return TEE_ERROR_SECURITY;

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

178(빈 줄)

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

179return TEE_SUCCESS;

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

180}

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

181#endif /*CFG_CORE_DYN_SHM*/

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

182#endif /*!CFG_CORE_FFA*/

183(빈 줄)

#endif /*!CFG_CORE_FFA*/까지의 동작과 static TEE_Result copy_in_params(const struct optee_msg_param *params,에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

184static TEE_Result copy_in_params(const struct optee_msg_param *params,

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

185uint32_t num_params,

원본 185번 줄의 uint32_t num_params,는 앞의 static TEE_Result copy_in_params(const struct optee_msg_param *params, 결과를 받아 다음 struct tee_ta_param *ta_param,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

186struct tee_ta_param *ta_param,

struct tee_ta_param *ta_param,를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 mobj / optee_msg_param / memref를 직접 소유하는지 pointer만 빌리는지, secure message parameter conversion를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

187uint64_t *saved_attr)

원본 187번 줄의 uint64_t *saved_attr)는 앞의 struct tee_ta_param *ta_param, 결과를 받아 다음 {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

188{

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

189TEE_Result res;

원본 189번 줄의 TEE_Result res;는 앞의 { 결과를 받아 다음 size_t n;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

190size_t n;

size_t n를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 mobj / optee_msg_param / memref를 직접 소유하는지 pointer만 빌리는지, secure message parameter conversion를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

191uint8_t pt[TEE_NUM_PARAMS] = { 0 };

uint8_t pt[TEE_NUM_PARAMS]에 { 0 }를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 TA mapping 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

192(빈 줄)

uint8_t pt[TEE_NUM_PARAMS] = { 0 };까지의 동작과 if (num_params > TEE_NUM_PARAMS)에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

193if (num_params > TEE_NUM_PARAMS)

num_params > TEE_NUM_PARAMS를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

194return TEE_ERROR_BAD_PARAMETERS;

195(빈 줄)

return TEE_ERROR_BAD_PARAMETERS;까지의 동작과 memset(ta_param, 0, sizeof(*ta_param));에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

196memset(ta_param, 0, sizeof(*ta_param));

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

197(빈 줄)

memset(ta_param, 0, sizeof(*ta_param));까지의 동작과 for (n = 0; n < num_params; n++) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

198for (n = 0; n < num_params; n++) {

'for (n = 0; n < num_params; n++) {'가 목록이나 후보를 순회한다. 반복 중 mobj / optee_msg_param / memref를 제거·추가하는 호출이 있는지와 loop 종료 뒤 iterator가 유효한지 확인한다.

199uint32_t attr;

원본 199번 줄의 uint32_t attr;는 앞의 for (n = 0; n < num_params; n++) { 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

200(빈 줄)

uint32_t attr;까지의 동작과 saved_attr[n] = READ_ONCE(params[n].attr);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

201saved_attr[n] = READ_ONCE(params[n].attr);

saved_attr[n]에 READ_ONCE(params[n].attr)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 TA mapping 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

202(빈 줄)

saved_attr[n] = READ_ONCE(params[n].attr);까지의 동작과 if (saved_attr[n] & OPTEE_MSG_ATTR_META)에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

203if (saved_attr[n] & OPTEE_MSG_ATTR_META)

saved_attr[n] & OPTEE_MSG_ATTR_META를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

204return TEE_ERROR_BAD_PARAMETERS;

205(빈 줄)

return TEE_ERROR_BAD_PARAMETERS;까지의 동작과 attr = saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

206attr = saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK;

attr에 saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 바로 다음 switch (attr) {가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

207switch (attr) {

원본 207번 줄의 switch (attr) {는 앞의 attr = saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK; 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_NONE:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

208case OPTEE_MSG_ATTR_TYPE_NONE:

원본 208번 줄의 case OPTEE_MSG_ATTR_TYPE_NONE:는 앞의 switch (attr) { 결과를 받아 다음 pt[n] = TEE_PARAM_TYPE_NONE;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

209pt[n] = TEE_PARAM_TYPE_NONE;

pt[n]에 TEE_PARAM_TYPE_NONE를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 TA mapping 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

210break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

211case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:

원본 211번 줄의 case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:는 앞의 break; 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

212case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:

원본 212번 줄의 case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT: 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

213case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:

원본 213번 줄의 case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT: 결과를 받아 다음 pt[n] = TEE_PARAM_TYPE_VALUE_INPUT + attr -로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

214pt[n] = TEE_PARAM_TYPE_VALUE_INPUT + attr -

원본 214번 줄의 pt[n] = TEE_PARAM_TYPE_VALUE_INPUT + attr -는 앞의 case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT: 결과를 받아 다음 OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

215OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;

원본 215번 줄의 OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;는 앞의 pt[n] = TEE_PARAM_TYPE_VALUE_INPUT + attr - 결과를 받아 다음 ta_param->u[n].val.a = READ_ONCE(params[n].u.value.a);로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

216ta_param->u[n].val.a = READ_ONCE(params[n].u.value.a);

ta_param->u[n].val.a에 READ_ONCE(params[n].u.value.a)를 = 연산으로 반영해 mobj / optee_msg_param / memref와 연결된 field를 갱신한다. 바로 다음 ta_param->u[n].val.b = READ_ONCE(params[n].u.value.b);가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

217ta_param->u[n].val.b = READ_ONCE(params[n].u.value.b);

ta_param->u[n].val.b에 READ_ONCE(params[n].u.value.b)를 = 연산으로 반영해 mobj / optee_msg_param / memref와 연결된 field를 갱신한다. 바로 다음 break;가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

218break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

219#ifdef CFG_CORE_FFA

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

220case OPTEE_MSG_ATTR_TYPE_FMEM_INPUT:

원본 220번 줄의 case OPTEE_MSG_ATTR_TYPE_FMEM_INPUT:는 앞의 #ifdef CFG_CORE_FFA 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

221case OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT:

원본 221번 줄의 case OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_FMEM_INPUT: 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_FMEM_INOUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

222case OPTEE_MSG_ATTR_TYPE_FMEM_INOUT:

원본 222번 줄의 case OPTEE_MSG_ATTR_TYPE_FMEM_INOUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT: 결과를 받아 다음 res = set_fmem_param(&params[n].u.fmem,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

223res = set_fmem_param(&params[n].u.fmem,

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

224&ta_param->u[n].mem);

원본 224번 줄의 &ta_param->u[n].mem);는 앞의 res = set_fmem_param(&params[n].u.fmem, 결과를 받아 다음 if (res)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

225if (res)

res를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

226return res;

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

227pt[n] = TEE_PARAM_TYPE_MEMREF_INPUT + attr -

원본 227번 줄의 pt[n] = TEE_PARAM_TYPE_MEMREF_INPUT + attr -는 앞의 return res; 결과를 받아 다음 OPTEE_MSG_ATTR_TYPE_FMEM_INPUT;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

228OPTEE_MSG_ATTR_TYPE_FMEM_INPUT;

원본 228번 줄의 OPTEE_MSG_ATTR_TYPE_FMEM_INPUT;는 앞의 pt[n] = TEE_PARAM_TYPE_MEMREF_INPUT + attr - 결과를 받아 다음 break;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

229break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

230#else /*!CFG_CORE_FFA*/

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

231case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:

원본 231번 줄의 case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:는 앞의 #else /*!CFG_CORE_FFA*/ 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

232case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:

원본 232번 줄의 case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT: 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

233case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:

원본 233번 줄의 case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT: 결과를 받아 다음 res = set_tmem_param(&params[n].u.tmem, saved_attr[n],로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

234res = set_tmem_param(&params[n].u.tmem, saved_attr[n],

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

235&ta_param->u[n].mem);

원본 235번 줄의 &ta_param->u[n].mem);는 앞의 res = set_tmem_param(&params[n].u.tmem, saved_attr[n], 결과를 받아 다음 if (res)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

236if (res)

237return res;

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

238pt[n] = TEE_PARAM_TYPE_MEMREF_INPUT + attr -

원본 238번 줄의 pt[n] = TEE_PARAM_TYPE_MEMREF_INPUT + attr -는 앞의 return res; 결과를 받아 다음 OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

239OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;

원본 239번 줄의 OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;는 앞의 pt[n] = TEE_PARAM_TYPE_MEMREF_INPUT + attr - 결과를 받아 다음 break;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

240break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

241#ifdef CFG_CORE_DYN_SHM

242case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:

원본 242번 줄의 case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:는 앞의 #ifdef CFG_CORE_DYN_SHM 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

243case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:

원본 243번 줄의 case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT: 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

244case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:

원본 244번 줄의 case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT: 결과를 받아 다음 res = set_rmem_param(&params[n].u.rmem,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

245res = set_rmem_param(&params[n].u.rmem,

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

246&ta_param->u[n].mem);

원본 246번 줄의 &ta_param->u[n].mem);는 앞의 res = set_rmem_param(&params[n].u.rmem, 결과를 받아 다음 if (res)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

247if (res)

248return res;

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

RELATED SOURCE

함께 읽어야 하는 원본 코드

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

01. 실패와 반환 경로에서 shared-memory reference 정리

core/tee/entry_std.c 254-330줄이다.

filecore/tee/entry_std.canchorstatic void cleanup_shm_refs

254		default:
255			return TEE_ERROR_BAD_PARAMETERS;
256		}
257	}
258
259	ta_param->types = TEE_PARAM_TYPES(pt[0], pt[1], pt[2], pt[3]);
260
261	return TEE_SUCCESS;
262}
263
264static void cleanup_shm_refs(const uint64_t *saved_attr,
265			     struct tee_ta_param *param, uint32_t num_params)
266{
267	size_t n;
268
269	for (n = 0; n < MIN((unsigned int)TEE_NUM_PARAMS, num_params); n++) {
270		switch (saved_attr[n]) {
271		case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
272		case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
273		case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
274#ifdef CFG_CORE_DYN_SHM
275		case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:
276		case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
277		case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
278#endif
279			mobj_put(param->u[n].mem.mobj);
280			break;
281		default:
282			break;
283		}
284	}
285}
286
287static void copy_out_param(struct tee_ta_param *ta_param, uint32_t num_params,
288			   struct optee_msg_param *params, uint64_t *saved_attr)
289{
290	size_t n;
291
292	for (n = 0; n < num_params; n++) {
293		switch (TEE_PARAM_TYPE_GET(ta_param->types, n)) {
294		case TEE_PARAM_TYPE_MEMREF_OUTPUT:
295		case TEE_PARAM_TYPE_MEMREF_INOUT:
296			switch (saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK) {
297			case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
298			case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
299				params[n].u.tmem.size = ta_param->u[n].mem.size;
300				break;
301			case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
302			case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
303				params[n].u.rmem.size = ta_param->u[n].mem.size;
304				break;
305			default:
306				break;
307			}
308			break;
309		case TEE_PARAM_TYPE_VALUE_OUTPUT:
310		case TEE_PARAM_TYPE_VALUE_INOUT:
311			params[n].u.value.a = ta_param->u[n].val.a;
312			params[n].u.value.b = ta_param->u[n].val.b;
313			break;
314		default:
315			break;
316		}
317	}
318}
319
320/*
321 * Extracts mandatory parameter for open session.
322 *
323 * Returns
324 * false : mandatory parameter wasn't found or malformatted
325 * true  : paramater found and OK
326 */
327static TEE_Result get_open_session_meta(size_t num_params,
328					struct optee_msg_param *params,
329					size_t *num_meta, TEE_UUID *uuid,
330					TEE_Identity *clnt_id)

254-330줄 해설

254default:

'default' label이다. 이곳을 참조하는 branch를 역검색하고 각 진입 경로의 register, stack, lock 조건이 같은지 확인한다.

255return TEE_ERROR_BAD_PARAMETERS;

256}

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

257}

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

258(빈 줄)

}까지의 동작과 ta_param->types = TEE_PARAM_TYPES(pt[0], pt[1], pt[2], pt[3]);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

259ta_param->types = TEE_PARAM_TYPES(pt[0], pt[1], pt[2], pt[3]);

ta_param->types에 TEE_PARAM_TYPES(pt[0], pt[1], pt[2], pt[3])를 = 연산으로 반영해 mobj / optee_msg_param / memref와 연결된 field를 갱신한다. 이후 TA mapping 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

260(빈 줄)

ta_param->types = TEE_PARAM_TYPES(pt[0], pt[1], pt[2], pt[3]);까지의 동작과 return TEE_SUCCESS;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

261return TEE_SUCCESS;

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

262}

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

263(빈 줄)

}까지의 동작과 static void cleanup_shm_refs(const uint64_t *saved_attr,에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

264static void cleanup_shm_refs(const uint64_t *saved_attr,

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

265struct tee_ta_param *param, uint32_t num_params)

struct tee_ta_param *param, uint32_t num_params)를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 mobj / optee_msg_param / memref를 직접 소유하는지 pointer만 빌리는지, secure message parameter conversion를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

266{

267size_t n;

268(빈 줄)

size_t n;까지의 동작과 for (n = 0; n < MIN((unsigned int)TEE_NUM_PARAMS, num_params); n++) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

269for (n = 0; n < MIN((unsigned int)TEE_NUM_PARAMS, num_params); n++) {

'for (n = 0; n < MIN((unsigned int)TEE_NUM_PARAMS, num_params); n++) {'가 목록이나 후보를 순회한다. 반복 중 mobj / optee_msg_param / memref를 제거·추가하는 호출이 있는지와 loop 종료 뒤 iterator가 유효한지 확인한다.

270switch (saved_attr[n]) {

원본 270번 줄의 switch (saved_attr[n]) {는 앞의 for (n = 0; n < MIN((unsigned int)TEE_NUM_PARAMS, num_params); n++) { 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

271case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:

원본 271번 줄의 case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:는 앞의 switch (saved_attr[n]) { 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

272case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:

원본 272번 줄의 case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT: 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

273case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:

원본 273번 줄의 case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT: 결과를 받아 다음 #ifdef CFG_CORE_DYN_SHM로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

274#ifdef CFG_CORE_DYN_SHM

275case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:

원본 275번 줄의 case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:는 앞의 #ifdef CFG_CORE_DYN_SHM 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

276case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:

원본 276번 줄의 case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT: 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

277case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:

원본 277번 줄의 case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT: 결과를 받아 다음 #endif로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

278#endif

279mobj_put(param->u[n].mem.mobj);

mobj_put(param->u[n].mem.mobj)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 mobj / optee_msg_param / memref의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 registered SHM 항목과 대조한다.

280break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

281default:

'default' label이다. 이곳을 참조하는 branch를 역검색하고 각 진입 경로의 register, stack, lock 조건이 같은지 확인한다.

282break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

283}

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

284}

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

285}

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

286(빈 줄)

}까지의 동작과 static void copy_out_param(struct tee_ta_param *ta_param, uint32_t num_params,에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

287static void copy_out_param(struct tee_ta_param *ta_param, uint32_t num_params,

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

288struct optee_msg_param *params, uint64_t *saved_attr)

struct optee_msg_param *params, uint64_t *saved_attr)를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 mobj / optee_msg_param / memref를 직접 소유하는지 pointer만 빌리는지, secure message parameter conversion를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

289{

290size_t n;

291(빈 줄)

size_t n;까지의 동작과 for (n = 0; n < num_params; n++) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

292for (n = 0; n < num_params; n++) {

293switch (TEE_PARAM_TYPE_GET(ta_param->types, n)) {

TEE_PARAM_TYPE_GET(ta_param->types, n))를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 mobj / optee_msg_param / memref의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 registered SHM 항목과 대조한다.

294case TEE_PARAM_TYPE_MEMREF_OUTPUT:

원본 294번 줄의 case TEE_PARAM_TYPE_MEMREF_OUTPUT:는 앞의 switch (TEE_PARAM_TYPE_GET(ta_param->types, n)) { 결과를 받아 다음 case TEE_PARAM_TYPE_MEMREF_INOUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

295case TEE_PARAM_TYPE_MEMREF_INOUT:

원본 295번 줄의 case TEE_PARAM_TYPE_MEMREF_INOUT:는 앞의 case TEE_PARAM_TYPE_MEMREF_OUTPUT: 결과를 받아 다음 switch (saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK) {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

296switch (saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK) {

원본 296번 줄의 switch (saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK) {는 앞의 case TEE_PARAM_TYPE_MEMREF_INOUT: 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

297case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:

원본 297번 줄의 case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:는 앞의 switch (saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK) { 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

298case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:

원본 298번 줄의 case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT: 결과를 받아 다음 params[n].u.tmem.size = ta_param->u[n].mem.size;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

299params[n].u.tmem.size = ta_param->u[n].mem.size;

params[n].u.tmem.size에 ta_param->u[n].mem.size를 = 연산으로 반영해 mobj / optee_msg_param / memref와 연결된 field를 갱신한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 TA mapping 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

300break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

301case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:

원본 301번 줄의 case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:는 앞의 break; 결과를 받아 다음 case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

302case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:

원본 302번 줄의 case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT: 결과를 받아 다음 params[n].u.rmem.size = ta_param->u[n].mem.size;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

303params[n].u.rmem.size = ta_param->u[n].mem.size;

params[n].u.rmem.size에 ta_param->u[n].mem.size를 = 연산으로 반영해 mobj / optee_msg_param / memref와 연결된 field를 갱신한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 TA mapping 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

304break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

305default:

'default' label이다. 이곳을 참조하는 branch를 역검색하고 각 진입 경로의 register, stack, lock 조건이 같은지 확인한다.

306break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

307}

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

308break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

309case TEE_PARAM_TYPE_VALUE_OUTPUT:

원본 309번 줄의 case TEE_PARAM_TYPE_VALUE_OUTPUT:는 앞의 break; 결과를 받아 다음 case TEE_PARAM_TYPE_VALUE_INOUT:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

310case TEE_PARAM_TYPE_VALUE_INOUT:

원본 310번 줄의 case TEE_PARAM_TYPE_VALUE_INOUT:는 앞의 case TEE_PARAM_TYPE_VALUE_OUTPUT: 결과를 받아 다음 params[n].u.value.a = ta_param->u[n].val.a;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

311params[n].u.value.a = ta_param->u[n].val.a;

params[n].u.value.a에 ta_param->u[n].val.a를 = 연산으로 반영해 mobj / optee_msg_param / memref와 연결된 field를 갱신한다. 바로 다음 params[n].u.value.b = ta_param->u[n].val.b;가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

312params[n].u.value.b = ta_param->u[n].val.b;

params[n].u.value.b에 ta_param->u[n].val.b를 = 연산으로 반영해 mobj / optee_msg_param / memref와 연결된 field를 갱신한다. 바로 다음 break;가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

313break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

314default:

'default' label이다. 이곳을 참조하는 branch를 역검색하고 각 진입 경로의 register, stack, lock 조건이 같은지 확인한다.

315break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

316}

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

317}

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

318}

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

319(빈 줄)

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

320/*

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

321* Extracts mandatory parameter for open session.

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

322*

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

323* Returns

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

324* false : mandatory parameter wasn't found or malformatted

원본 주석이 'false : mandatory parameter wasn't found or malformatted'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

325* true : paramater found and OK

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

326*/

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

327static TEE_Result get_open_session_meta(size_t num_params,

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

328struct optee_msg_param *params,

struct optee_msg_param *params,를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 mobj / optee_msg_param / memref를 직접 소유하는지 pointer만 빌리는지, secure message parameter conversion를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

329size_t *num_meta, TEE_UUID *uuid,

원본 329번 줄의 size_t *num_meta, TEE_UUID *uuid,는 앞의 struct optee_msg_param *params, 결과를 받아 다음 TEE_Identity *clnt_id)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

330TEE_Identity *clnt_id)

원본 330번 줄의 TEE_Identity *clnt_id)는 앞의 size_t *num_meta, TEE_UUID *uuid, 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

02. registered-memory cookie와 offset을 mobj로 변환

core/tee/entry_std.c 147-221줄이다.

filecore/tee/entry_std.canchorstatic TEE_Result set_rmem_param

147
148		mobj_put(rmobj);
149		if (rc)
150			return TEE_SUCCESS;
151	}
152
153	return TEE_ERROR_BAD_PARAMETERS;
154}
155
156#ifdef CFG_CORE_DYN_SHM
157static TEE_Result set_rmem_param(const struct optee_msg_param_rmem *rmem,
158				 struct param_mem *mem)
159{
160	size_t req_size = 0;
161	uint64_t shm_ref = READ_ONCE(rmem->shm_ref);
162	size_t sz = READ_ONCE(rmem->size);
163
164	mem->mobj = mobj_reg_shm_get_by_cookie(shm_ref);
165	if (!mem->mobj)
166		return TEE_ERROR_BAD_PARAMETERS;
167
168	mem->offs = READ_ONCE(rmem->offs);
169	mem->size = sz;
170
171	/*
172	 * Check that the supplied offset and size is covered by the
173	 * previously verified MOBJ.
174	 */
175	if (ADD_OVERFLOW(mem->offs, mem->size, &req_size) ||
176	    mem->mobj->size < req_size)
177		return TEE_ERROR_SECURITY;
178
179	return TEE_SUCCESS;
180}
181#endif /*CFG_CORE_DYN_SHM*/
182#endif /*!CFG_CORE_FFA*/
183
184static TEE_Result copy_in_params(const struct optee_msg_param *params,
185				 uint32_t num_params,
186				 struct tee_ta_param *ta_param,
187				 uint64_t *saved_attr)
188{
189	TEE_Result res;
190	size_t n;
191	uint8_t pt[TEE_NUM_PARAMS] = { 0 };
192
193	if (num_params > TEE_NUM_PARAMS)
194		return TEE_ERROR_BAD_PARAMETERS;
195
196	memset(ta_param, 0, sizeof(*ta_param));
197
198	for (n = 0; n < num_params; n++) {
199		uint32_t attr;
200
201		saved_attr[n] = READ_ONCE(params[n].attr);
202
203		if (saved_attr[n] & OPTEE_MSG_ATTR_META)
204			return TEE_ERROR_BAD_PARAMETERS;
205
206		attr = saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK;
207		switch (attr) {
208		case OPTEE_MSG_ATTR_TYPE_NONE:
209			pt[n] = TEE_PARAM_TYPE_NONE;
210			break;
211		case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:
212		case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:
213		case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:
214			pt[n] = TEE_PARAM_TYPE_VALUE_INPUT + attr -
215				OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;
216			ta_param->u[n].val.a = READ_ONCE(params[n].u.value.a);
217			ta_param->u[n].val.b = READ_ONCE(params[n].u.value.b);
218			break;
219#ifdef CFG_CORE_FFA
220		case OPTEE_MSG_ATTR_TYPE_FMEM_INPUT:
221		case OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT:

147-221줄 해설

147(빈 줄)

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

148mobj_put(rmobj);

mobj_put(rmobj)를 호출한다. 반환 결과는 현재 줄 또는 다음 if (rc)에서 검사되는 흐름이다. pointer 인자는 mobj / optee_msg_param / memref의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 mobj 항목과 대조한다.

149if (rc)

rc를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

150return TEE_SUCCESS;

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

151}

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

152(빈 줄)

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

153return TEE_ERROR_BAD_PARAMETERS;

154}

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

155(빈 줄)

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

156#ifdef CFG_CORE_DYN_SHM

157static TEE_Result set_rmem_param(const struct optee_msg_param_rmem *rmem,

158struct param_mem *mem)

struct param_mem *mem)를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 mobj / optee_msg_param / memref를 직접 소유하는지 pointer만 빌리는지, secure message parameter conversion를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

159{

160size_t req_size = 0;

161uint64_t shm_ref = READ_ONCE(rmem->shm_ref);

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

162size_t sz = READ_ONCE(rmem->size);

163(빈 줄)

164mem->mobj = mobj_reg_shm_get_by_cookie(shm_ref);

165if (!mem->mobj)

166return TEE_ERROR_BAD_PARAMETERS;

167(빈 줄)

168mem->offs = READ_ONCE(rmem->offs);

169mem->size = sz;

170(빈 줄)

mem->size = sz;까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 registered SHM 상태가 아래 블록의 입력으로 사용되는 경계다.

171/*

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

172* Check that the supplied offset and size is covered by the

원본 주석이 'Check that the supplied offset and size is covered by the'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

173* previously verified MOBJ.

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

174*/

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

175if (ADD_OVERFLOW(mem->offs, mem->size, &req_size) ||

176mem->mobj->size < req_size)

177return TEE_ERROR_SECURITY;

178(빈 줄)

179return TEE_SUCCESS;

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

180}

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

181#endif /*CFG_CORE_DYN_SHM*/

182#endif /*!CFG_CORE_FFA*/

183(빈 줄)

184static TEE_Result copy_in_params(const struct optee_msg_param *params,

185uint32_t num_params,

186struct tee_ta_param *ta_param,

187uint64_t *saved_attr)

188{

189TEE_Result res;

190size_t n;

191uint8_t pt[TEE_NUM_PARAMS] = { 0 };

192(빈 줄)

193if (num_params > TEE_NUM_PARAMS)

194return TEE_ERROR_BAD_PARAMETERS;

195(빈 줄)

196memset(ta_param, 0, sizeof(*ta_param));

197(빈 줄)

198for (n = 0; n < num_params; n++) {

199uint32_t attr;

200(빈 줄)

201saved_attr[n] = READ_ONCE(params[n].attr);

202(빈 줄)

203if (saved_attr[n] & OPTEE_MSG_ATTR_META)

204return TEE_ERROR_BAD_PARAMETERS;

205(빈 줄)

206attr = saved_attr[n] & OPTEE_MSG_ATTR_TYPE_MASK;

207switch (attr) {

208case OPTEE_MSG_ATTR_TYPE_NONE:

209pt[n] = TEE_PARAM_TYPE_NONE;

210break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

211case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:

212case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:

213case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:

214pt[n] = TEE_PARAM_TYPE_VALUE_INPUT + attr -

215OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;

216ta_param->u[n].val.a = READ_ONCE(params[n].u.value.a);

217ta_param->u[n].val.b = READ_ONCE(params[n].u.value.b);

218break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 mobj / optee_msg_param / memref에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

219#ifdef CFG_CORE_FFA

220case OPTEE_MSG_ATTR_TYPE_FMEM_INPUT:

221case OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT:

원본 221번 줄의 case OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT:는 앞의 case OPTEE_MSG_ATTR_TYPE_FMEM_INPUT: 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다' 조건이 유지되는지 확인한다.

DETAILS

내부 동작을 더 깊게 읽기

진입 조건을 먼저 고정한다

message parameter에서 들어온 실행은 secure message parameter conversion에 놓여 있다. 이때 interrupt, MMU/cache, stack, heap 중 무엇이 이미 준비되었는지 소스의 호출자까지 올라가 확인한다. 같은 함수라도 SPL, relocation 전후, app thread처럼 호출 문맥이 달라지면 허용되는 API와 지연 시간이 달라진다.

buffer 시작 주소만 검사해서는 안 된다. offset+size overflow, page list, cache attribute와 registered memory lifetime을 하나의 범위 계약으로 본다.

중심 객체의 생성과 공개를 나눈다

이 글의 중심 객체는 mobj / optee_msg_param / memref다. 메모리를 확보한 시점, 필드를 채운 시점, 전역 list나 다른 subsystem에 공개한 시점을 구분한다. 공개 뒤 오류가 발생한다면 목록에서 제거하고 child, buffer, reference를 역순으로 정리하는지 확인한다.

빌드 산출물 관점에서는 최종 부트로더 이미지 안에 해당 symbol과 section이 실제로 포함되었는지도 map과 objdump로 검증한다.

주소, 크기와 정렬을 계산한다

부트 코드의 오류는 논리보다 주소 계산에서 먼저 드러나는 경우가 많다. source range, destination range, header가 말하는 payload size, block 또는 page 단위를 표로 적고 각 구간의 끝 주소를 직접 계산한다. 끝 주소는 start + size - 1인지 exclusive end인지 API 계약을 확인한다.

TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다.

성공 flag와 실제 완료 시점을 맞춘다

type/attr decode → mobj lookup → offset/size bounds 구간에서는 부분 초기화 상태가 생길 수 있다. flag, list insertion, callback 등록, storage write 완료 중 무엇이 성공의 기준인지 찾는다. hardware write나 DMA가 포함되면 함수 반환과 장치 완료가 같은 시점인지도 확인한다.

다른 CPU, interrupt handler, USB completion 또는 shell command가 상태를 관찰할 수 있다면 memory ordering과 lock 범위도 함께 읽는다.

마지막 handoff의 계약을 적는다

정상 경로는 TA mapping에서 끝난다. 이 단계가 함수 반환인지, scheduler 전환인지, 다른 image로의 비복귀 분기인지 구분한다. 비복귀 handoff라면 cache clean/invalidate, interrupt disable, 장치 quiesce, argument register와 FDT 또는 image address가 최종 점검 항목이다.

반환하는 경로라면 caller가 오류와 부분 성공을 구분하고 다음 후보 또는 복구 경로를 선택하는지 확인한다.

IMPLEMENTATION NOTES

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

message parameter에서 TA mapping까지 제어권이 이동하는 조건

Normal World parameter의 physical range와 shared memory cookie를 mobj와 offset으로 바꾸고 TA가 볼 virtual mapping을 만드는 경로를 읽습니다. 이 경로는 함수 호출 목록만 외워서는 연결되지 않는다. message parameter → type/attr decode → mobj lookup → offset/size bounds → TA mapping 순서에서 각 단계가 읽는 입력, 새로 확정하는 상태, 다음 단계에 넘기는 값을 구분해야 한다. 특히 secure message parameter conversion에서는 이전 단계가 남긴 register와 memory attribute가 C 코드의 전제 조건이 된다.

buffer 시작 주소만 검사해서는 안 된다. offset+size overflow, page list, cache attribute와 registered memory lifetime을 하나의 범위 계약으로 본다. 따라서 첫 지점에서 mobj / optee_msg_param / memref의 주소와 owner를 기록하고, 마지막 지점에서 같은 값이 그대로 유지되는지 아니면 새 객체로 교체되는지를 확인한다. 중간 함수가 성공을 반환해도 TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다.

optee_msg_param와 registered SHM의 생성 시점과 수명

이 글에서 함께 나타나는 객체는 optee_msg_param, mobj, tee_ta_param, registered SHM이다. 이름이 비슷해도 저장 위치와 수명은 다르다. build-time descriptor인지, boot 단계의 임시 객체인지, world switch 뒤에도 남는 runtime 객체인지 나눠야 pointer를 따라가다 다른 단계의 구조체를 같은 것으로 오해하지 않는다.

mobj / optee_msg_param / memref을 기준으로 allocation 또는 정적 배치 위치, list/table에 공개되는 시점, 참조가 끊기는 시점을 적는다. 그 다음 source와 destination 범위, per-CPU 여부, secure/non-secure 접근 권한을 map과 runtime log로 대조한다. 이 절차를 거치면 단순한 호출 순서가 아니라 실제 소유권 이동이 보인다.

성공 로그만으로 놓치기 쉬운 실패 경계

대표적인 실패 조건은 offset+size wrap: bounds 우회; stale cookie: freed SHM 참조; cache attr 불일치: world 간 데이터 불일치이다. 이 문제들은 대개 fault가 발생한 함수보다 앞에서 만들어진 잘못된 주소, size, security state 또는 refcount 때문에 생긴다. 마지막 출력만 보지 말고 각 경계 직전의 상태를 한 줄씩 남겨 최초 불일치 지점을 찾는다.

재현에는 경계에 걸친 memref 시험; unregister와 invoke 경쟁 재현; TMEM과 RMEM의 refcount 변화를 비교를 사용한다. 정상 경로와 실패 경로에서 같은 필드를 같은 위치에 출력하고, 실패가 검증 단계에서 차단되는지 아니면 다음 context까지 전파되는지 비교한다. firmware와 secure world에서는 실패 뒤의 cleanup 또는 reset 경로도 정상 경로만큼 중요하다.

DEEP ANALYSIS

레지스터에서 오류 판정까지 상세 분석

TMEM, RMEM, FMEM은 모두 memref처럼 보이지만 backing object를 찾는 방식과 수명이 다르다. TMEM은 임시 physical buffer, RMEM은 사전에 등록한 shared-memory cookie와 offset, FMEM은 global identifier와 internal offset을 이용할 수 있으므로 attr type별 해석을 섞으면 안 된다.

검증의 중심은 base+offset+size가 아니라 mobj가 표현하는 page list와 access 권한이다. non-contiguous registered SHM에서는 physical address 하나로 전체 buffer를 표현할 수 없고, TA mapping 중 unregister되지 않도록 ref를 잡아야 한다.

그림 5. 이 경로를 통과하는 다섯 개의 진입 계약

01param.attr

TMEM/RMEM/FMEM과 input/output 방향 flag가 지원 조합이어야 한다.

02buffer pointer/cookie

type에 따라 physical address 또는 registered mobj key로 해석한다.

03offset

mobj size 안에서 overflow 없이 적용되고 alignment 요구를 만족한다.

04size

offset+size가 mobj 범위 안이고 TA address-space limit을 넘지 않는다.

05cache attribute

mobj와 mapping의 cacheability가 일치해야 한다.

각 계약은 앞 단계가 생산하고 현재 단계가 검증한 뒤 다음 소비자에게 넘기는 상태다. 한 항목이라도 확인되지 않으면 뒤 단계의 fault를 그 지점의 문제로 단정하지 않는다.

진입 레지스터와 메모리 계약

함수 첫 줄에 도달했을 때 이미 참이라고 가정하는 값과, 그 값이 틀렸을 때 영향을 받는 범위를 함께 적었다.

#	입력 상태	생산자	정상 조건	확인 이유
01	`param.attr`	Normal World	TMEM/RMEM/FMEM과 input/output 방향 flag가 지원 조합이어야 한다.	union field의 해석 방식을 선택한다.
02	`buffer pointer/cookie`	message param	type에 따라 physical address 또는 registered mobj key로 해석한다.	backing object lookup의 untrusted key다.
03	`offset`	message param	mobj size 안에서 overflow 없이 적용되고 alignment 요구를 만족한다.	부분 buffer의 시작을 정한다.
04	`size`	message param	offset+size가 mobj 범위 안이고 TA address-space limit을 넘지 않는다.	mapping과 copy의 최대 byte 수다.
05	`cache attribute`	message attr/SHM registration	mobj와 mapping의 cacheability가 일치해야 한다.	secure/normal world 사이 cache coherency를 결정한다.

핵심 구조체 필드의 생산자, 소비자와 수명

구조체 이름만 나열하지 않고 어떤 코드가 값을 쓰고, 어느 코드가 처음 읽으며, 언제까지 주소와 내용이 유지되어야 하는지 구분했다.

#	객체 또는 필드	생산자	소비자	수명과 불변 조건
01	`optee_msg_param`	Normal World	copy_in_params	wire-format union으로 call 동안만 신뢰하지 않은 채 읽는다.
02	`mobj`	reserved/dynamic SHM subsystem	parameter conversion/TA map	refcount가 있는 backing object로 unregister까지 존재한다.
03	`mobj page list`	Linux SHM registration	mobj_get_pa/get_va	non-contiguous buffer 수명 동안 immutable하게 유지돼야 한다.
04	`tee_ta_param.memref`	secure conversion	TA entry	mobj, offset, size와 direction을 call 동안 안정적으로 소유한다.
05	`user VA mapping`	TA MMU mapper	user TA	session/invoke 동안 mobj ref와 함께 유지되고 cleanup에서 unmap한다.
06	`registered SHM cookie table`	SHM register/unregister command	RMEM lookup	guest/client namespace별로 분리되고 concurrent lookup을 보호한다.

함수 내부 실행 순서

소스의 큰 분기와 side effect를 실행 순서대로 다시 펼쳤다. breakpoint는 이 목록의 경계에 두고, 다음 번호로 넘어갈 때 새로 유효해진 객체를 기록한다.

01
parameter attr에서 base type과 input/output 방향을 분리하고 예약 bit가 0인지 검사한다.
02
TMEM이면 physical range를 허용된 NS SHM 또는 SDP 범위와 대조해 mobj를 만든다.
03
RMEM/FMEM이면 cookie 또는 global ID로 registry를 조회하고 성공 즉시 mobj ref를 획득한다.
04
offset과 size를 overflow-safe 방식으로 계산해 mobj 전체 길이와 parameter limit 안인지 확인한다.
05
direction에 따라 secure read/write 권한과 cache attribute가 backing object 정책과 일치하는지 검사한다.
06
pseudo TA에는 적절한 secure VA를, user TA에는 page list 기반 user VA mapping을 제공한다.
07
TA 실행 중 short buffer 또는 output size 변화가 생기면 원래 bounds와 ABI 규칙에 맞춰 결과를 정규화한다.
08
output size/value만 message에 반영하고 cache maintenance가 필요한 platform이면 owner 전환 순서를 지킨다.
09
TA mapping을 제거한 뒤 mobj ref를 놓아 unregister가 안전하게 진행될 수 있게 한다.

빌드 설정이 바꾸는 실제 코드 경로

동일한 함수 이름이라도 아래 설정에 따라 포함되는 source, 구조체 크기, 인자 의미와 failure path가 달라진다.

#	설정	바뀌는 동작	확인 방법
01	`CFG_CORE_DYN_SHM`	registered non-contiguous SHM과 RMEM/FMEM을 지원한다.	page list validation과 cookie registry를 확인한다.
02	`CFG_CORE_RESERVED_SHM`	고정 contiguous NS SHM의 TMEM 경로를 제공한다.	base/size boundary와 cache attribute를 확인한다.
03	`CFG_SECURE_DATA_PATH`	특수 protected memory mobj type과 access policy가 추가된다.	일반 NS SHM으로 alias되지 않는지 본다.
04	`CFG_NS_VIRTUALIZATION`	SHM registry를 guest context별로 분리한다.	cross-guest cookie lookup이 실패하는지 시험한다.

증상에서 최초 불일치 지점까지 추적하기

마지막 panic 메시지가 아니라 어디에서 멈추고 무엇을 읽어 어떤 결론을 내릴지 정리했다. 정상값과 실패값은 같은 build와 같은 위치에서 비교한다.

#	관찰 증상	중단 위치	기록할 값	판정
01	큰 registered buffer의 중간 page에서 fault	`mobj page translation`	page index, page list length, offset	non-contiguous page list 또는 offset 계산 오류를 찾는다.
02	unregister와 invoke 동시 실행 시 crash	`mobj get/put와 registry removal`	refcount, lookup lock, mapping owner	ref 획득 이전에 object가 제거되는 race를 확인한다.
03	Normal World와 secure 값이 다름	`cache owner 전환`	cache attr, clean/invalidate, direction	coherency 또는 잘못된 mapping attribute를 판정한다.
04	offset+size wrap으로 작은 범위처럼 보임	`bounds check`	raw offset/size와 계산 type width	addition 이전의 overflow 검사가 있는지 확인한다.

OBJECT LIFETIME

객체와 수명

대상	만들어지는 시점	유효 범위	확인할 조건
`mobj / optee_msg_param / memref`	type/attr decode	TA mapping 또는 오류 정리 완료까지	TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다.
입력 buffer / metadata	message parameter	parse와 검증이 끝날 때까지	길이, 정렬, 소유권, 변조 가능성
등록된 list / descriptor	mobj lookup	subsystem 종료 또는 image handoff까지	이중 등록, dangling pointer, 오류 unwind
hardware 또는 persistent state	실제 write/probe가 완료된 뒤	reset 또는 명시적 해제·갱신까지	flush, timeout, 전원 차단, rollback
`최종 부트로더 이미지`	link/image 생성 시점	다음 stage가 새 image로 교체할 때까지	load address, entry, section과 header 일치

FAILURE PATH

실패 지점과 증상

#	조건	관찰되는 증상	먼저 볼 단계
01	offset+size wrap	bounds 우회	type/attr decode
02	stale cookie	freed SHM 참조	mobj lookup
03	cache attr 불일치	world 간 데이터 불일치	offset/size bounds

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

EVIDENCE

소스 밖에서 확인할 증거

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

#	목적	명령 또는 계측	판정 기준
01	빌드 산출물	`make PLATFORM=<platform> CFG_TEE_CORE_LOG_LEVEL=4`	tee.elf, tee.bin과 pageable/pager 구성이 같은 설정에서 생성됐는지 확인한다.
02	ELF 배치	`${CROSS_COMPILE64}readelf -W -lS out/arm/core/tee.elf`	secure RAM 안에서 text, data, pager, pageable 구간이 어떤 주소와 권한으로 배치되는지 확인한다.
03	심볼과 주소	`${CROSS_COMPILE64}nm -n out/arm/core/tee.elf \| grep 'static TEE_Result copy_in_params'`	entry, thread, TA manager 함수의 링크 주소를 원본 설명과 연결한다.
04	명령과 예외 경로	`${CROSS_COMPILE64}objdump -drS out/arm/core/tee.elf`	SMC entry, world switch, abort 복귀가 실제 register save/restore와 어떻게 이어지는지 대조한다.
05	Normal world 왕복	`xtest; dmesg \| grep -i optee`	secure console과 Linux OP-TEE driver 로그를 함께 보고 SMC, RPC, shared memory 왕복의 양쪽 증거를 맞춘다.

LAB

직접 확인할 실험

01
경계에 걸친 memref 시험
type/attr decode 진입 전후에 optee_msg_param의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다. 조건이 처음 깨지는 줄을 기록한다.
02
unregister와 invoke 경쟁 재현
mobj lookup 진입 전후에 mobj의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다. 조건이 처음 깨지는 줄을 기록한다.
03
TMEM과 RMEM의 refcount 변화를 비교
offset/size bounds 진입 전후에 tee_ta_param의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 TA에 전달되는 모든 memref는 살아 있는 mobj 범위 안에 있고 requested direction과 cache/security attribute가 허용되어야 한다. 조건이 처음 깨지는 줄을 기록한다.

PRIMARY REFERENCES

원문과 다음 글

core/tee/entry_std.c4.10.0 원본 파일 OP-TEE OS source tree기준 commit 753afbbee168