ARM Cortex-A 페이징

페이징

ARM Cortex-A 페이징

• Supersection: 16MB 크기를 가진 페이지입니다. (1단계 페이징)

• Section: 1MB 크기를 가진 페이지입니다. (1단계 페이징)

• Large Page: 64KB 크기를 가진 페이지입니다. (2단계 페이징)

• Small Page: 4KB 크기를 가진 페이지입니다. (2단계 페이징)

1 단계 페이징

0x4000(TTBA) + 0xC00(L1 Page Table Index) = 0x4C00(L1 Page Table Entry)

0x100000(Base Address) + 0x01000(Offset) = 0x101000(Physical Address)

• Section/Supersection Base Address:1MB/16MB 페이지 프레임의 물리 주소를 나타냅니다.

• SBZ: Should Be Zero. 0

• NG: Not Global. 글로벌 메모리 여부를 설정합니다. TLB 플러쉬 정책과 관련있습니다.

• S: Shareable. 메모리 속성에 따라 공유 가능여부를 설정합니다.

• APX/AP: Access Permission, 접근 권한을 설정하는 필드 입니다.

• TEX: Type extension. 메모리 속성 설정에 사용됩니다.

• P: Present. 운영체제 커널과 같은 시스템 소프트웨어에서 사용하는 필드입니다. 주로 스와핑에 사용됩니다.

• Domain: 도메인을 설정합니다. 메모리는 도메인별로 접근 권한 확인 여부를 설정할 수 있습니다. No access, Client, Manager 세가지 타입으로 설정가능하며 총 16개 도메인이 존재합니다.

• XN: Execute-Never 비트. CPU는 해당 메모리의 코드가 실행 가능한지 결정합니다.

• C: Cacheable. 메모리 속성 설정에 사용됩니다.

• B: Bufferable. 메모리 속성 설정에 사용됩니다.

• [코드 1] L1 페이지 테이블 엔트리 자료 구조 선언 <paging.h>

/* L1 Page table entry. */
typedef union {
    struct {
        u32 fixed:5;    /* {0,0,0,0,1} */
        u32 domain:4;   /* Memory protection domain info. */
        u32 p:1;        /* ECC enable. Should be zero. */
        u32 base:22;    /* L2 page table base address. */
    }__attribute__((__packed__)) pt; /* Page table */
    struct {
        u32 fixed:2;    /* {1,0}*/
        u32 b:1;        /* Buffer */
        u32 c:1;        /* Cache */
        u32 xn:1;       /* Execute never */
        u32 domain:4;   /* Domain for memory regions */
        u32 p:1;        /* Implementation Defined */
        u32 ap:2;       /* Access Permission */
        u32 tex:3;      /* Type Extension */
        u32 apx:1;      /* Access Permission 2 */
        u32 s:1;        /* Shareable */
        u32 ng:1;       /* Not Global */
        u32 sbz:2;      /* 0 */
        u32 base:12;    
    }__attribute__((__packed__)) s; /* Section */
    struct {
        u32 fixed:2;    /* {1,0} */
        u32 b:1;        /* Buffer */
        u32 c:1;        /* Cache */
        u32 xn:1;       /* Execute nerver */
        u32 domain:4;   /* Domain for memory regions */
        u32 p:1;        /* Implementation Defined */
        u32 ap:2;       /* Access Permission */
        u32 tex:3;      /* Type Extecsion */
        u32 apx:1;      /* Access Permission 2 */
        u32 s:1;        /* Shareable */
        u32 ng:1;       /* Not Global */
        u32 _1:1;       /* 1 */
        u32 sbz:5;      /* 0 */
        u32 base:8;     /* Base address */
    }__attribute__((__packed__)) ss; /* Supersection */
    u32 entry;
} l1_pte_t;

• [코드 2] L1 페이지 테이블 엔트리 설정 <paging.c>

