GICv3 Group 0/1 interrupt routing | Trusted Firmware-A

QUESTION

GICv3 Group 0/1 interrupt routing 단계에서 실제로 바뀌는 상태는 무엇인가?

interrupt ID만 보지 말고 group, priority, security state, route target과 EOI/deactivate 책임을 함께 본다.

secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다. 이 문장을 기준으로 코드를 위에서 아래로 읽으면, 함수 이름을 외우는 대신 어느 시점에 어떤 상태를 신뢰할 수 있는지 판단할 수 있다.

STRUCTURE

객체와 주소가 놓이는 구조

그림 1. GICv3 Group 0/1 interrupt routing에서 입력, 내부 상태, 출력의 경계

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

01gicv3_driver_data_t

02GICD/GICR frames

03interrupt group

04SCR routing bits

INVARIANT

secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다.

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

CALL PATH

실행 흐름

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

platform GIC data

Distributor init

Redistributor discover

CPU interface

interrupt routing

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

STATE LEDGER

단계별 입력과 출력

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

#	단계	진입 시 신뢰할 상태	성공 뒤 남아야 할 상태	다음 소비자
01	`platform GIC data`	EL3 initialization and interrupt context	gicv3_driver_data_t	Distributor init
02	`Distributor init`	platform GIC data 완료 상태	GICD/GICR frames	Redistributor discover
03	`Redistributor discover`	Distributor init 완료 상태	interrupt group	CPU interface
04	`CPU interface`	Redistributor discover 완료 상태	SCR routing bits	interrupt routing
05	`interrupt routing`	CPU interface 완료 상태	SCR routing bits	최종 최종 부트로더 이미지 또는 다음 stage

공통 불변 조건: secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다. 한 단계의 출력이 다음 단계의 입력 조건을 만족하지 않으면 오류가 실제로 드러난 위치보다 앞의 생산 단계부터 조사한다.

VISUAL WALKTHROUGH

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

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

그림 3. GICv3 Group 0/1 interrupt routing의 실행 순서

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

01platform GIC data

02Distributor init

03Redistributor discover

04CPU interface

05interrupt routing

그림 4. GIC interrupt group과 실행 world

두 열은 실행 주체와 접근 권한, 객체를 해제할 책임이 다른 경계를 비교한다.

Group 0 / Secure

01secure priority

02EL3 또는 S-EL1 routing

03secure handler가 EOI

04NS에서 mask/변경 제한

Group 1NS / Normal

01Linux IRQ

02NS priority mask

03NS handler가 EOI

04EL3 routing 정책 적용

UPSTREAM SOURCE

원본 코드

아래 코드는 Trusted Firmware-A LTS 2.14.3의 drivers/arm/gic/v3/gicv3_main.c에서 76-164줄을 그대로 가져온 것이다. 설명을 위해 실제 코드를 가짜 의사 코드로 바꾸지 않았다.

