73. MM 초기화 (mm/mm_init.c)

개요

mm/mm_init.c는 Linux 커널 부팅 시 메모리 관리 서브시스템의 초기화 과정을 담당하는 핵심 소스 파일입니다. 이 파일은 메모리 맵 구성, 존 설정, 페이지 초기화, 구조체 할당 등 부팅 초기의 모든 메모리 관리 작업을 수행합니다.

/* mm/mm_init.c - 메모리 초기화 검증 및 디버깅 - 2743줄 */
/* SPDX-License-Identifier: GPL-2.0-only */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/memblock.h>
#include <linux/page-isolation.h>
#include <linux/mm.h>
#include <linux/mmzone.h>
#include <linux/mm_types.h>

이 파일은 mm_core_init(), free_area_init(), memmap_init() 등의 핵심 함수를 포함하며, 부팅 과정에서 메모리 관리의 기반을 구축합니다. 아키텍처별 차이를 처리하고, NUMA 시스템의 메모리 배치를 설정하며, zonelist를 구성하는 등 커널 메모리 관리의 모든 것을 시작하는 곳입니다.

빠른 점검 명령

# mm_init.c 줄 수 확인
wc -l ~/Chamber_linux/linux-7.0-source/mm/mm_init.c

# 주요 함수 정의 확인
grep -n "^void\|^static void\|^static int\|^int" ~/Chamber_linux/linux-7.0-source/mm/mm_init.c | head -30

# 초기화 관련 매크로 확인
grep -n "#define\|#ifdef" ~/Chamber_linux/linux-7.0-source/mm/mm_init.c | head -20

# early_param 정의 확인
grep -n "early_param" ~/Chamber_linux/linux-7.0-source/mm/mm_init.c

# CONFIG 옵션 확인
grep -n "CONFIG_" ~/Chamber_linux/linux-7.0-source/mm/mm_init.c | sort -u | head -20

# 존 관련 변수 확인
grep -n "zone_movable_pfn\|arch_zone_" ~/Chamber_linux/linux-7.0-source/mm/mm_init.c | head -15

# memblock 사용 확인
grep -n "memblock" ~/Chamber_linux/linux-7.0-source/mm/mm_init.c | head -15

# mm_core_init 호출 흐름 확인
grep -n "mm_core_init\|free_area_init\|memmap_init" ~/Chamber_linux/linux-7.0-source/mm/mm_init.c

# 페이지 초기화 함수 확인
grep -n "__init_single_page\|memmap_init_range\|init_deferred_page" ~/Chamber_linux/linux-7.0-source/mm/mm_init.c

# NUMA 관련 함수 확인
grep -n "early_pfn_to_nid\|setup_nr_node_ids\|get_pfn_range_for_nid" ~/Chamber_linux/linux-7.0-source/mm/mm_init.c

핵심 자료구조

1. mminit_pfnnid_cache (파일:라인 605-609)

PFN-to-NID 변환 캐시입니다. 초기 부팅 시 빠른 조회를 위해 사용됩니다.

/* 초기 PFN-NID 캐시 - 빠른 조회를 위한 캐시 */
struct mminit_pfnnid_cache {
unsigned long last_start;   /* 마지막 검색 시작 PFN */
unsigned long last_end;     /* 마지막 검색 끝 PFN */
int last_nid;               /* 마지막 검색된 노드 ID */
};

2. zone_movable_pfn (파일:라인 238)

각 노드별 ZONE_MOVABLE 시작 PFN 배열입니다.

/* 노드별 ZONE_MOVABLE 시작 PFN */
static unsigned long zone_movable_pfn[MAX_NUMNODES] __initdata;

3. required_kernelcore/required_movablecore (파일:라인 240-243)

커널 파라미터로 지정된 커널/이동 가능 코어 메모리 크기입니다.

/* 커널코어/이동가능코어 메모리 크기 */
static unsigned long required_kernelcore __initdata;
static unsigned long required_kernelcore_percent __initdata;
static unsigned long required_movablecore __initdata;
static unsigned long required_movablecore_percent __initdata;

