ARM64 exception에서 C handler까지 | LK

QUESTION

ARM64 exception에서 C handler까지 단계에서 실제로 바뀌는 상태는 무엇인가?

exception level과 vector slot에 따라 저장해야 할 register가 다르다. fault address와 syndrome을 읽는 시점, frame의 수명을 확인한다.

handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다. 이 문장을 기준으로 코드를 위에서 아래로 읽으면, 함수 이름을 외우는 대신 어느 시점에 어떤 상태를 신뢰할 수 있는지 판단할 수 있다.

STRUCTURE

객체와 주소가 놓이는 구조

그림 1. ARM64 exception에서 C handler까지에서 입력, 내부 상태, 출력의 경계

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

01vector slot

02arm64_iframe

03syndrome registers

04fault handler

INVARIANT

handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다.

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

CALL PATH

실행 흐름

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

exception vector

save iframe

ESR/FAR read

C dispatch

eret or panic

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

STATE LEDGER

단계별 입력과 출력

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

#	단계	진입 시 신뢰할 상태	성공 뒤 남아야 할 상태	다음 소비자
01	`exception vector`	동기 exception 문맥	vector slot	save iframe
02	`save iframe`	exception vector 완료 상태	arm64_iframe	ESR/FAR read
03	`ESR/FAR read`	save iframe 완료 상태	syndrome registers	C dispatch
04	`C dispatch`	ESR/FAR read 완료 상태	fault handler	eret or panic
05	`eret or panic`	C dispatch 완료 상태	fault handler	최종 최종 부트로더 이미지 또는 다음 stage

공통 불변 조건: handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다. 한 단계의 출력이 다음 단계의 입력 조건을 만족하지 않으면 오류가 실제로 드러난 위치보다 앞의 생산 단계부터 조사한다.

UPSTREAM SOURCE

원본 코드

아래 코드는 LK upstream 1eb9917의 arch/arm64/exceptions_c.c에서 136-224줄을 그대로 가져온 것이다. 설명을 위해 실제 코드를 가짜 의사 코드로 바꾸지 않았다.

commit1eb99171efae98867d4be4a5bd6479ea03f43ac9symbolvoid arm64_sync_exception