commitf5e765a3443fe21154aa908228e75ee2600085f6symbolvoid __init gicv3_driver_init(

76			(ctx)->gicd_##reg[(int_id - (MIN_ESPI_ID -	\
77			round_up(TOTAL_SPI_INTR_NUM, 1U << REG##R_SHIFT)))\
78						>> REG##R_SHIFT]);	\
79		}							\
80	} while (false)
81
82#define SAVE_GICD_EREGS(base, ctx, intr_num, reg, REG)			\
83	do {								\
84		for (unsigned int int_id = MIN_ESPI_ID; int_id < (intr_num);\
85				int_id += (1U << REG##R_SHIFT)) {	\
86			(ctx)->gicd_##reg[(int_id - (MIN_ESPI_ID -	\
87			round_up(TOTAL_SPI_INTR_NUM, 1U << REG##R_SHIFT)))\
88			>> REG##R_SHIFT] = gicd_read_##reg((base), int_id);\
89		}							\
90	} while (false)
91#else
92#define SAVE_GICD_EREGS(base, ctx, intr_num, reg, REG)
93#define RESTORE_GICD_EREGS(base, ctx, intr_num, reg, REG)
94#endif /* GIC_EXT_INTID */
95
96/*******************************************************************************
97 * This function initialises the ARM GICv3 driver in EL3 with provided platform
98 * inputs.
99 ******************************************************************************/
100void __init gicv3_driver_init(const gicv3_driver_data_t *plat_driver_data)
101{
102	unsigned int gic_version;
103	unsigned int gicv2_compat;
104
105	assert(plat_driver_data != NULL);
106	assert(plat_driver_data->gicd_base != 0U);
107	assert(plat_driver_data->rdistif_num != 0U);
108	assert(plat_driver_data->rdistif_base_addrs != NULL);
109
110	assert(IS_IN_EL3());
111
112	assert((plat_driver_data->interrupt_props_num == 0U) ||
113			(plat_driver_data->interrupt_props != NULL));
114
115	/* Check for system register support */
116#ifndef __aarch64__
117	assert((read_id_pfr1() &
118			(ID_PFR1_GIC_MASK << ID_PFR1_GIC_SHIFT)) != 0U);
119#else
120	assert((read_id_aa64pfr0_el1() &
121			(ID_AA64PFR0_GIC_MASK << ID_AA64PFR0_GIC_SHIFT)) != 0U);
122#endif /* !__aarch64__ */
123
124	gic_version = gicd_read_pidr2(plat_driver_data->gicd_base);
125	gic_version >>= PIDR2_ARCH_REV_SHIFT;
126	gic_version &= PIDR2_ARCH_REV_MASK;
127
128	/* Check GIC version */
129#if !GIC_ENABLE_V4_EXTN
130	assert(gic_version == ARCH_REV_GICV3);
131#endif
132	/*
133	 * Find out whether the GIC supports the GICv2 compatibility mode.
134	 * The ARE_S bit resets to 0 if supported
135	 */
136	gicv2_compat = gicd_read_ctlr(plat_driver_data->gicd_base);
137	gicv2_compat >>= CTLR_ARE_S_SHIFT;
138	gicv2_compat = gicv2_compat & CTLR_ARE_S_MASK;
139
140	if (plat_driver_data->gicr_base != 0U) {
141		/*
142		 * Find the base address of each implemented Redistributor interface.
143		 * The number of interfaces should be equal to the number of CPUs in the
144		 * system. The memory for saving these addresses has to be allocated by
145		 * the platform port
146		 */
147		gicv3_rdistif_base_addrs_probe(plat_driver_data->rdistif_base_addrs,
148						   plat_driver_data->rdistif_num,
149						   plat_driver_data->gicr_base,
150						   plat_driver_data->mpidr_to_core_pos);
151#if !HW_ASSISTED_COHERENCY
152		/*
153		 * Flush the rdistif_base_addrs[] contents linked to the GICv3 driver.
154		 */
155		flush_dcache_range((uintptr_t)(plat_driver_data->rdistif_base_addrs),
156			plat_driver_data->rdistif_num *
157			sizeof(*(plat_driver_data->rdistif_base_addrs)));
158#endif
159	}
160	gicv3_driver_data = plat_driver_data;
161
162	/*
163	 * The GIC driver data is initialized by the primary CPU with caches
164	 * enabled. When the secondary CPU boots up, it initializes the

LINE BY LINE

76-164줄 해설

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

76(ctx)->gicd_##reg[(int_id - (MIN_ESPI_ID - \

원본 76번 줄의 (ctx)->gicd_##reg[(int_id - (MIN_ESPI_ID - \는 앞의 이전 block 경계 결과를 받아 다음 round_up(TOTAL_SPI_INTR_NUM, 1U << REG##R_SHIFT)))\로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

77round_up(TOTAL_SPI_INTR_NUM, 1U << REG##R_SHIFT)))\

round_up(TOTAL_SPI_INTR_NUM, 1U << REG##R_SHIFT)))를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 GICv3 distributor/redistributor state의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 GICD/GICR frames 항목과 대조한다.

78>> REG##R_SHIFT]); \

원본 78번 줄의 >> REG##R_SHIFT]); \는 앞의 round_up(TOTAL_SPI_INTR_NUM, 1U << REG##R_SHIFT)))\ 결과를 받아 다음 } \로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

79} \

원본 79번 줄의 } \는 앞의 >> REG##R_SHIFT]); \ 결과를 받아 다음 } while (false)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

80} while (false)

원본 80번 줄의 } while (false)는 앞의 } \ 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

81(빈 줄)

} while (false)까지의 동작과 #define SAVE_GICD_EREGS(base, ctx, intr_num, reg, REG) \에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

82#define SAVE_GICD_EREGS(base, ctx, intr_num, reg, REG) \

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

83do { \

원본 83번 줄의 do { \는 앞의 #define SAVE_GICD_EREGS(base, ctx, intr_num, reg, REG) \ 결과를 받아 다음 for (unsigned int int_id = MIN_ESPI_ID; int_id < (intr_num);\로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

84for (unsigned int int_id = MIN_ESPI_ID; int_id < (intr_num);\

'for (unsigned int int_id = MIN_ESPI_ID; int_id < (intr_num);\'가 목록이나 후보를 순회한다. 반복 중 GICv3 distributor/redistributor state를 제거·추가하는 호출이 있는지와 loop 종료 뒤 iterator가 유효한지 확인한다.

85int_id += (1U << REG##R_SHIFT)) { \

원본 85번 줄의 int_id += (1U << REG##R_SHIFT)) { \는 앞의 for (unsigned int int_id = MIN_ESPI_ID; int_id < (intr_num);\ 결과를 받아 다음 (ctx)->gicd_##reg[(int_id - (MIN_ESPI_ID - \로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

86(ctx)->gicd_##reg[(int_id - (MIN_ESPI_ID - \

원본 86번 줄의 (ctx)->gicd_##reg[(int_id - (MIN_ESPI_ID - \는 앞의 int_id += (1U << REG##R_SHIFT)) { \ 결과를 받아 다음 round_up(TOTAL_SPI_INTR_NUM, 1U << REG##R_SHIFT)))\로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

87round_up(TOTAL_SPI_INTR_NUM, 1U << REG##R_SHIFT)))\

88>> REG##R_SHIFT] = gicd_read_##reg((base), int_id);\

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

89} \

원본 89번 줄의 } \는 앞의 >> REG##R_SHIFT] = gicd_read_##reg((base), int_id);\ 결과를 받아 다음 } while (false)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

90} while (false)

원본 90번 줄의 } while (false)는 앞의 } \ 결과를 받아 다음 #else로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

91#else

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

92#define SAVE_GICD_EREGS(base, ctx, intr_num, reg, REG)

93#define RESTORE_GICD_EREGS(base, ctx, intr_num, reg, REG)

94#endif /* GIC_EXT_INTID */

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

95(빈 줄)

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

96/*******************************************************************************

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

97* This function initialises the ARM GICv3 driver in EL3 with provided platform

원본 주석이 'This function initialises the ARM GICv3 driver in EL3 with provided platform'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

98* inputs.

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

99******************************************************************************/

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

100void __init gicv3_driver_init(const gicv3_driver_data_t *plat_driver_data)

gicv3_driver_init 함수 정의가 시작된다. 입력은 const gicv3_driver_data_t *plat_driver_data이며, EL3 initialization and interrupt context에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

101{

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

102unsigned int gic_version;

unsigned int gic_version를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 GICv3 distributor/redistributor state를 직접 소유하는지 pointer만 빌리는지, EL3 initialization and interrupt context를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

103unsigned int gicv2_compat;

unsigned int gicv2_compat를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 GICv3 distributor/redistributor state를 직접 소유하는지 pointer만 빌리는지, EL3 initialization and interrupt context를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

104(빈 줄)

unsigned int gicv2_compat;까지의 동작과 assert(plat_driver_data != NULL);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

105assert(plat_driver_data != NULL);

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

106assert(plat_driver_data->gicd_base != 0U);

assert(plat_driver_data->gicd_base !에 0U)를 = 연산으로 반영해 GICv3 distributor/redistributor state와 연결된 field를 갱신한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 interrupt routing 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

107assert(plat_driver_data->rdistif_num != 0U);

assert(plat_driver_data->rdistif_num !에 0U)를 = 연산으로 반영해 GICv3 distributor/redistributor state와 연결된 field를 갱신한다. 이후 interrupt routing 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

108assert(plat_driver_data->rdistif_base_addrs != NULL);

assert(plat_driver_data->rdistif_base_addrs !에 NULL)를 = 연산으로 반영해 GICv3 distributor/redistributor state와 연결된 field를 갱신한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 interrupt routing 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

109(빈 줄)

assert(plat_driver_data->rdistif_base_addrs != NULL);까지의 동작과 assert(IS_IN_EL3());에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

110assert(IS_IN_EL3());

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

111(빈 줄)

assert(IS_IN_EL3());까지의 동작과 assert((plat_driver_data->interrupt_props_num == 0U) ||에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

112assert((plat_driver_data->interrupt_props_num == 0U) ||

assert((plat_driver_data->interrupt_props_num == 0U)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 GICv3 distributor/redistributor state의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SCR routing bits 항목과 대조한다.

113(plat_driver_data->interrupt_props != NULL));

(plat_driver_data->interrupt_props !에 NULL))를 = 연산으로 반영해 GICv3 distributor/redistributor state와 연결된 field를 갱신한다. 이후 interrupt routing 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

114(빈 줄)

(plat_driver_data->interrupt_props != NULL));까지의 동작과 /* Check for system register support */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

115/* Check for system register support */

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

116#ifndef __aarch64__

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

117assert((read_id_pfr1() &

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

118(ID_PFR1_GIC_MASK << ID_PFR1_GIC_SHIFT)) != 0U);

(ID_PFR1_GIC_MASK << ID_PFR1_GIC_SHIFT)) !에 0U)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 interrupt routing 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

119#else

120assert((read_id_aa64pfr0_el1() &

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

121(ID_AA64PFR0_GIC_MASK << ID_AA64PFR0_GIC_SHIFT)) != 0U);

(ID_AA64PFR0_GIC_MASK << ID_AA64PFR0_GIC_SHIFT)) !에 0U)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 interrupt routing 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

