LK · source analysis

PMM과 VMM의 page 소유권

vmm_alloc()·vmm_alloc_contiguous()의 PMM 소유 page와 vmm_alloc_physical()의 외부 paddr를 다른 경로로 읽습니다.

LK commit 1eb9917의 kernel/vm/pmm.c와 vmm.c를 기준으로 한다. page 소유권, virtual region, MMU mapping, 아키텍처별 TLB 처리를 같은 단계로 합치지 않는다.

Series
10 / 20
Baseline
upstream 1eb9917
Commit
1eb99171efae
Source
kernel/vm/pmm.c:38-126 (발췌 범위)

VMM 매핑은 언제 PMM page를 소유하고 언제 외부 paddr만 가리키는가?

vmm_alloc()은 pmm_alloc_pages(), vmm_alloc_contiguous()는 pmm_alloc_contiguous()로 물리 page를 먼저 확보한다. region을 만들고 arch_mmu_map()이 성공하면 page를 region의 page_list에 옮긴다.

vmm_alloc_physical()은 호출자가 넘긴 정렬된 paddr로 region을 만들고 직접 map한다. 이 함수에는 PMM page 할당이 없고 region의 page_list에 소유 page도 추가하지 않는다. 따라서 모든 mapping의 앞에 PMM allocation을 그릴 수 없다.

분석 경계

고정 LittleKernel commit 1eb9917의 PMM, VMM 구현이다. arch_mmu_flags는 mapping 인자로 전달되지만 PTE·TLB 세부는 해당 아키텍처 구현을 확인해야 한다.

page 소유권과 주소 매핑의 객체

그림 1. PMM, VMM region, architecture MMU의 경계
물리 주소·pagevirtual regionMMU mapping
01PMM arena·vm_page_t
02PMM 소유 page 또는 외부 paddr
03aspace의 vmm_region_t
04arch_mmu_map(..., flags)
소유권

page_list에 들어간 PMM page만 vmm_free_region()의 pmm_free() 대상이다. 외부 paddr 매핑은 이 list를 채우지 않는다.

pmm_add_arena()는 arena의 page metadata와 free list를 준비한다. VMM의 virtual region은 그 뒤 모든 호출에서 같은 방식으로 생기지만, 물리 page를 가져오는 방식은 API마다 다르다.

PMM 소유 할당과 외부 paddr 매핑의 두 경로

그림 2. 세 VMM API의 물리 주소 출처

PMM 소유 경로 — vmm_alloc()은 흩어진 page를, vmm_alloc_contiguous()는 연속 run을 먼저 확보한다.

vmm_alloc()
vmm_alloc_contiguous()
pmm_alloc_pages()
pmm_alloc_contiguous()
alloc_region
arch_mmu_map
region page_list

외부 주소 경로 — vmm_alloc_physical()은 호출자가 제공한 paddr를 그대로 사용한다.

caller paddr
vmm_alloc_physical
alloc_region
arch_mmu_map
빈 page_list

두 경로 모두 arch_mmu_flags를 region 기록과 mapping 호출에 넘긴다. generic vmm.c에는 mapping 뒤의 독립된 무조건 TLB 단계가 없다.

각 API가 실제로 바꾸는 상태

페이지 수명과 mapping 수명을 함수별로 추적한다. arch_mmu_map() 성공 뒤의 반환 값과 해제 시 page_list를 함께 본다.

여기서 map의 성공 분기는 arch_mmu_map() 반환값이 음수인지 검사한 결과다. vmm_alloc()에는 0과 1 반환 규약을 정리해야 한다는 TODO가 남아 있으며, 이 호출부는 모든 architecture에서 기대한 page 수만큼 매핑됐는지를 별도로 검사하지 않는다. ARM64 구현은 정상 map 뒤 0을 반환한다. 이 소스 경계를 실제 mapping 완전성이나 모든 architecture의 같은 반환 규약으로 확대하지 않는다. VMM의 음수 검사 · ARM64 map 반환.