#include <paging.h>
#include <stdlib.h>
#define L1_PT_SIZE (4*4096)      /* 페이지 테이블 엔트리 (크기)x(갯수) */
#define PAGE_SIZE  (0x100000)    /* Section 크기(1MB) */
#define MEM_SIZE   (0x40000000)  /* 메모리 크기(1GB) */
#define VIRT_START (0xC0000000)  /* 가상 메모리 시작 주소 */
#define PHY_START  (0x0)         /* 물리 메모리 시작 주소 */
void create_l1_pt(l1_pte_t *pt, u32 vaddr, u32 paddr, u32 page_size, u32 size)
{
    int i;
    char *base = (char *)pt;
    int offset = vaddr >> 20; /* 첫번째 페이지 테이블 엔트리 오프셋 */

         /* 매핑 할 메모리 크기 만큼의 L1 페이지 테이블 엔트리들을 설정 합니다. */
    for (i=0; i<size; i+=page_size, ++offset) {
        pt[offset].s.base   = (paddr+i)>>20; /* Page Frame base address*/
        pt[offset].s.sbz    = 0x0; /* 0 */
        pt[offset].s.ng     = 0x0; /* Not Global */
        pt[offset].s.s      = 0x0; /* Shareable */
        pt[offset].s.apx    = 0x0; /* Access Permission 2 */
        pt[offset].s.tex    = 0x0; /* Type Extension */
        pt[offset].s.ap     = 0x3; /* Access Permission */
        pt[offset].s.p      = 0x0; /* Implementation Defined */
        pt[offset].s.domain = 0x0; /* Domain for memory regions */
        pt[offset].s.xn     = 0x0; /* Execute never */
        pt[offset].s.c      = 0x0; /* Cache */
        pt[offset].s.b      = 0x0; /* Buffer */
        pt[offset].s.fixed  = 0x2; /* {1,0} */
    }
}
int main(void)
{
    l1_pte_t *l1_pt;
     
    /* L1 페이지 테이블 메모리 공간을 할당합니다. */
    l1_pt = (l1_pte_t *)malloc(L1_PT_SIZE);
    bzero(l1_pt, L1_PT_SIZE);
    /* L1 페이지 테이블을 구축합니다. */
    create_l1_pt(l1_pt, 0xC0000000, 0x0, PAGE_SIZE, MEM_SIZE);
    /* MMU를 활성화하여 가상 주소 사용을 시작합니다. */
    enable_paging(l1_pt);     
    /* 이제부터 물리 주소 0번지는 가상 주소 0xC0000000번지에 선형 매핑되었습니다. */
    /* Do something... */
    return 0;
}

/* Base|ss|tex|ap|bc|fixed */
pt[offset].entry = (paddr+i)|(0x0<<18)|(0x0<<12)|(0x3<<10)|0x0<<2)|0x2;

• [코드 3] 페이징 활성화 <paging.S>

.global enable_paging
.type   enable_paging, %function
.align  4
enable_paging:
    @ 페이징 활성화를 하기전에 TLB를 플러쉬 합니다.
    mov     r1, #0x0
    mcr     p15, 0, r1, c8, c7, 0

    @ TTBCR(Translation Table Base Control Register)을 설정합니다.
    mcr     p15, 0, r1, c2, c0, 2

         @ 도메인 접근 권한을 설정합니다.
    ldr     r1, =0xffffffff
    mcr     p15, 0, r1, c3, c0, 0

    @ TTBR(Translation Table Base Register) 0에 인자로 받은 L1 페이지 테이블의
    @ 시작 주소(TTBA)를 설정합니다.
    mcr     p15, 0, r0, c2, c0, 0
        
    @ SCTLR(System Control Register)에서 MMU를 활성화하여 가상 주소를 사용합니다.
    mrc     p15, 0, r0, c1, c0, 0
    orr     r0, r0, #0x1 
    mcr     p15, 0, r0, c1, c0, 0
    mov     pc, lr

2단계 페이징

• 가상 주소 = 0xC0010010

• 물리 주소 = 0x00010010

• L1 페이지 테이블 시작 주소 = 0x4000

• L2 페이지 테이블 시작 주소 = 0x9000

0x4000(TTBA) + 0xC00(L1 PT Index) = 0x4C00(L1 Page Table Entry)

0x9000(L2 Page Table Base) + 0x10(L2 PT Index) = 0x9010(L2 Page Table Entry)

0x10000(Page Frame Base) + 0x10(Page Frame Index) = 0x10010(Physical Address)

메모리 속성

• Strongly-ordered: CPU로 부터 순차적으로 메모리 접근을 보장합니다. 캐싱(C)과 버퍼링(B)를 하지 않습니다.

• Device: ARM은 MMIO을 사용하므로 해당 메모리 주소 영역이 디바이스 I/O 주소를 의미합니다.

• Normal: 데이터를 저장하는 일반적인 메모리를 의미합니다.

도메인

mrc    p15, 0, <Rt>, c3, c0, 0 ; DACR 값을 Rt에 읽어옵니다.
mcr    p15, 0, <Rt>, c3, c0, 0 ; Rt 값을 DACR에 설정합니다.

• 0b00: No access. 해당 도메인에 접근하면 도메인 폴트(Domain Fault)가 발생합니다.

• 0b01: Client. 페이지 테이블 엔트리의 접근 권한을 체크합니다.

• 0b10: Resesrved.

• 0b11: Manager. 페이지 테이블 엔트리의 접근 권한을 체크하지 않습니다.

접근 권한

참고자료