MMU Gather (TLB 플러시 최적화)

개요 (Overview)

MMU Gather는 Linux 커널이 페이지 테이블에서 엔트리를 제거할 때 TLB(Translation Lookaside Buffer) 플러시를 효율적으로 수행하기 위한 배치(batching) 메커니즘입니다. 페이지 테이블에서 PTE, PMD 같은 엔트리를 하나씩 제거할 때마다 즉시 TLB 플러시를 호출하면 SMP 환경에서 IPI(Inter-Processor Interrupt) 오버헤드가 너무 커지므로, 여러 제거 작업을 모아서 한 번에 플러시하는 방식으로 성능을 최적화합니다.

mm/mmu_gather.c는 struct mmu_gather 구조체를 초기화하고, 제거된 페이지/테이블을 배치로 수집한 뒤, 최종적으로 TLB 플러시와 메모리 해제를 수행하는 핵심 루틴을 제공합니다. 아키텍처별로 flush_tlb_mm(), flush_tlb_range() 같은 저수준 함수를 제공하며, asm-generic/tlb.h에서 공통 인라인 함수들을 정의합니다.

TLB shootdown은 페이지 테이블을 정리하는 순간뿐 아니라 mprotect(), munmap(), MADV_DONTNEED, COW, NUMA balancing처럼 PTE 의미가 바뀌는 순간에도 필요합니다. 이 문서는 tlb_gather_mmu()로 변경을 모은 뒤 tlb_flush_mmu_tlbonly() 또는 tlb_flush_mmu()에서 invalidate와 free를 한 번에 처리하는 흐름을 같이 봅니다.

소스 파일 경로:
├── mm/mmu_gather.c                          ← MMU gather 핵심 로직 (536줄)
├── include/asm-generic/tlb.h                ← struct mmu_gather 정의 (L321-392), 인라인 함수
├── include/linux/mm_types.h                 ← encode_page/decode_page (L238-279)
├── include/linux/mm_types.h:1578-1582       ← tlb_gather_mmu/finish 선언
├── arch/Kconfig:508-530                     ← MMU_GATHER_* 옵션 정의
├── arch/x86/Kconfig:285-286                 ← x86: RCU_TABLE_FREE, MERGE_VMAS
├── arch/arm64/Kconfig:251                   ← ARM64: RCU_TABLE_FREE
└── arch/s390/Kconfig:265-267                ← s390: MERGE_VMAS, NO_GATHER, RCU_TABLE_FREE

---

빠른 점검 명령

# MMU_GATHER 관련 커널 설정 확인
zcat /proc/config.gz 2>/dev/null | grep -E "CONFIG_MMU_GATHER" || grep -E "CONFIG_MMU_GATHER" /boot/config-$(uname -r) 2>/dev/null

# RCU 테이블 해제 지원 여부 확인
zcat /proc/config.gz 2>/dev/null | grep CONFIG_MMU_GATHER_RCU_TABLE_FREE || grep CONFIG_MMU_GATHER_RCU_TABLE_FREE /boot/config-$(uname -r) 2>/dev/null

# TLB 플러시 관련 커널 통계 확인
cat /proc/vmstat | grep -E "tlb_flush|pgfault|pgmajfault"

# 현재 시스템의 페이지 크기 확인
getconf PAGESIZE

# 커널 빌드 시 MMU_GATHER 모듈 포함 여부 확인
cat /lib/modules/$(uname -r)/build/.config 2>/dev/null | grep CONFIG_MMU_GATHER

# TLB 관련 커널 로그 확인
dmesg | grep -iE "tlb|flush|gather" | tail -10

# NUMA 시스템에서의 TLB 플러시 통계
cat /proc/interrupts | grep -i "TLB" 2>/dev/null || echo "TLB 인터럽트 정보 없음"