#함수·조건물리 주소·pageVMM·MMU 변화해제 시점
01pmm_add_arena()boot_alloc_mem()으로 metadata 배열, free list 구성VMM mapping 없음이 함수는 page 할당 API가 아님
02vmm_alloc()pmm_alloc_pages()로 여러 page 확보region 후 page별 arch_mmu_map(...,1,flags)성공 page를 region list에 넣음
03vmm_alloc_contiguous()pmm_alloc_contiguous()로 물리 연속 runregion 후 한 번에 arch_mmu_map(...,count,flags)성공 run의 page list 이전
04vmm_alloc_physical()호출자 paddr 사용; PMM 할당 없음region 후 arch_mmu_map(...,paddr,count,flags)외부 paddr의 PMM 소유권 변화 없음
05vmm_free_region()pmm_free(&r->page_list)region 제거 중 arch_mmu_unmap()list가 빈 외부 매핑은 반환 page 없음

vmm_alloc_physical()도 VMM_REGION_FLAG_PHYSICAL region을 만든다. 이 flag만으로 PMM page를 새로 소유했다고 판단하지 말고 region의 page_list와 호출 API를 보아야 한다.

할당·매핑·해제에서 갈리는 책임

그림 3은 PMM이 page를 제공하는 두 API의 경로다. 그림 4는 같은 paddr라도 region의 mapping 속성과 물리 page 소유권이 다름을 보여 준다.

그림 3. vmm_alloc()·vmm_alloc_contiguous()의 PMM 소유 경로

PMM allocation은 이 두 API에서 region과 MMU map보다 앞선다.

01PMM page 또는 run 확보
02alloc_region()으로 VA 선택
03arch_mmu_map(...,flags)
04성공 page를 r->page_list로
05매핑된 VA 반환
그림 4. 물리 주소 출처와 virtual mapping 속성

물리 page가 PMM 소유인지와 mapping의 cache·permission flag는 다른 질문이다.

Physical page / paddr

01PMM page 또는 caller paddr

02PMM 소유 시 region page_list에 보관

03외부 paddr map은 PMM 새 할당 없음

04해제·재사용 책임은 출처에 따름

Virtual region / mapping

01aspace의 VA region 선택

02arch_mmu_flags를 region에 기록

03같은 flags를 arch_mmu_map()에 전달

04cache·permission 해석은 arch 구현

원본 코드

아래 코드는 LK upstream 1eb9917의 kernel/vm/pmm.c에서 38-126줄을 그대로 가져온 것이다.