4. deferred_struct_pages (파일:라인 248)

지연된 구조체 페이지 초기화 활성화 여부입니다.

/* 지연된 구조체 페이지 초기화 플래그 */
static bool deferred_struct_pages __meminitdata;

5. pgdat_set_deferred_range (파일:라인 690-693)

지연된 초기화 범위를 설정하는 인라인 함수입니다.

/* 지연된 초기화 범위 설정 */
static inline void pgdat_set_deferred_range(pg_data_t *pgdat)
{
pgdat->first_deferred_pfn = ULONG_MAX;
}

핵심 함수

1. free_area_init() (파일:라인 1820-1933)

모든 pg_data_t와 존 데이터를 초기화하는 메인 함수입니다.

/* 모든 노드와 존 초기화 */
static void __init free_area_init(void)
{
unsigned long max_zone_pfn[MAX_NR_ZONES] = { 0 };
unsigned long start_pfn, end_pfn;
int i, nid, zone;
bool descending;

arch_zone_limits_init(max_zone_pfn);
sparse_init();

start_pfn = PHYS_PFN(memblock_start_of_DRAM());
descending = arch_has_descending_max_zone_pfns();

/* 존 범위 설정 */
for (i = 0; i < MAX_NR_ZONES; i++) {
if (descending)
zone = MAX_NR_ZONES - i - 1;
else
zone = i;

if (zone == ZONE_MOVABLE)
continue;

end_pfn = max(max_zone_pfn[zone], start_pfn);
arch_zone_lowest_possible_pfn[zone] = start_pfn;
arch_zone_highest_possible_pfn[zone] = end_pfn;

start_pfn = end_pfn;
}

/* ZONE_MOVABLE 시작 PFN 찾기 */
memset(zone_movable_pfn, 0, sizeof(zone_movable_pfn));
find_zone_movable_pfns_for_nodes();

/* 각 노드 초기화 */
for_each_node(nid) {
pg_data_t *pgdat;
if (!NODE_DATA(nid))
alloc_offline_node_data(nid);

pgdat = NODE_DATA(nid);
free_area_init_node(nid);

if (pgdat->node_present_pages) {
node_set_state(nid, N_MEMORY);
check_for_memory(pgdat);
}
}

calc_nr_kernel_pages();
memmap_init();
set_high_memory();
}

2. free_area_init_node() (파일:라인 1714-1746)

단일 노드의 메모리 맵을 초기화합니다.

/* 단일 노드 초기화 */
static void __init free_area_init_node(int nid)
{
pg_data_t *pgdat = NODE_DATA(nid);
unsigned long start_pfn = 0;
unsigned long end_pfn = 0;

get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);

pgdat->node_id = nid;
pgdat->node_start_pfn = start_pfn;
pgdat->per_cpu_nodestats = NULL;

if (start_pfn != end_pfn) {
calculate_node_totalpages(pgdat, start_pfn, end_pfn);
} else {
reset_memoryless_node_totalpages(pgdat);
}

alloc_node_mem_map(pgdat);
pgdat_set_deferred_range(pgdat);
free_area_init_core(pgdat);
lru_gen_init_pgdat(pgdat);
}

3. memmap_init_range() (파일:라인 872-939)

메모리 맵 범위를 초기화합니다.

/* 메모리 맵 범위 초기화 */
void __meminit memmap_init_range(unsigned long size, int nid, unsigned long zone,
unsigned long start_pfn, unsigned long zone_end_pfn,
enum meminit_context context,
struct vmem_altmap *altmap, int migratetype,
bool isolate_pageblock)
{
unsigned long pfn, end_pfn = start_pfn + size;
struct page *page;

for (pfn = start_pfn; pfn < end_pfn; ) {
if (context == MEMINIT_EARLY) {
if (overlap_memmap_init(zone, &pfn))
continue;
if (defer_init(nid, pfn, zone_end_pfn)) {
deferred_struct_pages = true;
break;
}
}

page = pfn_to_page(pfn);
__init_single_page(page, pfn, zone, nid);

if (pageblock_aligned(pfn)) {
init_pageblock_migratetype(page, migratetype, isolate_pageblock);
cond_resched();
}
pfn++;
}
}