# 아키텍처별 MMU_GATHER 선택 옵션 확인
grep -r "select MMU_GATHER" arch/*/Kconfig 2>/dev/null

# 페이지 테이블 관련 메모리 사용량 확인
cat /proc/meminfo | grep -E "PageTables|KernelStack"

# 커널 소스에서의 MMU gather 관련 함수 목록 확인
grep -rn "tlb_gather_mmu\|tlb_finish_mmu\|tlb_remove_page\|tlb_remove_table" mm/mmu_gather.c

# TLB miss 관찰
perf stat -e dTLB-load-misses,dTLB-store-misses,iTLB-load-misses -a -- sleep 5

# 현재 프로세스의 minor/major fault 확인
ps -o pid,minflt,majflt -p $$

# 페이지 폴트 및 reclaim 압력 확인
cat /proc/vmstat | grep -E "pgfault|pgmajfault|allocstall|tlb"
cat /proc/pressure/memory

# 페이지 테이블 덤프(활성화된 경우)
cat /sys/kernel/debug/kernel_page_tables 2>/dev/null | head -40

---

핵심 자료구조

1. `struct mmu_gather` (include/asm-generic/tlb.h:321)

TLB 플러시 배치의 핵심 구조체입니다. 스택에 할당되며, 페이지 테이블 제거 작업을 수집하고 범위를 추적합니다.

// include/asm-generic/tlb.h:321-392
struct mmu_gather {
struct mm_struct    *mm;        // 대상 주소 공간

struct mmu_table_batch *batch;  // 테이블 배치 (CONFIG_MMU_GATHER_TABLE_FREE)

unsigned long       start;      // 플러시 대상 범위 시작
unsigned long       end;        // 플러시 대상 범위 끝

unsigned int        fullmm : 1;           // 전체 mm 제거 여부 (exit/execve)
unsigned int        need_flush_all : 1;   // 전체 flush 필요 여부
unsigned int        freed_tables : 1;     // 페이지 디렉토리 제거됨
unsigned int        delayed_rmap : 1;     // 지연된 rmap 제거 보유 여부

unsigned int        cleared_ptes : 1;     // PTE 레벨 제거 기록
unsigned int        cleared_pmds : 1;     // PMD 레벨 제거 기록
unsigned int        cleared_puds : 1;     // PUD 레벨 제거 기록
unsigned int        cleared_p4ds : 1;     // P4D 레벨 제거 기록

unsigned int        vma_exec : 1;         // VM_EXEC 플래그 추적
unsigned int        vma_huge : 1;         // VM_HUGETLB 플래그 추적
unsigned int        vma_pfn  : 1;         // VM_PFNMAP/VM_MIXEDMAP 추적

unsigned int        unshared_tables : 1;  // 공유 해제된 테이블 존재
unsigned int        fully_unshared_tables : 1; // 완전히 해제된 테이블

unsigned int        batch_count;           // 현재 배치 수

struct mmu_gather_batch *active;   // 현재 활성 배치
struct mmu_gather_batch local;     // 스택 할당 로컬 배치
struct page         *__pages[MMU_GATHER_BUNDLE]; // 로컬 페이지 배열

unsigned int page_size;            // 현재 페이지 크기 (CONFIG_MMU_GATHER_PAGE_SIZE)
};

필드 설명:

start, end: TLB 플러시가 필요한 주소 범위. __tlb_adjust_range()로 갱신됨.

fullmm: exit(), execve()처럼 전체 주소 공간을 제거할 때 true. 범위 추적을 건너뛰고 전체 flush 수행.

freed_tables, cleared_ptes/pmds/puds/p4ds: 어떤 레벨의 엔트리가 제거되었는지 기록. tlb_flush_mmu_tlbonly()에서 flush 필요 여부 결정.

delayed_rmap: SMP에서 rmap 제거를 TLB flush 후로 미룸. tlb_flush_rmaps()에서 처리.

active: 현재 채우고 있는 배치. local에서 시작하여 필요 시 새 배치 할당.

batch_count: 할당된 배치 수. MAX_GATHER_BATCH_COUNT(≈10K 페이지/배치 크기)로 제한하여 soft lockup 방지.

2. `struct mmu_gather_batch` (include/asm-generic/tlb.h:272)

인코딩된 페이지 포인터를 저장하는 단일 linked list 노드입니다.

// include/asm-generic/tlb.h:272-277
struct mmu_gather_batch {
struct mmu_gather_batch *next;   // 다음 배치 (linked list)
unsigned int        nr;          // 현재 저장된 엔트리 수
unsigned int        max;         // 최대 엔트리 수
struct encoded_page *encoded_pages[];  // 인코딩된 페이지 배열 (flexible array)
};

설명:

encoded_pages[]: 페이지 포인터에 플래그를 비트 마스킹하여 저장. 하위 2비트는 ENCODED_PAGE_BIT_DELAY_RMAP(bit 1)과 ENCODED_PAGE_BIT_NR_PAGES_NEXT(bit 2)로 사용.

MAX_GATHER_BATCH: (PAGE_SIZE - sizeof(struct mmu_gather_batch)) / sizeof(void *). 4KB 페이지 기준 약 512 엔트리.

local: 스택에 직접 할당되는 첫 번째 배치. 추가 배치는 __get_free_page(GFP_NOWAIT)로 동적 할당.

3. `struct mmu_table_batch` (include/asm-generic/tlb.h:205)

페이지 테이블 디렉토리 해제를 위한 배치 구조체입니다. CONFIG_MMU_GATHER_RCU_TABLE_FREE 활성화 시 RCU grace period 후 해제됩니다.

// include/asm-generic/tlb.h:205-211
struct mmu_table_batch {
struct rcu_head     rcu;         // RCU 해제 헤드 (CONFIG_MMU_GATHER_RCU_TABLE_FREE)
unsigned int        nr;          // 현재 저장된 테이블 수
void                *tables[];   // 테이블 포인터 배열 (flexible array)
};

설명:

MAX_TABLE_BATCH: (PAGE_SIZE - sizeof(struct mmu_table_batch)) / sizeof(void *).

RCU 테이블 해제는 소프트웨어 페이지 테이블 워커(gup_fast 등)와의 동기화에 사용됨. IRQ 비활성화 구간에서 워커가 페이지 테이블을 읽으므로, 해제 전에 RCU grace period를 대기해야 함.

4. `struct encoded_page` (include/linux/mm_types.h:238)

페이지 포인터에 플래그를 비트 마스킹하여 저장하는 인코딩 포인터입니다.

// include/linux/mm_types.h:238-279
struct encoded_page;

#define ENCODED_PAGE_BITS           3ul      // 사용 가능한 비트 수
#define ENCODED_PAGE_BIT_DELAY_RMAP 1ul      // TLB flush 후 rmap 제거 지연
#define ENCODED_PAGE_BIT_NR_PAGES_NEXT 2ul   // 다음 엔트리가 nr_pages 값

// 인코딩: 페이지 포인터 하위 비트에 플래그 추가
static __always_inline struct encoded_page *encode_page(struct page *page, unsigned long flags)
{
BUILD_BUG_ON(flags > ENCODED_PAGE_BITS);
return (struct encoded_page *)(flags | (unsigned long)page);
}

// 디코딩: 하위 비트 제거하여 실제 페이지 포인터 복원
static inline struct page *encoded_page_ptr(struct encoded_page *page)
{
return (struct page *)(~ENCODED_PAGE_BITS & (unsigned long)page);
}

// include/linux/mm_types.h:260-268
static inline unsigned long encoded_page_flags(struct encoded_page *page)
{
return ENCODED_PAGE_BITS & (unsigned long)page;
}

설명:

ENCODED_PAGE_BIT_DELAY_RMAP (bit 1): SMP 환경에서 rmap 제거를 TLB flush 이후로 미룸. folio_remove_rmap_ptes() 호출이 지연됨.

ENCODED_PAGE_BIT_NR_PAGES_NEXT (bit 2): 연속된 여러 페이지(folio)를 하나의 배치 엔트리로 표현. 다음 엔트리에 실제 페이지 수가 인코딩됨.

5. `encode_page` / `encode_nr_pages` (include/linux/mm_types.h:254-279)

페이지 인코딩/디코딩 유틸리티 함수입니다.

// include/linux/mm_types.h:270-278
// 페이지 수 인코딩: 상위 비트에 페이지 수 저장
static __always_inline struct encoded_page *encode_nr_pages(unsigned long nr)
{
VM_WARN_ON_ONCE((nr << 2) >> 2 != nr);  // 30비트 초과 검증
return (struct encoded_page *)(nr << 2);
}

// 인코딩된 페이지 수 디코딩
static __always_inline unsigned long encoded_nr_pages(struct encoded_page *page)
{
return ((unsigned long)page) >> 2;
}

---

핵심 함수

1. `tlb_gather_mmu()` — 초기화

// mm/mmu_gather.c:443-446
void tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm)
{
__tlb_gather_mmu(tlb, mm, false);  // fullmm = false
}

역할: 스택에 할당된 mmu_gather 구조체를 초기화. 페이지 테이블 제거 작업 시작 전에 호출.

동작: __tlb_gather_mmu()에서 mm 연결, 배치 초기화(local 사용), 범위 초기화(__tlb_reset_range()), inc_tlb_flush_pending() 호출.

변형:

- tlb_gather_mmu_fullmm(): fullmm=true. 전체 주소 공간 제거(exit/execve) 시 사용.

- tlb_gather_mmu_vma(): 단일 VMA 대상. tlb_update_vma_flags()와 HugeTLB 페이지 크기 설정 포함.

2. `__tlb_remove_folio_pages()` — 페이지 제거 기록

// mm/mmu_gather.c:207-212
bool __tlb_remove_folio_pages(struct mmu_gather *tlb, struct page *page,
unsigned int nr_pages, bool delay_rmap)
{
return __tlb_remove_folio_pages_size(tlb, page, nr_pages, delay_rmap,
PAGE_SIZE);
}

역할: 제거된 페이지를 배치에 인코딩하여 저장. 배치가 가득 차면 tlb_flush_mmu()를 유발.

분기 로직:

- nr_pages == 1: 단일 페이지 → encode_page(page, flags)로 저장.

- nr_pages > 1: folio → ENCODED_PAGE_BIT_NR_PAGES_NEXT 설정 후 다음 엔트리에 encode_nr_pages(nr_pages) 저장.

- batch->nr >= batch->max - 1: 배치 가득 참 → tlb_next_batch()로 새 배치 할당 실패 시 true 반환 → 호출부에서 flush 유발.

반환값: true = 즉시 flush 필요, false = 계속 배치 가능.

3. `tlb_flush_mmu()` — TLB 플러시 실행

// mm/mmu_gather.c:402-406
void tlb_flush_mmu(struct mmu_gather *tlb)
{
tlb_flush_mmu_tlbonly(tlb);   // 아키텍처별 TLB flush
tlb_flush_mmu_free(tlb);       // 테이블 및 페이지 해제
}

역할: tlb_remove_page() 등에서 배치가 가득 찼을 때 호출. 실제 TLB flush와 리소스 해제를 수행.

동작:

1. tlb_flush_mmu_tlbonly(): freed_tables 또는 cleared_* 플래그가 설정된 경우에만 tlb_flush() 호출. flush 후 __tlb_reset_range()로 범위 리셋.

2. tlb_flush_mmu_free(): tlb_table_flush()로 테이블 배치 해제 + tlb_batch_pages_flush()로 페이지 배치 해제.

4. `tlb_finish_mmu()` — 최종 정리

// mm/mmu_gather.c:496-536
void tlb_finish_mmu(struct mmu_gather *tlb)

역할: 페이지 테이블 제거 작업 완료 후 호출. 중첩 flush 처리, 최종 flush, 배치 메모리 해제.

동작:

1. mm_tlb_flush_nested() 확인: 병렬 스레드가 같은 범위에 PTE 변경 시 강제 전체 flush (fullmm=1, __tlb_reset_range(), freed_tables=1).

2. tlb_flush_mmu(): 최종 flush 실행.

3. tlb_batch_list_free(): 동적 할당된 배치 페이지 해제.

4. dec_tlb_flush_pending(): 대기 카운트 감소.

보조 경로

// include/asm-generic/tlb.h:495-507
static inline void tlb_flush_mmu_tlbonly(struct mmu_gather *tlb)
{
if (!(tlb->freed_tables || tlb->cleared_ptes || tlb->cleared_pmds ||
tlb->cleared_puds || tlb->cleared_p4ds || tlb->unshared_tables))
return;

tlb_flush(tlb);
__tlb_reset_range(tlb);
}

tlb_flush_mmu_tlbonly()는 freed_tables, cleared_*, unshared_tables가 있을 때만 invalidate하고 범위를 리셋합니다.

tlb_remove_tlb_entry()는 mm/memory.c:1695-1705에서 ptep_get_and_clear_full() 뒤에 호출되어 PTE 제거 범위를 기록합니다.

tlb_free_vmas()는 VM_PFNMAP / VM_MIXEDMAP이 섞인 범위에서 VMA를 unlink하기 전에 TLB flush를 앞당깁니다.

5. `tlb_remove_table()` — 테이블 배치

// mm/mmu_gather.c:363-380
void tlb_remove_table(struct mmu_gather *tlb, void *table)

역할: 제거된 페이지 테이블 디렉토리(PGD, P4D 등)를 배치에 저장. CONFIG_MMU_GATHER_TABLE_FREE 활성화 시 사용.

동작:

1. 배치 할당: __get_free_page(GFP_NOWAIT)로 새 배치 할당 실패 시 즉시 tlb_table_invalidate() + 단일 해제.

2. 배치 추가: batch->tables[batch->nr++] = table.

3. 배치 가득 참: tlb_table_flush()로 즉시 flush.

6. `tlb_flush_rmaps()` — 지연 rmap 제거

// mm/mmu_gather.c:84-93
void tlb_flush_rmaps(struct mmu_gather *tlb, struct vm_area_struct *vma)

역할: SMP에서 delayed_rmap이 설정된 경우, TLB flush 완료 후 rmap 제거를 수행.

동작: tlb->local과 tlb->active 배치의 모든 엔트리를 순회하며 ENCODED_PAGE_BIT_DELAY_RMAP이 설정된 페이지에 대해 folio_remove_rmap_ptes() 호출.

7. `tlb_next_batch()` — 새 배치 할당

// mm/mmu_gather.c:20-50
static bool tlb_next_batch(struct mmu_gather *tlb)

역할: 현재 배치가 가득 찼을 때 다음 배치를 할당하거나 이동.

분기:

- tlb->delayed_rmap && tlb->active != &tlb->local: 지연 rmap 보유 시 새 배치 시작 불가 (기존 배치에서 처리해야 함).

- batch->next: 이미 할당된 다음 배치가 있으면 이동.

- batch_count == MAX_GATHER_BATCH_COUNT: 배치 수 제한 도달 → 할당 거부 (soft lockup 방지).

- __get_free_page(GFP_NOWAIT) 실패: 메모리 부족 시 할당 거부.

---

호출 흐름

사용자: munmap() / exit() / madvise(MADV_DONTNEED)
│
▼
tlb_gather_mmu(tlb, mm)  ← 초기화 (스택 할당, 배치 초기화)
│
▼
tlb_start_vma(tlb, vma)  ← 캐시 플러시, VMA 플래그 기록
│
▼ (VMA 순회하며)
zap_pte_range(tlb, vma, pmd, addr, end)
│
├── tlb_remove_tlb_entry(tlb, ptep, addr)
│     └── tlb_flush_pte_range(tlb, addr, PAGE_SIZE)  ← 범위 갱신
│
└── __tlb_remove_folio_pages(tlb, page, nr_pages, delay_rmap)
└── __tlb_remove_folio_pages_size()
└── 배치에 인코딩된 페이지 저장
└── 배치 가득 참 → tlb_flush_mmu() 유발
│
▼
tlb_end_vma(tlb, vma)  ← VMA 경계에서 플러시 (MERGE_VMAS 미활성화 시)
│
▼
tlb_finish_mmu(tlb)  ← 최종 정리
├── mm_tlb_flush_nested() 확인 → 병렬 flush 필요 시 fullmm 강제
├── tlb_flush_mmu()
│     ├── tlb_flush_mmu_tlbonly() → flush_tlb_mm() 또는 flush_tlb_range()
│     └── tlb_flush_mmu_free()
│           ├── tlb_table_flush() → RCU/직접 테이블 해제
│           └── tlb_batch_pages_flush() → free_pages_and_swap_cache()
└── tlb_batch_list_free() → 동적 배치 해제

---

조건별 비교

MMU_GATHER_* 커널 옵션 비교

옵션	설명	활성화 아키텍처
`MMU_GATHER_TABLE_FREE`	페이지 테이블 디렉토리를 배치로 해제	x86, ARM64, RISC-V, PowerPC, s390 등 대부분
`MMU_GATHER_RCU_TABLE_FREE`	RCU grace period 후 테이블 해제. 소프트웨어 워커(gup_fast) 동기화	x86(SMP), ARM64(SMP), RISC-V(SMP), s390, PowerPC
`MMU_GATHER_NO_RANGE`	범위 기반 플러시 없이 전체 mm 플러시만 사용	nios2, m68k, microblaze, OpenRISC
`MMU_GATHER_MERGE_VMAS`	VMA 경계에서 플러시를 건너뛰고 범위 병합	x86, PowerPC, s390, SPARC, LoongArch
`MMU_GATHER_NO_FLUSH_CACHE`	`flush_cache_range()` 호출 안 함	s390, SPARC
`MMU_GATHER_NO_GATHER`	페이지 배치 없이 즉시 해제. 아키텍처가 자체 flush 지원 시	s390
`MMU_GATHER_PAGE_SIZE`	페이지 크기 변경 감지 ( HugeTLB)	PowerPC

아키텍처별 TLB flush 방식 비교

아키텍처	flush 방식	특징
x86_64	`flush_tlb_mm()`, `flush_tlb_range()`	INVLPG 명령어 사용. 전체 flush 시 CR3 재로드. MERGE_VMAS로 범위 최적화.
ARM64	`tlbi vmalle1is`, `tlbi vae1is`	HW 지원 cross-CPU 동기화. fullmm 사용 시 IPI 스팸 방지.
s390	동기식 원격 flush	NO_GATHER로 즉시 해제. 소프트웨어 워커 불필요.
RISC-V	`sfence.vma`	SMP 시 RCU_TABLE_FREE로 IPI 비활성화 구간 동기화.

배치 동작 비교

상황	동작	설명
단일 페이지 제거	`encode_page(page, 0)` → `batch->encoded_pages[nr++]`	플래그 없이 단순 저장
folio 여러 페이지	`encode_page(page, NR_PAGES_NEXT)` + `encode_nr_pages(nr)`	연속 2엔트리 사용
SMP rmap 지연	`tlb_delay_rmap(tlb)` → `ENCODED_PAGE_BIT_DELAY_RMAP` 설정	flush 후 rmap 제거
배치 가득 참	`tlb_next_batch()` → 새 배치 할당 또는 flush 유발	`MAX_GATHER_BATCH_COUNT` 제한
메모리 부족	`__get_free_page(GFP_NOWAIT)` 실패 → 기존 배치에서 flush	진행 보장

대표 VMA 경로 비교

경로	진입 함수	mmu_gather 사용	핵심 흐름
`munmap()`	`unmap_region()`	`tlb_gather_mmu()` → `tlb_finish_mmu()`	`unmap_vmas()` → `free_pgtables()` → page table tear-down
`mprotect()`	`do_mprotect_pkey()`	`tlb_gather_mmu()` → `mprotect_fixup()` → `tlb_finish_mmu()`	`change_protection()` → `walk_page_range()` → PTE 권한 갱신
`MADV_COLD` / `MADV_PAGEOUT`	`madvise_cold()` / `madvise_pageout()`	`tlb_gather_mmu()` → `tlb_start_vma()` / `tlb_end_vma()` → `tlb_finish_mmu()`	LRU 접근 비트 정리 후 TLB invalidate
`MADV_FREE`	`madvise_free_single_vma()`	`tlb_start_vma()` / `tlb_end_vma()`	`clear_young_dirty_ptes()` + `tlb_remove_tlb_entries()`
NUMA balancing	`change_prot_numa()`	`tlb_gather_mmu()` → `tlb_finish_mmu()`	PROT_NONE 마킹 후 `change_protection()`
exec stack relocation	`relocate_vma_down()`	`tlb_gather_mmu()` → `free_pgd_range()` → `tlb_finish_mmu()`	새 위치로 이동 후 상위 페이지 테이블 정리

아키텍처별 invalidate 방식

아키텍처	대표 primitive	동기 범위	비고
x86_64	`invlpg`, `flush_tlb_mm()`, `flush_tlb_range()`	local + IPI shootdown	PCID가 있으면 태그 전환으로 비용을 줄임
ARM64	`TLBI ...`, `dsb ish`, `isb`	inner-shareable broadcast	ASID 기반으로 range/fullmm 구분
RISC-V	`sfence.vma`	per-hart 또는 IPI 동기화	ASID 인자가 있으면 범위 축소 가능
s390	synchronous remote flush	동기식 CPU sync	`MMU_GATHER_NO_GATHER`와 함께 쓰이는 경우가 많음

---

관련 문서

00 — 메모리 관리 개요

03 — VMA / mmap

36 — mprotect

38 — Page Table Walk

05 — 페이지 회수

20 — Migration

39 — vmpressure

33 — GUP (Get User Pages)

43 — HugeTLB

64 — MMU 없는 시스템