122#endif /* !__aarch64__ */

123(빈 줄)

#endif /* !__aarch64__ */까지의 동작과 gic_version = gicd_read_pidr2(plat_driver_data->gicd_base);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

124gic_version = gicd_read_pidr2(plat_driver_data->gicd_base);

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

125gic_version >>= PIDR2_ARCH_REV_SHIFT;

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

126gic_version &= PIDR2_ARCH_REV_MASK;

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

127(빈 줄)

gic_version &= PIDR2_ARCH_REV_MASK;까지의 동작과 /* Check GIC version */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

128/* Check GIC version */

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

129#if !GIC_ENABLE_V4_EXTN

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

130assert(gic_version == ARCH_REV_GICV3);

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

131#endif

132/*

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

133* Find out whether the GIC supports the GICv2 compatibility mode.

원본 주석이 'Find out whether the GIC supports the GICv2 compatibility mode.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

134* The ARE_S bit resets to 0 if supported

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

135*/

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

136gicv2_compat = gicd_read_ctlr(plat_driver_data->gicd_base);

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

137gicv2_compat >>= CTLR_ARE_S_SHIFT;

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

138gicv2_compat = gicv2_compat & CTLR_ARE_S_MASK;

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

139(빈 줄)

gicv2_compat = gicv2_compat & CTLR_ARE_S_MASK;까지의 동작과 if (plat_driver_data->gicr_base != 0U) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

140if (plat_driver_data->gicr_base != 0U) {

plat_driver_data->gicr_base != 0U를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

141/*

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

142* Find the base address of each implemented Redistributor interface.

원본 주석이 'Find the base address of each implemented Redistributor interface.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

143* The number of interfaces should be equal to the number of CPUs in the

원본 주석이 'The number of interfaces should be equal to the number of CPUs in the'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

144* system. The memory for saving these addresses has to be allocated by

원본 주석이 'system. The memory for saving these addresses has to be allocated by'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

145* the platform port

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

146*/

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

147gicv3_rdistif_base_addrs_probe(plat_driver_data->rdistif_base_addrs,

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

148plat_driver_data->rdistif_num,

원본 148번 줄의 plat_driver_data->rdistif_num,는 앞의 gicv3_rdistif_base_addrs_probe(plat_driver_data->rdistif_base_addrs, 결과를 받아 다음 plat_driver_data->gicr_base,로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

149plat_driver_data->gicr_base,

원본 149번 줄의 plat_driver_data->gicr_base,는 앞의 plat_driver_data->rdistif_num, 결과를 받아 다음 plat_driver_data->mpidr_to_core_pos);로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

150plat_driver_data->mpidr_to_core_pos);

원본 150번 줄의 plat_driver_data->mpidr_to_core_pos);는 앞의 plat_driver_data->gicr_base, 결과를 받아 다음 #if !HW_ASSISTED_COHERENCY로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

151#if !HW_ASSISTED_COHERENCY

152/*

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

153* Flush the rdistif_base_addrs[] contents linked to the GICv3 driver.

원본 주석이 'Flush the rdistif_base_addrs[] contents linked to the GICv3 driver.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

154*/

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

155flush_dcache_range((uintptr_t)(plat_driver_data->rdistif_base_addrs),

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

156plat_driver_data->rdistif_num *

원본 156번 줄의 plat_driver_data->rdistif_num *는 앞의 flush_dcache_range((uintptr_t)(plat_driver_data->rdistif_base_addrs), 결과를 받아 다음 sizeof(*(plat_driver_data->rdistif_base_addrs)));로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

157sizeof(*(plat_driver_data->rdistif_base_addrs)));

원본 157번 줄의 sizeof(*(plat_driver_data->rdistif_base_addrs)));는 앞의 plat_driver_data->rdistif_num * 결과를 받아 다음 #endif로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

158#endif

159}

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

160gicv3_driver_data = plat_driver_data;

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

161(빈 줄)

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