136}
137
138extern struct fault_handler_table_entry __fault_handler_table_start[];
139extern struct fault_handler_table_entry __fault_handler_table_end[];
140
141static void dump_iframe(const struct arm64_iframe_long *iframe) {
142    printf("iframe %p:\n", iframe);
143    printf("x0  0x%16llx x1  0x%16llx x2  0x%16llx x3  0x%16llx\n", iframe->r[0], iframe->r[1], iframe->r[2], iframe->r[3]);
144    printf("x4  0x%16llx x5  0x%16llx x6  0x%16llx x7  0x%16llx\n", iframe->r[4], iframe->r[5], iframe->r[6], iframe->r[7]);
145    printf("x8  0x%16llx x9  0x%16llx x10 0x%16llx x11 0x%16llx\n", iframe->r[8], iframe->r[9], iframe->r[10], iframe->r[11]);
146    printf("x12 0x%16llx x13 0x%16llx x14 0x%16llx x15 0x%16llx\n", iframe->r[12], iframe->r[13], iframe->r[14], iframe->r[15]);
147    printf("x16 0x%16llx x17 0x%16llx x18 0x%16llx x19 0x%16llx\n", iframe->r[16], iframe->r[17], iframe->r[18], iframe->r[19]);
148    printf("x20 0x%16llx x21 0x%16llx x22 0x%16llx x23 0x%16llx\n", iframe->r[20], iframe->r[21], iframe->r[22], iframe->r[23]);
149    printf("x24 0x%16llx x25 0x%16llx x26 0x%16llx x27 0x%16llx\n", iframe->r[24], iframe->r[25], iframe->r[26], iframe->r[27]);
150    printf("x28 0x%16llx x29 0x%16llx lr  0x%16llx usp 0x%16llx\n", iframe->r[28], iframe->r[29], iframe->lr, iframe->usp);
151    printf("elr 0x%16llx\n", iframe->elr);
152    printf("spsr 0x%16llx\n", iframe->spsr);
153    arch_stacktrace(iframe->r[29], iframe->elr);
154}
155
156__WEAK void arm64_syscall(struct arm64_iframe_long *iframe, bool is_64bit) {
157    panic("unhandled syscall vector\n");
158}
159
160void arm64_sync_exception(struct arm64_iframe_long *iframe);
161void arm64_sync_exception(struct arm64_iframe_long *iframe) {
162    struct fault_handler_table_entry *fault_handler;
163    uint32_t esr = ARM64_READ_SYSREG(esr_el1);
164    uint32_t ec = BITS_SHIFT(esr, 31, 26);
165    uint32_t il = BIT(esr, 25);
166    uint32_t iss = BITS(esr, 24, 0);
167
168    switch (ec) {
169        case 0b000111: /* floating point */
170            arm64_fpu_exception(iframe);
171            return;
172        case 0b010001: /* syscall from arm32 */
173        case 0b010101: /* syscall from arm64 */
174#ifdef WITH_LIB_SYSCALL
175            void arm64_syscall(struct arm64_iframe_long *iframe);
176            arch_enable_fiqs();
177            arm64_syscall(iframe);
178            arch_disable_fiqs();
179            return;
180#else
181            arm64_syscall(iframe, (ec == 0x15) ? true : false);
182            return;
183#endif
184        case 0b100000: /* instruction abort from lower level */
185        case 0b100001: /* instruction abort from same level */
186            printf("instruction abort: PC at 0x%llx\n", iframe->elr);
187            print_fault_msg(BITS(iss, 5, 0));
188            break;
189        case 0b100100: /* data abort from lower level */
190        case 0b100101: { /* data abort from same level */
191            for (fault_handler = __fault_handler_table_start;
192                    fault_handler < __fault_handler_table_end;
193                    fault_handler++) {
194                if (fault_handler->pc == iframe->elr) {
195                    iframe->elr = fault_handler->fault_handler;
196                    return;
197                }
198            }
199
200            /* read the FAR register */
201            uint64_t far = ARM64_READ_SYSREG(far_el1);
202
203            printf("data fault: %s access from PC 0x%llx, FAR 0x%llx, iss 0x%x (DFSC 0x%lx)\n",
204                   BIT(iss, 6) ? "Write" : "Read", iframe->elr, far, iss, BITS(iss, 5, 0));
205            print_fault_msg(BITS(iss, 5, 0));
206            break;
207        }
208        case 0b111100: {
209            printf("BRK #0x%04lx instruction: PC at 0x%llx\n",
210                   BITS_SHIFT(iss, 15, 0), iframe->elr);
211            break;
212        }
213        default:
214            printf("unhandled synchronous exception\n");
215    }
216
217    /* unhandled exception, die here */
218    printf("ESR 0x%x: ec 0x%x, il 0x%x, iss 0x%x\n", esr, ec, il, iss);
219    dump_iframe(iframe);
220
221    panic("die\n");
222}
223
224void arm64_invalid_exception(struct arm64_iframe_long *iframe, unsigned int which);

LINE BY LINE

136-224줄 해설

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

136}

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

137(빈 줄)

}까지의 동작과 extern struct fault_handler_table_entry __fault_handler_table_start[];에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 arm64_iframe 상태가 아래 블록의 입력으로 사용되는 경계다.

138extern struct fault_handler_table_entry __fault_handler_table_start[];

extern struct fault_handler_table_entry __fault_handler_table_start[]를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 arm64_iframe / ESR_ELx를 직접 소유하는지 pointer만 빌리는지, 동기 exception 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

139extern struct fault_handler_table_entry __fault_handler_table_end[];

extern struct fault_handler_table_entry __fault_handler_table_end[]를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 arm64_iframe / ESR_ELx를 직접 소유하는지 pointer만 빌리는지, 동기 exception 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

140(빈 줄)

extern struct fault_handler_table_entry __fault_handler_table_end[];까지의 동작과 static void dump_iframe(const struct arm64_iframe_long *iframe) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 fault handler 상태가 아래 블록의 입력으로 사용되는 경계다.