commit1eb99171efae98867d4be4a5bd6479ea03f43ac9anchor · L62status_t pmm_add_arena(pmm_arena_t *arena)
38    return !(page->flags & VM_PAGE_FLAG_NONFREE);
39}
40
41paddr_t vm_page_to_paddr(const vm_page_t *page) {
42    pmm_arena_t *a;
43    list_for_every_entry(&arena_list, a, pmm_arena_t, node) {
44        if (PAGE_BELONGS_TO_ARENA(page, a)) {
45            return PAGE_ADDRESS_FROM_ARENA(page, a);
46        }
47    }
48    return -1;
49}
50
51vm_page_t *paddr_to_vm_page(paddr_t addr) {
52    pmm_arena_t *a;
53    list_for_every_entry(&arena_list, a, pmm_arena_t, node) {
54        if (addr >= a->base && addr <= a->base + a->size - 1) {
55            size_t index = (addr - a->base) / PAGE_SIZE;
56            return &a->page_array[index];
57        }
58    }
59    return NULL;
60}
61
62status_t pmm_add_arena(pmm_arena_t *arena) {
63    LTRACEF("arena %p name '%s' base 0x%lx size 0x%zx\n", arena, arena->name, arena->base, arena->size);
64
65    DEBUG_ASSERT(IS_PAGE_ALIGNED(arena->base));
66    DEBUG_ASSERT(IS_PAGE_ALIGNED(arena->size));
67    DEBUG_ASSERT(arena->size > 0);
68
69    /* walk the arena list and add arena based on priority order */
70    pmm_arena_t *a;
71    list_for_every_entry(&arena_list, a, pmm_arena_t, node) {
72        if (a->priority > arena->priority) {
73            list_add_before(&a->node, &arena->node);
74            goto done_add;
75        }
76    }
77
78    /* walked off the end, add it to the end of the list */
79    list_add_tail(&arena_list, &arena->node);
80
81done_add:
82
83    /* zero out some of the structure */
84    arena->free_count = 0;
85    list_initialize(&arena->free_list);
86
87    /* allocate an array of pages to back this one */
88    size_t page_count = arena->size / PAGE_SIZE;
89    arena->page_array = boot_alloc_mem(page_count * sizeof(vm_page_t));
90
91    /* initialize all of the pages */
92    memset(arena->page_array, 0, page_count * sizeof(vm_page_t));
93
94    /* add them to the free list */
95    for (size_t i = 0; i < page_count; i++) {
96        vm_page_t *p = &arena->page_array[i];
97
98        list_add_tail(&arena->free_list, &p->node);
99
100        arena->free_count++;
101    }
102
103    return NO_ERROR;
104}
105
106size_t pmm_alloc_pages(uint count, struct list_node *list) {
107    LTRACEF("count %u\n", count);
108
109    /* list must be initialized prior to calling this */
110    DEBUG_ASSERT(list);
111
112    uint allocated = 0;
113    if (count == 0)
114        return 0;
115
116    mutex_acquire(&lock);
117
118    /* walk the arenas in order, allocating as many pages as we can from each */
119    pmm_arena_t *a;
120    list_for_every_entry(&arena_list, a, pmm_arena_t, node) {
121        while (allocated < count && a->free_count > 0) {
122            vm_page_t *page = list_remove_head_type(&a->free_list, vm_page_t, node);
123            if (!page)
124                goto done;
125
126            a->free_count--;

발췌 범위와 읽기 기준

원문 38–126줄에는 앞뒤 문맥이 포함된다. pmm_add_arena()은 L62, pmm_alloc_pages()는 L106에서 시작한다. 발췌 첫 줄을 함수 시작으로 읽지 않는다.

이 두 PMM 발췌는 vmm_alloc_physical()이 PMM을 호출한다는 증거가 아니다. 세 VMM API와 vmm_free_region()은 고정 vmm.c에서 별도로 대조한다.

함께 읽어야 하는 원본 코드

아래 두 번째 보존 발췌는 pmm_alloc_pages()가 free list에서 page를 가져와 VM_PAGE_FLAG_NONFREE를 세우는 부분이다. VMM의 세 mapping API는 같은 commit의 vmm.c에서 이어 읽는다.

01. free list에서 여러 physical page를 꺼내는 pmm_alloc_pages

kernel/vm/pmm.c 96-176줄이다.

filekernel/vm/pmm.canchor · L106size_t pmm_alloc_pages(uint count
96        vm_page_t *p = &arena->page_array[i];
97
98        list_add_tail(&arena->free_list, &p->node);
99
100        arena->free_count++;
101    }
102
103    return NO_ERROR;
104}
105
106size_t pmm_alloc_pages(uint count, struct list_node *list) {
107    LTRACEF("count %u\n", count);
108
109    /* list must be initialized prior to calling this */
110    DEBUG_ASSERT(list);
111
112    uint allocated = 0;
113    if (count == 0)
114        return 0;
115
116    mutex_acquire(&lock);
117
118    /* walk the arenas in order, allocating as many pages as we can from each */
119    pmm_arena_t *a;
120    list_for_every_entry(&arena_list, a, pmm_arena_t, node) {
121        while (allocated < count && a->free_count > 0) {
122            vm_page_t *page = list_remove_head_type(&a->free_list, vm_page_t, node);
123            if (!page)
124                goto done;
125
126            a->free_count--;
127
128            page->flags |= VM_PAGE_FLAG_NONFREE;
129            list_add_tail(list, &page->node);
130
131            allocated++;
132        }
133    }
134
135done:
136    mutex_release(&lock);
137    return allocated;
138}
139
140vm_page_t *pmm_alloc_page(void) {
141    struct list_node list = LIST_INITIAL_VALUE(list);
142
143    size_t ret = pmm_alloc_pages(1, &list);
144    if (ret == 0) {
145        return NULL;
146    }
147
148    DEBUG_ASSERT(ret == 1);
149
150    return list_peek_head_type(&list, vm_page_t, node);
151}
152
153size_t pmm_alloc_range(paddr_t address, uint count, struct list_node *list) {
154    LTRACEF("address 0x%lx, count %u\n", address, count);
155
156    DEBUG_ASSERT(list);
157
158    uint allocated = 0;
159    if (count == 0)
160        return 0;
161
162    address = ROUNDDOWN(address, PAGE_SIZE);
163
164    mutex_acquire(&lock);
165
166    /* walk through the arenas, looking to see if the physical page belongs to it */
167    pmm_arena_t *a;
168    list_for_every_entry(&arena_list, a, pmm_arena_t, node) {
169        while (allocated < count && ADDRESS_IN_ARENA(address, a)) {
170            size_t index = (address - a->base) / PAGE_SIZE;
171
172            DEBUG_ASSERT(index < a->size / PAGE_SIZE);
173
174            vm_page_t *page = &a->page_array[index];
175            if (page->flags & VM_PAGE_FLAG_NONFREE) {
176                /* we hit an allocated page */

page list와 region 수명을 함수별로 추적

01

arena 등록은 mapping 전 단계가 아니다

pmm_add_arena()는 arena를 priority 순으로 연결하고 boot_alloc_mem()으로 vm_page_t metadata 배열을 마련한 뒤 각 page를 free list에 넣는다. 이 함수는 특정 VMM 호출의 virtual region을 만들거나 PTE를 작성하지 않는다.

02

두 VMM allocator가 먼저 PMM을 호출한다

vmm_alloc()은 page 수만큼 pmm_alloc_pages()를 요청하고 부족하면 반환된 page를 돌려준다. vmm_alloc_contiguous()는 pmm_alloc_contiguous()로 물리 연속 run을 얻는다. 그 뒤 둘 다 region을 만들고 arch_mmu_flags를 map에 넘긴다.

03

외부 물리주소는 직접 map한다

vmm_alloc_physical()은 aspace, paddr와 size의 page 정렬을 검사한다. size==0이면 성공으로 일찍 반환한다. 그 외에는 caller paddr로 region을 만들고 arch_mmu_map(...,paddr,...)한다. 이 함수 내부에는 pmm_alloc_*가 없다.

04

해제는 region의 소유 page만 PMM에 돌린다

vmm_free_region()은 region을 list에서 제거하면서 arch_mmu_unmap()을 호출한다. 이후 pmm_free(&r->page_list)를 한다. 두 allocator가 채운 list에는 page가 있고 외부 paddr 경로에서는 비어 있으므로, unmap만으로 외부 물리주소가 PMM에 반환되지는 않는다.

05

flags와 TLB는 아키텍처 경계를 넘겨 읽는다

alloc_region()은 arch_mmu_flags를 region에 기록하고 arch_mmu_map()도 같은 값을 받는다. 예를 들어 ARM64 arch_mmu_map()은 flags를 PTE attribute로 변환한다. ARM64 unmap은 유효한 기존 PTE를 지울 때 ASID 조건에 따라 TLBI를 사용한다. 이 조건을 generic VMM의 모든 map 뒤에 강제되는 단계로 그리지 않는다.

소스에서 주의할 경계 세 가지

01

VMM_REGION_FLAG_PHYSICAL은 소유권 판정이 아니다

세 API가 모두 이 region flag를 사용하지만 vmm_alloc_physical()의 page_list는 채우지 않는다. vmm_free_region()은 list에 있는 page만 pmm_free()로 돌린다. 따라서 flag 이름보다 page list 작성 지점을 따라간다.

02

부분 실패에는 정리 경로가 다르다

두 allocator는 PMM page를 먼저 확보하므로 region 생성 또는 map 실패 시 해당 page list를 반환한다. 외부 paddr 경로의 map 실패는 region을 제거·해제하지만 외부 paddr를 PMM에 반환하지 않는다. vmm_alloc_physical()과 contiguous 경로는 출력 *ptr를 map 전에 써서, 실패 반환 뒤 그 값을 성공 주소로 사용해서는 안 된다.

03

TLB 처리는 architecture 구현에서 조건부다

generic vmm.c의 vmm_free_region()은 arch_mmu_unmap()만 호출한다. 고정 ARM64 arm64_mmu_unmap_pt()는 기존 PTE가 있을 때 해당 entry를 무효화하고 global/user ASID에 맞는 TLBI를 실행한다. 일반 mapping 뒤의 독립 TLB phase로 그리지 않고, 다른 arch는 그 구현을 확인한다.

매핑별 물리 page의 소유자

대상생성·입력region과 관계free 시 동작
pmm_arena_t·vm_page_tpmm_add_arena()의 metadata·free listPMM allocator가 page를 꺼낼 수 있음pmm_free()가 소유 page를 free list로
vmm_alloc() pagepmm_alloc_pages()page별 map 뒤 r->page_listunmap 뒤 PMM 반환
contiguous runpmm_alloc_contiguous()연속 map 뒤 page list 이전unmap 뒤 PMM 반환
외부 paddrvmm_alloc_physical()의 인자map하지만 r->page_list는 빈 상태unmap; 외부 주소는 PMM 반환 안 함
arch_mmu_flags세 VMM API의 인자region 기록·arch_mmu_map() 전달실제 PTE/TLB 동작은 arch별

고정 코드의 실패와 검증 범위

#조건코드의 경로읽을 때 주의할 점
01vmm_alloc() PMM short count받은 page를 pmm_free() 후 ERR_NO_MEMORYmapping 전 실패
02contiguous run 부족ERR_NO_MEMORY; 부분 run은 없다고 assertregion·map 전 실패
03외부 paddr 정렬 오류ERR_INVALID_ARGSpage 소유권 검사와 다름
04arch_mmu_map() 오류region 제거; owned page는 PMM 반환외부 paddr는 반환하지 않음
05ARM64 unmap의 기존 PTEentry 무효화 뒤 global/user TLBIgeneric VMM의 독립 stage 아님

PMM과 VMM의 lock은 별도이며, address space가 같은 vmm_lock 아래 관리되는지와 arch mapping 반환을 각각 확인한다. 모든 architecture에서 같은 TLB sequence가 실행된다고 추론하지 않는다.

원문에서 각 화살표를 대조할 위치

이 페이지의 두 보존 발췌는 PMM arena와 free list를 보여 준다. VMM 분기는 고정 vmm.c, TLB 예시는 고정 ARM64 MMU 코드에서 확인한다.

#주제고정 원문확인할 식·호출
01arena·page 할당pmm.c:62–142free_list, VM_PAGE_FLAG_NONFREE
02외부 paddr mapvmm.c:327–397paddr·alloc_region·arch_mmu_map; PMM 호출 없음
03연속 pagevmm.c:399–484pmm_alloc_contiguous 선행
04일반 pagevmm.c:486–589pmm_alloc_pages와 page별 map
05unmap·PMM 반환vmm.c:610–650arch_mmu_unmap 뒤 pmm_free(r->page_list)
06ARM64 조건부 TLBIarm64/mmu.c:343–390기존 PTE·global/user ASID 조건

세 API와 해제 경로를 분리해 확인

  1. 01
    page 출처 추적

    고정 소스에서 vmm_alloc(), vmm_alloc_contiguous(), vmm_alloc_physical()의 PMM 호출 유무와 page_list 이동 위치를 각각 표시한다.

  2. 02
    동일 paddr의 flag 비교

    재현 가능한 시험 환경에서 mapping 호출의 arch_mmu_flags와 ARM64 PTE attribute 변환을 대조한다. physical address만 보고 cache attribute를 추정하지 않는다.

  3. 03
    unmap과 page 반환 대조

    PMM 소유 region과 외부 paddr region을 각각 해제할 때 arch_mmu_unmap()과 pmm_free()의 대상 list를 기록한다. ARM64 TLBI는 기존 PTE와 ASID 분기 안에서만 찾는다.

원문과 다음 글