162/*

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

163* The GIC driver data is initialized by the primary CPU with caches

원본 주석이 'The GIC driver data is initialized by the primary CPU with caches'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

164* enabled. When the secondary CPU boots up, it initializes the

원본 주석이 'enabled. When the secondary CPU boots up, it initializes the'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

RELATED SOURCE

함께 읽어야 하는 원본 코드

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

01. 한 CPU의 GIC system-register interface 활성화

drivers/arm/gic/v3/gicv3_main.c 265-355줄이다.

filedrivers/arm/gic/v3/gicv3_main.canchorvoid gicv3_cpuif_enable(unsigned int proc_num)

265void gicv3_rdistif_off(unsigned int proc_num)
266{
267}
268
269void gicv3_rdistif_on(unsigned int proc_num)
270{
271}
272
273/*******************************************************************************
274 * This function enables the GIC CPU interface of the calling CPU using only
275 * system register accesses.
276 ******************************************************************************/
277void gicv3_cpuif_enable(unsigned int proc_num)
278{
279	uintptr_t gicr_base;
280	u_register_t scr_el3;
281	unsigned int icc_sre_el3;
282
283	assert(gicv3_driver_data != NULL);
284	assert(proc_num < gicv3_driver_data->rdistif_num);
285	assert(gicv3_driver_data->rdistif_base_addrs != NULL);
286	assert(IS_IN_EL3());
287
288	/* Mark the connected core as awake */
289	gicr_base = gicv3_driver_data->rdistif_base_addrs[proc_num];
290	gicv3_rdistif_mark_core_awake(gicr_base);
291
292	/* Disable the legacy interrupt bypass */
293	icc_sre_el3 = ICC_SRE_DIB_BIT | ICC_SRE_DFB_BIT;
294
295	/*
296	 * Enable system register access for EL3 and allow lower exception
297	 * levels to configure the same for themselves. If the legacy mode is
298	 * not supported, the SRE bit is RAO/WI
299	 */
300	icc_sre_el3 |= (ICC_SRE_EN_BIT | ICC_SRE_SRE_BIT);
301	write_icc_sre_el3(read_icc_sre_el3() | icc_sre_el3);
302
303	scr_el3 = read_scr_el3();
304
305	/*
306	 * Switch to NS state to write Non secure ICC_SRE_EL1 and
307	 * ICC_SRE_EL2 registers.
308	 */
309	write_scr_el3(scr_el3 | SCR_NS_BIT);
310	isb();
311
312	write_icc_sre_el2(read_icc_sre_el2() | icc_sre_el3);
313	write_icc_sre_el1(ICC_SRE_SRE_BIT);
314	isb();
315
316	/* Switch to secure state. */
317	write_scr_el3(scr_el3 & (~SCR_NS_BIT));
318	isb();
319
320	/* Write the secure ICC_SRE_EL1 register */
321	write_icc_sre_el1(ICC_SRE_SRE_BIT);
322	isb();
323
324	/* Program the idle priority in the PMR */
325	write_icc_pmr_el1(GIC_PRI_MASK);
326
327	/* Enable Group0 interrupts */
328	write_icc_igrpen0_el1(IGRPEN1_EL1_ENABLE_G0_BIT);
329
330	/* Enable Group1 Secure interrupts */
331	write_icc_igrpen1_el3(read_icc_igrpen1_el3() |
332				IGRPEN1_EL3_ENABLE_G1S_BIT);
333	/* and restore the original */
334	write_scr_el3(scr_el3);
335	isb();
336	/* Add DSB to ensure visibility of System register writes */
337	dsb();
338}
339
340/*******************************************************************************
341 * This function disables the GIC CPU interface of the calling CPU using
342 * only system register accesses.
343 ******************************************************************************/
344void gicv3_cpuif_disable(unsigned int proc_num)
345{
346	uintptr_t gicr_base;
347
348	assert(gicv3_driver_data != NULL);
349	assert(proc_num < gicv3_driver_data->rdistif_num);
350	assert(gicv3_driver_data->rdistif_base_addrs != NULL);
351
352	assert(IS_IN_EL3());
353
354	/* Disable legacy interrupt bypass */
355	write_icc_sre_el3(read_icc_sre_el3() |

265-355줄 해설

265void gicv3_rdistif_off(unsigned int proc_num)

gicv3_rdistif_off 함수 정의가 시작된다. 입력은 unsigned int proc_num이며, EL3 initialization and interrupt context에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

266{

267}

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

268(빈 줄)

}까지의 동작과 void gicv3_rdistif_on(unsigned int proc_num)에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

269void gicv3_rdistif_on(unsigned int proc_num)

gicv3_rdistif_on 함수 정의가 시작된다. 입력은 unsigned int proc_num이며, EL3 initialization and interrupt context에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

270{

271}

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

272(빈 줄)

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

273/*******************************************************************************

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

274* This function enables the GIC CPU interface of the calling CPU using only

원본 주석이 'This function enables the GIC CPU interface of the calling CPU using only'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

275* system register accesses.

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

276******************************************************************************/

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

277void gicv3_cpuif_enable(unsigned int proc_num)

gicv3_cpuif_enable 함수 정의가 시작된다. 입력은 unsigned int proc_num이며, EL3 initialization and interrupt context에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

278{

279uintptr_t gicr_base;

원본 279번 줄의 uintptr_t gicr_base;는 앞의 { 결과를 받아 다음 u_register_t scr_el3;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

280u_register_t scr_el3;

원본 280번 줄의 u_register_t scr_el3;는 앞의 uintptr_t gicr_base; 결과를 받아 다음 unsigned int icc_sre_el3;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

281unsigned int icc_sre_el3;

unsigned int icc_sre_el3를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 GICv3 distributor/redistributor state를 직접 소유하는지 pointer만 빌리는지, EL3 initialization and interrupt context를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

282(빈 줄)

unsigned int icc_sre_el3;까지의 동작과 assert(gicv3_driver_data != NULL);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

283assert(gicv3_driver_data != NULL);

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

284assert(proc_num < gicv3_driver_data->rdistif_num);

assert(proc_num < gicv3_driver_data->rdistif_num)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 GICv3 distributor/redistributor state의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SCR routing bits 항목과 대조한다.

285assert(gicv3_driver_data->rdistif_base_addrs != NULL);

assert(gicv3_driver_data->rdistif_base_addrs !에 NULL)를 = 연산으로 반영해 GICv3 distributor/redistributor state와 연결된 field를 갱신한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 interrupt routing 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

286assert(IS_IN_EL3());

287(빈 줄)

assert(IS_IN_EL3());까지의 동작과 /* Mark the connected core as awake */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

288/* Mark the connected core as awake */

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

289gicr_base = gicv3_driver_data->rdistif_base_addrs[proc_num];

gicr_base에 gicv3_driver_data->rdistif_base_addrs[proc_num]를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 바로 다음 gicv3_rdistif_mark_core_awake(gicr_base);가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

290gicv3_rdistif_mark_core_awake(gicr_base);

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

291(빈 줄)

gicv3_rdistif_mark_core_awake(gicr_base);까지의 동작과 /* Disable the legacy interrupt bypass */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

292/* Disable the legacy interrupt bypass */

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

293icc_sre_el3 = ICC_SRE_DIB_BIT | ICC_SRE_DFB_BIT;

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

294(빈 줄)

icc_sre_el3 = ICC_SRE_DIB_BIT | ICC_SRE_DFB_BIT;까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

295/*

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

296* Enable system register access for EL3 and allow lower exception

원본 주석이 'Enable system register access for EL3 and allow lower exception'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

297* levels to configure the same for themselves. If the legacy mode is

원본 주석이 'levels to configure the same for themselves. If the legacy mode is'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

298* not supported, the SRE bit is RAO/WI

원본 주석이 'not supported, the SRE bit is RAO/WI'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

299*/

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

300icc_sre_el3 |= (ICC_SRE_EN_BIT | ICC_SRE_SRE_BIT);

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

301write_icc_sre_el3(read_icc_sre_el3() | icc_sre_el3);

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

302(빈 줄)

write_icc_sre_el3(read_icc_sre_el3() | icc_sre_el3);까지의 동작과 scr_el3 = read_scr_el3();에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

303scr_el3 = read_scr_el3();

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

304(빈 줄)

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

305/*

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

306* Switch to NS state to write Non secure ICC_SRE_EL1 and

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

307* ICC_SRE_EL2 registers.

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

308*/

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

309write_scr_el3(scr_el3 | SCR_NS_BIT);

write_scr_el3(scr_el3 | SCR_NS_BIT)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 GICv3 distributor/redistributor state의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SCR routing bits 항목과 대조한다.

310isb();

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

311(빈 줄)

isb();까지의 동작과 write_icc_sre_el2(read_icc_sre_el2() | icc_sre_el3);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

312write_icc_sre_el2(read_icc_sre_el2() | icc_sre_el3);

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

313write_icc_sre_el1(ICC_SRE_SRE_BIT);

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

314isb();

315(빈 줄)

isb();까지의 동작과 /* Switch to secure state. */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

316/* Switch to secure state. */

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

317write_scr_el3(scr_el3 & (~SCR_NS_BIT));

write_scr_el3(scr_el3 & (~SCR_NS_BIT))를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 GICv3 distributor/redistributor state의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 SCR routing bits 항목과 대조한다.

318isb();

319(빈 줄)

isb();까지의 동작과 /* Write the secure ICC_SRE_EL1 register */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

320/* Write the secure ICC_SRE_EL1 register */

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

321write_icc_sre_el1(ICC_SRE_SRE_BIT);

322isb();

323(빈 줄)

isb();까지의 동작과 /* Program the idle priority in the PMR */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

324/* Program the idle priority in the PMR */

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

325write_icc_pmr_el1(GIC_PRI_MASK);

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

326(빈 줄)

write_icc_pmr_el1(GIC_PRI_MASK);까지의 동작과 /* Enable Group0 interrupts */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

327/* Enable Group0 interrupts */

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

328write_icc_igrpen0_el1(IGRPEN1_EL1_ENABLE_G0_BIT);

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

329(빈 줄)

write_icc_igrpen0_el1(IGRPEN1_EL1_ENABLE_G0_BIT);까지의 동작과 /* Enable Group1 Secure interrupts */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

330/* Enable Group1 Secure interrupts */

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

331write_icc_igrpen1_el3(read_icc_igrpen1_el3() |

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

332IGRPEN1_EL3_ENABLE_G1S_BIT);

원본 332번 줄의 IGRPEN1_EL3_ENABLE_G1S_BIT);는 앞의 write_icc_igrpen1_el3(read_icc_igrpen1_el3() | 결과를 받아 다음 /* and restore the original */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

333/* and restore the original */

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

334write_scr_el3(scr_el3);

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

335isb();

336/* Add DSB to ensure visibility of System register writes */

원본 주석이 'Add DSB to ensure visibility of System register writes'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

337dsb();

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

338}

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

339(빈 줄)

340/*******************************************************************************

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

341* This function disables the GIC CPU interface of the calling CPU using

원본 주석이 'This function disables the GIC CPU interface of the calling CPU using'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

342* only system register accesses.

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

343******************************************************************************/

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

344void gicv3_cpuif_disable(unsigned int proc_num)

gicv3_cpuif_disable 함수 정의가 시작된다. 입력은 unsigned int proc_num이며, EL3 initialization and interrupt context에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

345{

346uintptr_t gicr_base;

원본 346번 줄의 uintptr_t gicr_base;는 앞의 { 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

347(빈 줄)

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

348assert(gicv3_driver_data != NULL);

349assert(proc_num < gicv3_driver_data->rdistif_num);

350assert(gicv3_driver_data->rdistif_base_addrs != NULL);

351(빈 줄)

assert(gicv3_driver_data->rdistif_base_addrs != NULL);까지의 동작과 assert(IS_IN_EL3());에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

352assert(IS_IN_EL3());

353(빈 줄)

assert(IS_IN_EL3());까지의 동작과 /* Disable legacy interrupt bypass */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

354/* Disable legacy interrupt bypass */

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

355write_icc_sre_el3(read_icc_sre_el3() |

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

02. 현재 CPU의 Redistributor와 SGI/PPI 초기화

drivers/arm/gic/v3/gicv3_main.c 217-303줄이다.

filedrivers/arm/gic/v3/gicv3_main.canchorvoid gicv3_rdistif_init(unsigned int proc_num)

217
218	/* Enable the secure (E)SPIs now that they have been configured */
219	gicd_set_ctlr(gicv3_driver_data->gicd_base, bitmap, RWP_TRUE);
220}
221
222/*******************************************************************************
223 * This function initialises the GIC Redistributor interface of the calling CPU
224 * (identified by the 'proc_num' parameter) based upon the data provided by the
225 * platform while initialising the driver.
226 ******************************************************************************/
227void gicv3_rdistif_init(unsigned int proc_num)
228{
229	uintptr_t gicr_base;
230	unsigned int bitmap;
231	uint32_t ctlr;
232
233	assert(gicv3_driver_data != NULL);
234	assert(proc_num < gicv3_driver_data->rdistif_num);
235	assert(gicv3_driver_data->rdistif_base_addrs != NULL);
236	assert(gicv3_driver_data->gicd_base != 0U);
237
238	ctlr = gicd_read_ctlr(gicv3_driver_data->gicd_base);
239	assert((ctlr & CTLR_ARE_S_BIT) != 0U);
240
241	assert(IS_IN_EL3());
242
243	/* Power on redistributor */
244	gicv3_rdistif_on(proc_num);
245
246	gicr_base = gicv3_driver_data->rdistif_base_addrs[proc_num];
247	assert(gicr_base != 0U);
248
249	/* Set the default attribute of all SGIs and (E)PPIs */
250	gicv3_ppi_sgi_config_defaults(gicr_base);
251
252	bitmap = gicv3_secure_ppi_sgi_config_props(gicr_base,
253			gicv3_driver_data->interrupt_props,
254			gicv3_driver_data->interrupt_props_num);
255
256	/* Enable interrupt groups as required, if not already */
257	if ((ctlr & bitmap) != bitmap) {
258		gicd_set_ctlr(gicv3_driver_data->gicd_base, bitmap, RWP_TRUE);
259	}
260}
261
262/*******************************************************************************
263 * Functions to perform power operations on GIC Redistributor
264 ******************************************************************************/
265void gicv3_rdistif_off(unsigned int proc_num)
266{
267}
268
269void gicv3_rdistif_on(unsigned int proc_num)
270{
271}
272
273/*******************************************************************************
274 * This function enables the GIC CPU interface of the calling CPU using only
275 * system register accesses.
276 ******************************************************************************/
277void gicv3_cpuif_enable(unsigned int proc_num)
278{
279	uintptr_t gicr_base;
280	u_register_t scr_el3;
281	unsigned int icc_sre_el3;
282
283	assert(gicv3_driver_data != NULL);
284	assert(proc_num < gicv3_driver_data->rdistif_num);
285	assert(gicv3_driver_data->rdistif_base_addrs != NULL);
286	assert(IS_IN_EL3());
287
288	/* Mark the connected core as awake */
289	gicr_base = gicv3_driver_data->rdistif_base_addrs[proc_num];
290	gicv3_rdistif_mark_core_awake(gicr_base);
291
292	/* Disable the legacy interrupt bypass */
293	icc_sre_el3 = ICC_SRE_DIB_BIT | ICC_SRE_DFB_BIT;
294
295	/*
296	 * Enable system register access for EL3 and allow lower exception
297	 * levels to configure the same for themselves. If the legacy mode is
298	 * not supported, the SRE bit is RAO/WI
299	 */
300	icc_sre_el3 |= (ICC_SRE_EN_BIT | ICC_SRE_SRE_BIT);
301	write_icc_sre_el3(read_icc_sre_el3() | icc_sre_el3);
302
303	scr_el3 = read_scr_el3();

217-303줄 해설

217(빈 줄)

이전 block 경계까지의 동작과 /* Enable the secure (E)SPIs now that they have been configured */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 gicv3_driver_data_t 상태가 아래 블록의 입력으로 사용되는 경계다.

218/* Enable the secure (E)SPIs now that they have been configured */

원본 주석이 'Enable the secure (E)SPIs now that they have been configured'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

219gicd_set_ctlr(gicv3_driver_data->gicd_base, bitmap, RWP_TRUE);

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

220}

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

221(빈 줄)

222/*******************************************************************************

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

223* This function initialises the GIC Redistributor interface of the calling CPU

원본 주석이 'This function initialises the GIC Redistributor interface of the calling CPU'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

224* (identified by the 'proc_num' parameter) based upon the data provided by the

원본 주석이 '(identified by the 'proc_num' parameter) based upon the data provided by the'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

225* platform while initialising the driver.

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

226******************************************************************************/

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

227void gicv3_rdistif_init(unsigned int proc_num)

gicv3_rdistif_init 함수 정의가 시작된다. 입력은 unsigned int proc_num이며, EL3 initialization and interrupt context에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

228{

229uintptr_t gicr_base;

원본 229번 줄의 uintptr_t gicr_base;는 앞의 { 결과를 받아 다음 unsigned int bitmap;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

230unsigned int bitmap;

unsigned int bitmap를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 GICv3 distributor/redistributor state를 직접 소유하는지 pointer만 빌리는지, EL3 initialization and interrupt context를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

231uint32_t ctlr;

원본 231번 줄의 uint32_t ctlr;는 앞의 unsigned int bitmap; 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

232(빈 줄)

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

233assert(gicv3_driver_data != NULL);

234assert(proc_num < gicv3_driver_data->rdistif_num);

235assert(gicv3_driver_data->rdistif_base_addrs != NULL);

236assert(gicv3_driver_data->gicd_base != 0U);

assert(gicv3_driver_data->gicd_base !에 0U)를 = 연산으로 반영해 GICv3 distributor/redistributor state와 연결된 field를 갱신한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 interrupt routing 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

237(빈 줄)

assert(gicv3_driver_data->gicd_base != 0U);까지의 동작과 ctlr = gicd_read_ctlr(gicv3_driver_data->gicd_base);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

238ctlr = gicd_read_ctlr(gicv3_driver_data->gicd_base);

ctlr에 gicd_read_ctlr(gicv3_driver_data->gicd_base)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 바로 다음 assert((ctlr & CTLR_ARE_S_BIT) != 0U);가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

239assert((ctlr & CTLR_ARE_S_BIT) != 0U);

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

240(빈 줄)

assert((ctlr & CTLR_ARE_S_BIT) != 0U);까지의 동작과 assert(IS_IN_EL3());에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

241assert(IS_IN_EL3());

242(빈 줄)

assert(IS_IN_EL3());까지의 동작과 /* Power on redistributor */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

243/* Power on redistributor */

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

244gicv3_rdistif_on(proc_num);

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

245(빈 줄)

gicv3_rdistif_on(proc_num);까지의 동작과 gicr_base = gicv3_driver_data->rdistif_base_addrs[proc_num];에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

246gicr_base = gicv3_driver_data->rdistif_base_addrs[proc_num];

gicr_base에 gicv3_driver_data->rdistif_base_addrs[proc_num]를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 바로 다음 assert(gicr_base != 0U);가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

247assert(gicr_base != 0U);

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

248(빈 줄)

assert(gicr_base != 0U);까지의 동작과 /* Set the default attribute of all SGIs and (E)PPIs */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

249/* Set the default attribute of all SGIs and (E)PPIs */

원본 주석이 'Set the default attribute of all SGIs and (E)PPIs'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

250gicv3_ppi_sgi_config_defaults(gicr_base);

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

251(빈 줄)

gicv3_ppi_sgi_config_defaults(gicr_base);까지의 동작과 bitmap = gicv3_secure_ppi_sgi_config_props(gicr_base,에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

252bitmap = gicv3_secure_ppi_sgi_config_props(gicr_base,

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

253gicv3_driver_data->interrupt_props,

원본 253번 줄의 gicv3_driver_data->interrupt_props,는 앞의 bitmap = gicv3_secure_ppi_sgi_config_props(gicr_base, 결과를 받아 다음 gicv3_driver_data->interrupt_props_num);로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

254gicv3_driver_data->interrupt_props_num);

원본 254번 줄의 gicv3_driver_data->interrupt_props_num);는 앞의 gicv3_driver_data->interrupt_props, 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건이 유지되는지 확인한다.

255(빈 줄)

gicv3_driver_data->interrupt_props_num);까지의 동작과 /* Enable interrupt groups as required, if not already */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 SCR routing bits 상태가 아래 블록의 입력으로 사용되는 경계다.

256/* Enable interrupt groups as required, if not already */

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

257if ((ctlr & bitmap) != bitmap) {

(ctlr & bitmap) != bitmap를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

258gicd_set_ctlr(gicv3_driver_data->gicd_base, bitmap, RWP_TRUE);

259}

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

260}

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

261(빈 줄)

262/*******************************************************************************

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

263* Functions to perform power operations on GIC Redistributor

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

264******************************************************************************/

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

265void gicv3_rdistif_off(unsigned int proc_num)

266{

267}

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

268(빈 줄)

269void gicv3_rdistif_on(unsigned int proc_num)

270{

271}

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

272(빈 줄)

273/*******************************************************************************

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

274* This function enables the GIC CPU interface of the calling CPU using only

275* system register accesses.

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

276******************************************************************************/

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

277void gicv3_cpuif_enable(unsigned int proc_num)

278{

279uintptr_t gicr_base;

280u_register_t scr_el3;

281unsigned int icc_sre_el3;

282(빈 줄)

283assert(gicv3_driver_data != NULL);

284assert(proc_num < gicv3_driver_data->rdistif_num);

285assert(gicv3_driver_data->rdistif_base_addrs != NULL);

286assert(IS_IN_EL3());

287(빈 줄)

288/* Mark the connected core as awake */

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

289gicr_base = gicv3_driver_data->rdistif_base_addrs[proc_num];

290gicv3_rdistif_mark_core_awake(gicr_base);

291(빈 줄)

292/* Disable the legacy interrupt bypass */

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

293icc_sre_el3 = ICC_SRE_DIB_BIT | ICC_SRE_DFB_BIT;

294(빈 줄)

295/*

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

296* Enable system register access for EL3 and allow lower exception

297* levels to configure the same for themselves. If the legacy mode is

298* not supported, the SRE bit is RAO/WI

원본 주석이 'not supported, the SRE bit is RAO/WI'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

299*/

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

300icc_sre_el3 |= (ICC_SRE_EN_BIT | ICC_SRE_SRE_BIT);

301write_icc_sre_el3(read_icc_sre_el3() | icc_sre_el3);

302(빈 줄)

303scr_el3 = read_scr_el3();

DETAILS

내부 동작을 더 깊게 읽기

진입 조건을 먼저 고정한다

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

interrupt ID만 보지 말고 group, priority, security state, route target과 EOI/deactivate 책임을 함께 본다.

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

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

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

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

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

secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다.

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

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

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

마지막 handoff의 계약을 적는다

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

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

IMPLEMENTATION NOTES

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

platform GIC data에서 interrupt routing까지 제어권이 이동하는 조건

Distributor, Redistributor와 CPU interface를 초기화하고 secure interrupt를 EL3 또는 S-EL1로 라우팅하는 경로를 읽습니다. 이 경로는 함수 호출 목록만 외워서는 연결되지 않는다. platform GIC data → Distributor init → Redistributor discover → CPU interface → interrupt routing 순서에서 각 단계가 읽는 입력, 새로 확정하는 상태, 다음 단계에 넘기는 값을 구분해야 한다. 특히 EL3 initialization and interrupt context에서는 이전 단계가 남긴 register와 memory attribute가 C 코드의 전제 조건이 된다.

interrupt ID만 보지 말고 group, priority, security state, route target과 EOI/deactivate 책임을 함께 본다. 따라서 첫 지점에서 GICv3 distributor/redistributor state의 주소와 owner를 기록하고, 마지막 지점에서 같은 값이 그대로 유지되는지 아니면 새 객체로 교체되는지를 확인한다. 중간 함수가 성공을 반환해도 secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다.

gicv3_driver_data_t와 SCR routing bits의 생성 시점과 수명

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

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

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

대표적인 실패 조건은 GICR affinity 불일치: secondary CPU interrupt 없음; group 오설정: Normal World 노출; EOI 누락: interrupt 재진입/정지이다. 이 문제들은 대개 fault가 발생한 함수보다 앞에서 만들어진 잘못된 주소, size, security state 또는 refcount 때문에 생긴다. 마지막 출력만 보지 말고 각 경계 직전의 상태를 한 줄씩 남겨 최초 불일치 지점을 찾는다.

재현에는 GICD IGROUPR/IGRPMODR dump; secure timer interrupt route 변경; secondary CPU의 GICR base와 MPIDR 대조를 사용한다. 정상 경로와 실패 경로에서 같은 필드를 같은 위치에 출력하고, 실패가 검증 단계에서 차단되는지 아니면 다음 context까지 전파되는지 비교한다. firmware와 secure world에서는 실패 뒤의 cleanup 또는 reset 경로도 정상 경로만큼 중요하다.

DEEP ANALYSIS

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

GICv3 초기화는 Distributor base를 쓰는 하나의 루틴이 아니다. GICD는 전역 interrupt group과 routing을, 각 GICR frame은 CPU별 SGI/PPI와 redistributor state를, ICC_* system register는 현재 PE의 CPU interface를 담당한다.

secure interrupt 경로를 이해하려면 interrupt group, priority, route target, SCR_EL3의 IRQ/FIQ routing, SPD가 기대하는 secure interrupt model을 동시에 봐야 한다. 한 요소만 맞아도 interrupt가 pending 상태에 머물거나 다른 world에서 acknowledge될 수 있다.

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

01GICD/GICR base

MMIO 범위와 frame stride가 실제 SoC memory map과 일치해야 한다.

02rdistif_num/MPIDR hash

각 PE가 정확히 하나의 GICR_TYPER affinity와 대응해야 한다.

03interrupt property array

ID, group, priority, configuration이 유효해야 한다.

04ICC_SRE_EL3

system register interface enable bit가 EL3/하위 EL 정책과 맞아야 한다.

05SCR_EL3 routing

FIQ/IRQ routing이 interrupt group과 SPD model을 일관되게 EL3로 보낸다.

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

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

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

#	입력 상태	생산자	정상 조건	확인 이유
01	`GICD/GICR base`	platform gicv3_driver_data	MMIO 범위와 frame stride가 실제 SoC memory map과 일치해야 한다.	모든 distributor/redistributor 접근의 기준이다.
02	`rdistif_num/MPIDR hash`	platform topology	각 PE가 정확히 하나의 GICR_TYPER affinity와 대응해야 한다.	secondary CPU interface 초기화 대상을 찾는다.
03	`interrupt property array`	platform secure interrupt list	ID, group, priority, configuration이 유효해야 한다.	Group0/Group1S/Group1NS 분류를 만든다.
04	`ICC_SRE_EL3`	CPU interface init	system register interface enable bit가 EL3/하위 EL 정책과 맞아야 한다.	ICC_* register 접근 가능 여부를 결정한다.
05	`SCR_EL3 routing`	context management	FIQ/IRQ routing이 interrupt group과 SPD model을 일관되게 EL3로 보낸다.	어느 vector가 interrupt를 받는지 결정한다.

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

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

#	객체 또는 필드	생산자	소비자	수명과 불변 조건
01	`gicv3_driver_data_t`	platform setup	GICv3 common driver	BL31 runtime 동안 유지되며 base와 callback table이 유효해야 한다.
02	`GICD group/config/route registers`	driver init	hardware distributor	global interrupt policy로 reset 또는 명시적 변경까지 유지된다.
03	`GICR frame state`	per-CPU init	local SGI/PPI delivery	CPU power cycle마다 sleep/wake와 enable 복원이 필요하다.
04	`ICC_PMR/BPR/IGRPEN`	CPU interface enable	current PE interrupt selection	CPU별 state이며 world switch/power management 정책과 맞아야 한다.
05	`pending/active interrupt`	hardware acknowledge	EL3/SPD/OS handler	EOI와 deactivate가 완료될 때까지 동일 interrupt owner가 관리한다.
06	`interrupt property descriptors`	platform constant table	driver init	초기화 때 소비되지만 runtime 재설정이 있으면 resident 수명을 확인한다.

함수 내부 실행 순서

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

01
platform이 GICD base, GICR region, MPIDR-to-core callback과 secure interrupt property를 등록한다.
02
driver가 GIC architecture version과 frame 정보를 검증하고 redistributor를 affinity별로 탐색한다.
03
primary CPU가 Distributor를 disable/정규화하고 group, priority, configuration, route를 설정한다.
04
각 CPU가 자신의 GICR frame을 wake하고 SGI/PPI group과 enable state를 초기화한다.
05
ICC_SRE_EL3와 CPU interface register를 설정하고 priority mask와 binary point를 정한다.
06
Group0/Group1S enable과 SCR_EL3 routing을 secure payload dispatcher 모델에 맞춘다.
07
interrupt 발생 시 IAR에서 ID를 읽고 group/owner에 따라 EL3 handler 또는 secure payload로 전달한다.
08
handler completion 뒤 EOIR과 필요 시 DIR을 올바른 순서로 써 active state를 해제한다.
09
CPU suspend/hotplug 경로에서 redistributor와 CPU interface state를 저장·복원한다.

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

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

#	설정	바뀌는 동작	확인 방법
01	`GICV3_SUPPORT_GIC600 계열 workaround`	특정 구현 erratum과 register sequence를 추가한다.	SoC GIC revision과 적용 workaround를 기록한다.
02	`GICV3_IMPL_GIC600_MULTICHIP`	multi-chip routing/register 구성이 추가된다.	chip address와 SPI route 범위를 확인한다.
03	`EL3_EXCEPTION_HANDLING`	EL3 interrupt framework가 직접 secure interrupt를 처리할 수 있다.	등록 handler와 SCR routing을 함께 본다.
04	`SPD interrupt model`	secure interrupt를 EL3에서 넘기는 방식이 달라진다.	Group 설정과 dispatcher의 interrupt entry를 대조한다.

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

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

#	관찰 증상	중단 위치	기록할 값	판정
01	SPI가 pending인데 CPU에 오지 않음	`GICD pending/route와 CPU IAR`	group, enable, route MPIDR, PMR	Distributor routing과 CPU priority mask를 순서대로 확인한다.
02	secondary CPU에서 PPI만 없음	`gicv3_rdistif_init`	GICR_TYPER affinity, WAKER, PPI enable	redistributor frame 매핑 오류를 찾는다.
03	secure timer가 Linux IRQ로 보임	`group configuration과 SCR`	IGROUPR/IGRPMODR, SCR IRQ/FIQ	group 분류와 EL3 routing 중 불일치 지점을 판정한다.
04	한 번 처리한 interrupt가 계속 재진입	`handler exit`	IAR ID, EOIR/DIR write, active bit	EOI mode와 deactivate 누락을 확인한다.

OBJECT LIFETIME

객체와 수명

대상	만들어지는 시점	유효 범위	확인할 조건
`GICv3 distributor/redistributor state`	Distributor init	interrupt routing 또는 오류 정리 완료까지	secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다.
입력 buffer / metadata	platform GIC data	parse와 검증이 끝날 때까지	길이, 정렬, 소유권, 변조 가능성
등록된 list / descriptor	Redistributor discover	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	GICR affinity 불일치	secondary CPU interrupt 없음	Distributor init
02	group 오설정	Normal World 노출	Redistributor discover
03	EOI 누락	interrupt 재진입/정지	CPU interface

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

EVIDENCE

소스 밖에서 확인할 증거

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

#	목적	명령 또는 계측	판정 기준
01	빌드 산출물	`make PLAT=<platform> DEBUG=1 all fip`	BL1, BL2, BL31과 FIP가 같은 설정으로 만들어졌는지 전체 빌드 명령부터 기록한다.
02	FIP 구성	`tools/fiptool/fiptool info build/<platform>/debug/fip.bin`	FIP 안의 BL31, BL32, BL33 UUID와 offset, 크기를 확인해 실제 적재 입력을 고정한다.
03	심볼과 주소	`${CROSS_COMPILE}nm -n build/<platform>/debug/bl31/bl31.elf \| grep 'void __init gicv3_driver_init'`	대상 함수가 BL31의 어느 주소와 섹션에 놓였는지 확인한다.
04	EL3 명령 추적	`${CROSS_COMPILE}objdump -drS build/<platform>/debug/bl31/bl31.elf`	C 코드가 EL3 system register 접근과 eret 경로로 어떻게 번역됐는지 대조한다.
05	실행 시점 증거	`TF-A DEBUG log + CurrentEL/SCR_EL3/SPSR_EL3/x0-x3 기록`	어느 exception level에서 어떤 security state와 인자를 다음 이미지에 넘겼는지 serial log로 남긴다.

LAB

직접 확인할 실험

01
GICD IGROUPR/IGRPMODR dump
Distributor init 진입 전후에 gicv3_driver_data_t의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다. 조건이 처음 깨지는 줄을 기록한다.
02
secure timer interrupt route 변경
Redistributor discover 진입 전후에 GICD/GICR frames의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다. 조건이 처음 깨지는 줄을 기록한다.
03
secondary CPU의 GICR base와 MPIDR 대조
CPU interface 진입 전후에 interrupt group의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 secure interrupt는 설정된 group과 routing model에 따라 한 security state의 handler로만 전달되고 CPU interface enable 순서가 지켜져야 한다. 조건이 처음 깨지는 줄을 기록한다.

PRIMARY REFERENCES

원문과 다음 글

drivers/arm/gic/v3/gicv3_main.cLTS 2.14.3 원본 파일 Trusted Firmware-A source tree기준 commit f5e765a3443f