4. __init_single_page() (파일:라인 581-597)

개별 페이지 구조체를 초기화합니다.

/* 개별 페이지 초기화 */
void __meminit __init_single_page(struct page *page, unsigned long pfn,
unsigned long zone, int nid)
{
mm_zero_struct_page(page);
set_page_links(page, zone, nid, pfn);
init_page_count(page);
atomic_set(&page->_mapcount, -1);
page_cpupid_reset_last(page);
page_kasan_tag_reset(page);

INIT_LIST_HEAD(&page->lru);
}

5. mm_core_init() (파일:라인 2694-2743)

커널 메모리 관리의 메인 초기화 함수입니다.

/* 메모리 관리 핵심 초기화 */
void __init mm_core_init(void)
{
arch_mm_preinit();

BUILD_BUG_ON(MAX_ZONELISTS > 2);
build_all_zonelists(NULL);
page_alloc_init_cpuhp();
alloc_tag_sec_init();

page_ext_init_flatmem();
mem_debugging_and_hardening_init();
kfence_alloc_pool_and_metadata();
report_meminit();
kmsan_init_shadow();
stack_depot_early_init();

kho_memory_init();

memblock_free_all();
mem_init();
kmem_cache_init();

page_ext_init_flatmem_late();
kmemleak_init();
ptlock_cache_init();
pgtable_cache_init();
debug_objects_mem_init();
vmalloc_init();

if (!deferred_struct_pages)
page_ext_init();

init_espfix_bsp();
pti_init();
kmsan_init_runtime();
mm_cache_init();
execmem_init();
}

호출 흐름

커널 부팅
├── mm_core_init_early()
│   ├── hugetlb_cma_reserve()
│   ├── hugetlb_bootmem_alloc()
│   └── free_area_init()
│       ├── arch_zone_limits_init()
│       ├── sparse_init()
│       ├── find_zone_movable_pfns_for_nodes()
│       └── for_each_node()
│           └── free_area_init_node()
│               ├── get_pfn_range_for_nid()
│               ├── calculate_node_totalpages()
│               ├── alloc_node_mem_map()
│               └── free_area_init_core()
│                   ├── pgdat_init_internals()
│                   └── for_each_zone()
│                       └── zone_init_internals()
│
└── mm_core_init()
├── arch_mm_preinit()
├── build_all_zonelists()
├── page_alloc_init_cpuhp()
├── mem_debugging_and_hardening_init()
├── memblock_free_all()
├── mem_init()
├── kmem_cache_init()
├── vmalloc_init()
└── execmem_init()

조건별 비교

초기화 경로 비교

구분	mm_core_init_early()	mm_core_init()
시점	부팅 초기	부팅 후기
역할	메모리 맵 기본 구조 설정	할당자 및 디버깅 초기화
주요 함수	free_area_init()	memblock_free_all(), kmem_cache_init()
사용 가능	제한적	전체 기능 사용 가능

존 초기화 상태 비교

상태	설명	관련 함수
초기화 전	메모리 맵 미정의	memblock 단계
초기화 중	페이지 구조체 설정 중	memmap_init_range()
초기화 완료	할당 가능 상태	free_area_init_core() 완료

NUMA vs UMA 비교

구분	NUMA	UMA
노드 수	2개 이상	1개
초기화复杂度	높음 (노드별 처리)	낮음 (단일 노드)
메모리 배치	노드별 분산	연속 할당
관련 함수	early_pfn_to_nid(), get_pfn_range_for_nid()	단순 초기화

관련 문서

00-메모리 관리 개요

01-Buddy Allocator

04-Memblock

11-Compaction

13-NUMA

22-Hotplug

64-MMU 없는 시스템

참고 자료

Linux Kernel Documentation - mm/

Linux Kernel Source - mm/mm_init.c