141static void dump_iframe(const struct arm64_iframe_long *iframe) {

dump_iframe 함수 정의가 시작된다. 입력은 const struct arm64_iframe_long *iframe이며, 동기 exception 문맥에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

142printf("iframe %p:\n", iframe);

printf("iframe %p:\n", iframe)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

143printf("x0 0x%16llx x1 0x%16llx x2 0x%16llx x3 0x%16llx\n", iframe->r[0], iframe->r[1], iframe->r[2], iframe->r[3]);

printf("x0 0x%16llx x1 0x%16llx x2 0x%16llx x3 0x%16llx\n", iframe->r[0], iframe->r[1], iframe->r[2], iframe->r[3])를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

144printf("x4 0x%16llx x5 0x%16llx x6 0x%16llx x7 0x%16llx\n", iframe->r[4], iframe->r[5], iframe->r[6], iframe->r[7]);

printf("x4 0x%16llx x5 0x%16llx x6 0x%16llx x7 0x%16llx\n", iframe->r[4], iframe->r[5], iframe->r[6], iframe->r[7])를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

145

printf("x8  0x%16llx x9  0x%16llx x10 0x%16llx x11 0x%16llx\n", iframe->r[8], iframe->r[9], iframe->r[10], iframe->r[11]);

printf("x8 0x%16llx x9 0x%16llx x10 0x%16llx x11 0x%16llx\n", iframe->r[8], iframe->r[9], iframe->r[10], iframe->r[11])를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

146

printf("x12 0x%16llx x13 0x%16llx x14 0x%16llx x15 0x%16llx\n", iframe->r[12], iframe->r[13], iframe->r[14], iframe->r[15]);

printf("x12 0x%16llx x13 0x%16llx x14 0x%16llx x15 0x%16llx\n", iframe->r[12], iframe->r[13], iframe->r[14], iframe->r[15])를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

147

printf("x16 0x%16llx x17 0x%16llx x18 0x%16llx x19 0x%16llx\n", iframe->r[16], iframe->r[17], iframe->r[18], iframe->r[19]);

printf("x16 0x%16llx x17 0x%16llx x18 0x%16llx x19 0x%16llx\n", iframe->r[16], iframe->r[17], iframe->r[18], iframe->r[19])를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

148

printf("x20 0x%16llx x21 0x%16llx x22 0x%16llx x23 0x%16llx\n", iframe->r[20], iframe->r[21], iframe->r[22], iframe->r[23]);

printf("x20 0x%16llx x21 0x%16llx x22 0x%16llx x23 0x%16llx\n", iframe->r[20], iframe->r[21], iframe->r[22], iframe->r[23])를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

149

printf("x24 0x%16llx x25 0x%16llx x26 0x%16llx x27 0x%16llx\n", iframe->r[24], iframe->r[25], iframe->r[26], iframe->r[27]);

printf("x24 0x%16llx x25 0x%16llx x26 0x%16llx x27 0x%16llx\n", iframe->r[24], iframe->r[25], iframe->r[26], iframe->r[27])를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

150printf("x28 0x%16llx x29 0x%16llx lr 0x%16llx usp 0x%16llx\n", iframe->r[28], iframe->r[29], iframe->lr, iframe->usp);

printf("x28 0x%16llx x29 0x%16llx lr 0x%16llx usp 0x%16llx\n", iframe->r[28], iframe->r[29], iframe->lr, iframe->usp)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

151printf("elr 0x%16llx\n", iframe->elr);

printf("elr 0x%16llx\n", iframe->elr)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

152printf("spsr 0x%16llx\n", iframe->spsr);

printf("spsr 0x%16llx\n", iframe->spsr)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

153arch_stacktrace(iframe->r[29], iframe->elr);

arch_stacktrace(iframe->r[29], iframe->elr)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

154}

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

155(빈 줄)

}까지의 동작과 __WEAK void arm64_syscall(struct arm64_iframe_long *iframe, bool is_64bit) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 fault handler 상태가 아래 블록의 입력으로 사용되는 경계다.

156__WEAK void arm64_syscall(struct arm64_iframe_long *iframe, bool is_64bit) {

arm64_syscall 함수 정의가 시작된다. 입력은 struct arm64_iframe_long *iframe, bool is_64bit이며, 동기 exception 문맥에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

157panic("unhandled syscall vector\n");

panic("unhandled syscall vector\n")를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

158}

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

159(빈 줄)

}까지의 동작과 void arm64_sync_exception(struct arm64_iframe_long *iframe);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 fault handler 상태가 아래 블록의 입력으로 사용되는 경계다.

160void arm64_sync_exception(struct arm64_iframe_long *iframe);

void arm64_sync_exception(struct arm64_iframe_long *iframe)를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 arm64_iframe / ESR_ELx를 직접 소유하는지 pointer만 빌리는지, 동기 exception 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

161void arm64_sync_exception(struct arm64_iframe_long *iframe) {

arm64_sync_exception 함수 정의가 시작된다. 입력은 struct arm64_iframe_long *iframe이며, 동기 exception 문맥에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

162struct fault_handler_table_entry *fault_handler;

struct fault_handler_table_entry *fault_handler를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 arm64_iframe / ESR_ELx를 직접 소유하는지 pointer만 빌리는지, 동기 exception 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

163uint32_t esr = ARM64_READ_SYSREG(esr_el1);

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

164uint32_t ec = BITS_SHIFT(esr, 31, 26);

uint32_t ec에 BITS_SHIFT(esr, 31, 26)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 eret or panic 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

165uint32_t il = BIT(esr, 25);

uint32_t il에 BIT(esr, 25)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 eret or panic 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

166uint32_t iss = BITS(esr, 24, 0);

uint32_t iss에 BITS(esr, 24, 0)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 eret or panic 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

167(빈 줄)

uint32_t iss = BITS(esr, 24, 0);까지의 동작과 switch (ec) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 fault handler 상태가 아래 블록의 입력으로 사용되는 경계다.

168switch (ec) {

원본 168번 줄의 switch (ec) {는 앞의 이전 block 경계 결과를 받아 다음 case 0b000111: /* floating point */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

169case 0b000111: /* floating point */

원본 169번 줄의 case 0b000111: /* floating point */는 앞의 switch (ec) { 결과를 받아 다음 arm64_fpu_exception(iframe);로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

170arm64_fpu_exception(iframe);

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

171return;

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

172case 0b010001: /* syscall from arm32 */

원본 172번 줄의 case 0b010001: /* syscall from arm32 */는 앞의 return; 결과를 받아 다음 case 0b010101: /* syscall from arm64 */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

173case 0b010101: /* syscall from arm64 */

원본 173번 줄의 case 0b010101: /* syscall from arm64 */는 앞의 case 0b010001: /* syscall from arm32 */ 결과를 받아 다음 #ifdef WITH_LIB_SYSCALL로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

174#ifdef WITH_LIB_SYSCALL

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

175void arm64_syscall(struct arm64_iframe_long *iframe);

void arm64_syscall(struct arm64_iframe_long *iframe)를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 arm64_iframe / ESR_ELx를 직접 소유하는지 pointer만 빌리는지, 동기 exception 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

176arch_enable_fiqs();

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

177arm64_syscall(iframe);

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

178arch_disable_fiqs();

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

179return;

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

180#else

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

181arm64_syscall(iframe, (ec == 0x15) ? true : false);

arm64_syscall(iframe, (ec에 = 0x15) ? true : false)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 eret or panic 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

182return;

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

183#endif

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

184case 0b100000: /* instruction abort from lower level */

원본 184번 줄의 case 0b100000: /* instruction abort from lower level */는 앞의 #endif 결과를 받아 다음 case 0b100001: /* instruction abort from same level */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

185case 0b100001: /* instruction abort from same level */

원본 185번 줄의 case 0b100001: /* instruction abort from same level */는 앞의 case 0b100000: /* instruction abort from lower level */ 결과를 받아 다음 printf("instruction abort: PC at 0x%llx\n", iframe->elr);로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

186printf("instruction abort: PC at 0x%llx\n", iframe->elr);

printf("instruction abort: PC at 0x%llx\n", iframe->elr)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

187print_fault_msg(BITS(iss, 5, 0));

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

188break;

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

189case 0b100100: /* data abort from lower level */

원본 189번 줄의 case 0b100100: /* data abort from lower level */는 앞의 break; 결과를 받아 다음 case 0b100101: { /* data abort from same level */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

190case 0b100101: { /* data abort from same level */

원본 190번 줄의 case 0b100101: { /* data abort from same level */는 앞의 case 0b100100: /* data abort from lower level */ 결과를 받아 다음 for (fault_handler = __fault_handler_table_start;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

191for (fault_handler = __fault_handler_table_start;

'for (fault_handler = __fault_handler_table_start;'가 목록이나 후보를 순회한다. 반복 중 arm64_iframe / ESR_ELx를 제거·추가하는 호출이 있는지와 loop 종료 뒤 iterator가 유효한지 확인한다.

192fault_handler < __fault_handler_table_end;

원본 192번 줄의 fault_handler < __fault_handler_table_end;는 앞의 for (fault_handler = __fault_handler_table_start; 결과를 받아 다음 fault_handler++) {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

193fault_handler++) {

원본 193번 줄의 fault_handler++) {는 앞의 fault_handler < __fault_handler_table_end; 결과를 받아 다음 if (fault_handler->pc == iframe->elr) {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

194if (fault_handler->pc == iframe->elr) {

fault_handler->pc == iframe->elr를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

195iframe->elr = fault_handler->fault_handler;

iframe->elr에 fault_handler->fault_handler를 = 연산으로 반영해 arm64_iframe / ESR_ELx와 연결된 field를 갱신한다. 이후 eret or panic 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

196return;

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

197}

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

198}

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

199(빈 줄)

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

200/* read the FAR register */

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

201uint64_t far = ARM64_READ_SYSREG(far_el1);

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

202(빈 줄)

uint64_t far = ARM64_READ_SYSREG(far_el1);까지의 동작과 printf("data fault: %s access from PC 0x%llx, FAR 0x%llx, iss 0x%x (DFSC 0x%lx)\n",에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 fault handler 상태가 아래 블록의 입력으로 사용되는 경계다.

203printf("data fault: %s access from PC 0x%llx, FAR 0x%llx, iss 0x%x (DFSC 0x%lx)\n",

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

204BIT(iss, 6) ? "Write" : "Read", iframe->elr, far, iss, BITS(iss, 5, 0));

205print_fault_msg(BITS(iss, 5, 0));

206break;

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

207}

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

208case 0b111100: {

원본 208번 줄의 case 0b111100: {는 앞의 } 결과를 받아 다음 printf("BRK #0x%04lx instruction: PC at 0x%llx\n",로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다' 조건이 유지되는지 확인한다.

209printf("BRK #0x%04lx instruction: PC at 0x%llx\n",

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

210BITS_SHIFT(iss, 15, 0), iframe->elr);

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

211break;

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

212}

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

213default:

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

214printf("unhandled synchronous exception\n");

printf("unhandled synchronous exception\n")를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

215}

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

216(빈 줄)

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

217/* unhandled exception, die here */

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

218printf("ESR 0x%x: ec 0x%x, il 0x%x, iss 0x%x\n", esr, ec, il, iss);

printf("ESR 0x%x: ec 0x%x, il 0x%x, iss 0x%x\n", esr, ec, il, iss)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 arm64_iframe / ESR_ELx의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 fault handler 항목과 대조한다.

219dump_iframe(iframe);

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

220(빈 줄)

dump_iframe(iframe);까지의 동작과 panic("die\n");에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 fault handler 상태가 아래 블록의 입력으로 사용되는 경계다.

221panic("die\n");

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

222}

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

223(빈 줄)

}까지의 동작과 void arm64_invalid_exception(struct arm64_iframe_long *iframe, unsigned int which);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 fault handler 상태가 아래 블록의 입력으로 사용되는 경계다.

224void arm64_invalid_exception(struct arm64_iframe_long *iframe, unsigned int which);

void arm64_invalid_exception(struct arm64_iframe_long *iframe, unsigned int which)를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 arm64_iframe / ESR_ELx를 직접 소유하는지 pointer만 빌리는지, 동기 exception 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

DETAILS

내부 동작을 더 깊게 읽기

진입 조건을 먼저 고정한다

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

exception level과 vector slot에 따라 저장해야 할 register가 다르다. fault address와 syndrome을 읽는 시점, frame의 수명을 확인한다.

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

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

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

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

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

handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다.

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

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

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

마지막 handoff의 계약을 적는다

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

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

IMPLEMENTATION NOTES

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

vector slot에서 iframe 완성까지가 하나의 원자적 진입이다

assembly는 interrupted context의 general register, ELR, SPSR와 syndrome을 stack frame에 저장한 뒤 C handler로 넘긴다. frame offset이 C 구조체와 한 필드라도 다르면 backtrace와 signal 판단이 모두 틀어진다.

nested exception을 허용하기 전까지 stack과 per-CPU exception state가 완성되어야 한다.

IRQ와 synchronous exception은 복귀 조건이 다르다

IRQ handler는 interrupt controller에서 source를 acknowledge하고 device handler 뒤 EOI를 수행하지만 synchronous abort는 ESR class와 FAR를 해석해 복구 또는 panic을 결정한다. 같은 C dispatch로 들어가도 saved PC를 증가시킬지 여부가 다르다.

spurious interrupt와 level-triggered source가 계속 assert된 경우의 loop를 구분한다.

user와 kernel fault 경계를 명시한다

lower EL에서 온 fault는 현재 process address space와 user register를 기준으로 처리할 수 있지만 kernel fault는 대개 invariant 위반이다. exception origin bit와 saved SPSR를 먼저 확인한다.

fault log에는 ESR 해석 문자열뿐 아니라 raw ESR, FAR, ELR, SP와 translation table base를 남긴다.

OBJECT LIFETIME

객체와 수명

대상	만들어지는 시점	유효 범위	확인할 조건
`arm64_iframe / ESR_ELx`	save iframe	eret or panic 또는 오류 정리 완료까지	handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다.
입력 buffer / metadata	exception vector	parse와 검증이 끝날 때까지	길이, 정렬, 소유권, 변조 가능성
등록된 list / descriptor	ESR/FAR read	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	frame layout 불일치	잘못된 register 복원	save iframe
02	ESR decode 오류	원인 오판	ESR/FAR read
03	nested exception	원래 frame 손상	C dispatch

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

EVIDENCE

소스 밖에서 확인할 증거

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

#	목적	명령 또는 계측	판정 기준
01	빌드 구성	`make <project> -j1`	platform, target, app 선택과 linker 입력을 로그로 남긴다.
02	symbol과 주소	`nm -n build-*/lk.elf \| grep 'void arm64_sync_exception'`	init hook, app descriptor와 함수가 어느 주소에 놓였는지 확인한다.
03	어셈블리 대조	`objdump -drS build-*/lk.elf`	thread 전환과 interrupt disable 구간의 실제 명령을 확인한다.
04	초기화 순서	`init level 전후에 current_time_hires()와 함수 이름 기록`	level 내부 순서와 지연을 serial log로 남긴다.
05	문맥 확인	`current_thread, interrupt state, stack pointer 기록`	함수가 bootstrap thread인지 scheduler 이후 thread인지 구분한다.

LAB

직접 확인할 실험

01
의도적 data abort로 ESR/FAR 확인
save iframe 진입 전후에 vector slot의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다. 조건이 처음 깨지는 줄을 기록한다.
02
objdump로 assembly frame offset과 C struct 비교
ESR/FAR read 진입 전후에 arm64_iframe의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다. 조건이 처음 깨지는 줄을 기록한다.
03
breakpoint exception의 PC 증가 규칙 확인
C dispatch 진입 전후에 syndrome registers의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 handler가 복귀한다면 frame은 예외 전 CPU 상태를 완전하게 보존하고 수정 사항만 의도적으로 반영해야 한다. 조건이 처음 깨지는 줄을 기록한다.

PRIMARY REFERENCES

원문과 다음 글

arch/arm64/exceptions_c.cupstream 1eb9917 원본 파일 LK source tree기준 commit 1eb99171efae