CMA 디버깅 (CMA DebugFS)

개요 (Overview)

CMA DebugFS는 런타임에 CMA 영역의 상태를 관찰하고 테스트할 수 있는 디버깅 인터페이스입니다. CONFIG_CMA_DEBUGFS 옵션이 활성화되면 /sys/kernel/debug/cma/ 디렉토리에 각 CMA 영역별 하위 디렉토리가 생성되며, 할당/해제 테스트, 비트맵 덤프, 사용량 확인 등의 작업을 수행할 수 있습니다. 이 인터페이스는 주로 CMA 영역 설계 시 멀티 레인지 구성이 올바른지 확인하거나, unmovable 페이지 침투로 인한 할당 실패를 진단할 때 활용됩니다.

Linux 7.0에서 CMA DebugFS는 멀티 레인지(multi-range) 지원을 반영하여 각 레인지별 비트맵과 base PFN을 개별적으로 노출합니다. 또한 cma_alloc/cma_free 디버그 파일을 통해 수동으로 할당/해제를 수행할 수 있어, 실제 드라이버 없이도 CMA 동작을 검증할 수 있습니다.

소스 파일:
mm/cma_debug.c                 ← DebugFS 인터페이스 구현 (212줄)
mm/cma.h                       ← 내부 구조체 (cma, cma_memrange)
include/linux/cma.h            ← 외부 API 헤더

---

빠른 점검 명령

# CMA 영역 디버그 디렉토리 확인
sudo ls /sys/kernel/debug/cma/

# CMA 영역별 총 페이지 수 / 사용 중인 페이지 수 / 최대 연속 빈 블록
cat /sys/kernel/debug/cma/cma-0/count
cat /sys/kernel/debug/cma/cma-0/used
cat /sys/kernel/debug/cma/cma-0/maxchunk

# order_per_bit 확인 (비트맵 해상도)
cat /sys/kernel/debug/cma/cma-0/order_per_bit

# 멀티 레인지 각 범위의 base PFN 확인
cat /sys/kernel/debug/cma/cma-0/ranges/0/base_pfn
cat /sys/kernel/debug/cma/cma-0/ranges/1/base_pfn

# 멀티 레인지 비트맵 확인 (텍스트로 출력)
cat /sys/kernel/debug/cma/cma-0/ranges/0/bitmap

# 수동 할당 테스트 (16 페이지 할당)
echo 16 | sudo tee /sys/kernel/debug/cma/cma-0/alloc

# 수동 해제 테스트 (16 페이지 해제)
echo 16 | sudo tee /sys/kernel/debug/cma/cma-0/free

# /proc/meminfo에서 CMA 현황 확인
cat /proc/meminfo | grep -i cma

# CMA pageblock 마이그레이션 타입 확인
cat /proc/pagetypeinfo | grep CMA

# dmesg에서 CMA 관련 메시지 확인
dmesg | grep -i cma

---

핵심 자료구조

struct cma_mem — 디버그 할당 추적 (`mm/cma_debug.c:18-22`)

struct cma_mem {
struct hlist_node node;   // 해시 리스트 노드 (mem_head 연결)
struct page *p;           // 할당된 페이지 시작 주소
unsigned long n;          // 할당된 페이지 수
};

설명: cma_alloc/cma_free 디버그 파일을 통해 수동 할당된 페이지 블록을 추적합니다. cma 구조체의 mem_head 해시 리스트에 연결되며, free 호출 시 이 리스트에서 꺼내어 순차적으로 해제합니다.

struct cma — CMA 영역 관리자 (`mm/cma.h:39-65`)

struct cma {
unsigned long   count;            // 총 페이지 수
unsigned long   available_count;  // 사용 가능한 페이지 수
unsigned int order_per_bit;       // 비트맵 1비트당 페이지 수 (2^order)
spinlock_t      lock;             // 비트맵 동시성 제어
struct mutex    alloc_mutex;      // 할당 시 직렬화
struct hlist_head mem_head;       // 디버그 할당 리스트 (CONFIG_CMA_DEBUGFS)
spinlock_t      mem_head_lock;    // mem_head 동시성 제어
char name[CMA_MAX_NAME];         // 영역 이름
int nranges;                      // 실제 레인지 수 (1~8)
struct cma_memrange ranges[CMA_MAX_RANGES]; // 멀티 레인지 배열
unsigned long flags;              // CMA_ACTIVATED 등 플래그
int nid;                          // NUMA 노드 ID
};

설명: mem_head와 mem_head_lock은 CONFIG_CMA_DEBUGFS가 활성화될 때만 존재하며, 수동 할당된 cma_mem 항목들의 해시 리스트를 관리합니다. available_count는 count - used로 계산되며, cma_used_get()이 이 값을 읽습니다.

struct cma_memrange — 개별 물리 범위 (`mm/cma.h:26-36`)

struct cma_memrange {
unsigned long base_pfn;    // 범위 시작 PFN
unsigned long count;       // 범위 내 페이지 수
union {
unsigned long early_pfn;  // cma_reserve_early()에서 사용
unsigned long *bitmap;    // 활성화 후 할당 비트맵
};
struct debugfs_u32_array dfs_bitmap;  // debugfs 비트맵 노출용
};

설명: dfs_bitmap은 cma_debugfs_add_one()에서 bitmap 필드를 직접 할당하여 debugfs에 u32 배열로 노출합니다. array는 bitmap의 시작 주소를, n_elements는 cma_bitmap_maxno() 계산값을 저장합니다.

cma_debugfs_fops — debugfs 파일 운영 체계 (`mm/cma_debug.c:24-32`)

static int cma_debugfs_get(void *data, u64 *val)
{
unsigned long *p = data;
*val = *p;
return 0;
}
DEFINE_DEBUGFS_ATTRIBUTE(cma_debugfs_fops, cma_debugfs_get, NULL, "%llu\n");

설명: count, order_per_bit, base_pfn 같은 읽기 전용 값을 표시할 때 사용되는 일반 디버그 파일 운영 체계입니다. DEFINE_DEBUGFS_ATTRIBUTE 매크로로 open, read, write 핸들러가 자동 생성됩니다.

---

핵심 함수

1. `cma_debugfs_init()` — 전체 초기화 (`mm/cma_debug.c:200-211`)

static int __init cma_debugfs_init(void)
{
struct dentry *cma_debugfs_root;
int i;

cma_debugfs_root = debugfs_create_dir("cma", NULL);

for (i = 0; i < cma_area_count; i++)
cma_debugfs_add_one(&cma_areas[i], cma_debugfs_root);

return 0;
}
late_initcall(cma_debugfs_init);

역할: /sys/kernel/debug/cma/ 루트 디렉토리를 생성하고, 등록된 모든 CMA 영역에 대해 cma_debugfs_add_one()을 호출합니다.

분기 로직:

1. late_initcall에서 호출 — 모든 CMA 영역이 초기화된 후 실행

2. cma_area_count만큼 반복하며 각 cma_areas[i]에 대한 디버그 파일 생성

2. `cma_debugfs_add_one()` — 영역별 디버그 파일 생성 (`mm/cma_debug.c:161-198`)

static void cma_debugfs_add_one(struct cma *cma, struct dentry *root_dentry)
{
struct dentry *tmp, *dir, *rangedir;
int r;
char rdirname[12];
struct cma_memrange *cmr;

tmp = debugfs_create_dir(cma->name, root_dentry);

debugfs_create_file("alloc", 0200, tmp, cma, &cma_alloc_fops);
debugfs_create_file("free", 0200, tmp, cma, &cma_free_fops);
debugfs_create_file("count", 0444, tmp, &cma->count, &cma_debugfs_fops);
debugfs_create_file("order_per_bit", 0444, tmp,
&cma->order_per_bit, &cma_debugfs_fops);
debugfs_create_file("used", 0444, tmp, cma, &cma_used_fops);
debugfs_create_file("maxchunk", 0444, tmp, cma, &cma_maxchunk_fops);

rangedir = debugfs_create_dir("ranges", tmp);
for (r = 0; r < cma->nranges; r++) {
cmr = &cma->ranges[r];
snprintf(rdirname, sizeof(rdirname), "%d", r);
dir = debugfs_create_dir(rdirname, rangedir);
debugfs_create_file("base_pfn", 0444, dir,
&cmr->base_pfn, &cma_debugfs_fops);
cmr->dfs_bitmap.array = (u32 *)cmr->bitmap;
cmr->dfs_bitmap.n_elements =
DIV_ROUND_UP(cma_bitmap_maxno(cma, cmr),
BITS_PER_BYTE * sizeof(u32));
debugfs_create_u32_array("bitmap", 0444, dir,
&cmr->dfs_bitmap);
}

debugfs_create_symlink("base_pfn", tmp, "ranges/0/base_pfn");
debugfs_create_symlink("bitmap", tmp, "ranges/0/bitmap");
}

역할: 하나의 CMA 영역에 대해 6개의 디버그 파일과 ranges/ 하위 디렉토리를 생성합니다. 하위 호환을 위해 base_pfn과 bitmap의 심볼릭 링크도 만듭니다.

분기 로직:

1. alloc/free: 쓰기 전용 (0200) — 수동 할당/해제

2. count/order_per_bit: 직접 &cma->count 등에 연결 (읽기 전용)

3. used: cma_used_get() 사용 — count - available_count 계산

4. maxchunk: cma_maxchunk_get() 사용 — 모든 레인지의 비트맵을 순회하여 최대 연속 빈 블록 계산

5. ranges/N/: 각 레인지별 base_pfn과 bitmap u32 배열 노출

3. `cma_used_get()` — 사용량 계산 (`mm/cma_debug.c:34-43`)

static int cma_used_get(void *data, u64 *val)
{
struct cma *cma = data;

spin_lock_irq(&cma->lock);
*val = cma->count - cma->available_count;
spin_unlock_irq(&cma->lock);

return 0;
}

역할: count(전체)에서 available_count(사용 가능)를 빼서 현재 사용 중인 페이지 수를 반환합니다.

4. `cma_maxchunk_get()` — 최대 연속 빈 블록 계산 (`mm/cma_debug.c:46-66`)

static int cma_maxchunk_get(void *data, u64 *val)
{
struct cma *cma = data;
struct cma_memrange *cmr;
unsigned long maxchunk = 0;
unsigned long start, end;
unsigned long bitmap_maxno;
int r;

spin_lock_irq(&cma->lock);
for (r = 0; r < cma->nranges; r++) {
cmr = &cma->ranges[r];
bitmap_maxno = cma_bitmap_maxno(cma, cmr);
for_each_clear_bitrange(start, end, cmr->bitmap, bitmap_maxno)
maxchunk = max(end - start, maxchunk);
}
spin_unlock_irq(&cma->lock);
*val = (u64)maxchunk << cma->order_per_bit;

return 0;
}

역할: 모든 레인지의 비트맵을 순회하며 가장 큰 연속 빈 영역(0 비트 범위)의 크기를 반환합니다. CMA 할당이 가능한 최대 블록 크기를 알려줍니다.

분기 로직:

1. cma->nranges만큼 반복

2. for_each_clear_bitrange()로 각 레인지의 빈 비트 범위 탐색

3. maxchunk = max(end - start, maxchunk)으로 최대값 갱신

4. << cma->order_per_bit로 페이지 수로 변환

5. `cma_alloc_mem()` / `cma_free_mem()` — 수동 할당/해제 (`mm/cma_debug.c:90-158`)

static int cma_alloc_mem(struct cma *cma, int count)
{
struct cma_mem *mem;
struct page *p;

mem = kzalloc_obj(*mem);
if (!mem)
return -ENOMEM;

p = cma_alloc(cma, count, 0, false);
if (!p) {
kfree(mem);
return -ENOMEM;
}

mem->p = p;
mem->n = count;

cma_add_to_cma_mem_list(cma, mem);

return 0;
}

역할: alloc 디버그 파일에 페이지 수를 쓰면 cma_alloc()으로 실제 할당 후 cma_mem 리스트에 추가합니다.

static int cma_free_mem(struct cma *cma, int count)
{
struct cma_mem *mem = NULL;

while (count) {
mem = cma_get_entry_from_list(cma);
if (mem == NULL)
return 0;

if (mem->n <= count) {
cma_release(cma, mem->p, mem->n);
count -= mem->n;
kfree(mem);
} else if (cma->order_per_bit == 0) {
cma_release(cma, mem->p, count);
mem->p += count;
mem->n -= count;
count = 0;
cma_add_to_cma_mem_list(cma, mem);
} else {
pr_debug("cma: cannot release partial block when order_per_bit != 0\n");
cma_add_to_cma_mem_list(cma, mem);
break;
}
}

return 0;
}

역할: free 디버그 파일에 페이지 수를 쓰면 할당 리스트에서 순차적으로 꺼내 해제합니다.

분기 로직:

1. mem->n <= count: 블록 전체를 해제 후 kfree(mem)

2. order_per_bit == 0이고 mem->n > count: 부분 해제 가능 — mem->p와 mem->n 갱신 후 리스트에 다시 추가

3. order_per_bit != 0이고 부분 해제 불가: 디버그 메시지 출력 후 중단

---

호출 흐름

DebugFS 초기화 흐름

부팅 (late_initcall)
│
▼
cma_debugfs_init()
│
├── debugfs_create_dir("cma", NULL)    ← /sys/kernel/debug/cma/ 생성
│
└── for (i = 0; i < cma_area_count; i++)
│
└── cma_debugfs_add_one(&cma_areas[i], root)
│
├── debugfs_create_dir(cma->name)     ← cma-0/, cma-1/, ...
│
├── debugfs_create_file("alloc")      ← 쓰기 전용
├── debugfs_create_file("free")       ← 쓰기 전용
├── debugfs_create_file("count")      ← 읽기 전용
├── debugfs_create_file("order_per_bit")
├── debugfs_create_file("used")       ← cma_used_get()
├── debugfs_create_file("maxchunk")   ← cma_maxchunk_get()
│
└── ranges/ 하위 디렉토리
└── for (r = 0; r < nranges; r++)
├── base_pfn 파일
└── bitmap u32 배열

수동 할당/해제 흐름

사용자: echo 16 > /sys/kernel/debug/cma/cma-0/alloc
│
▼
cma_alloc_write(data=cma, val=16)
│
└── cma_alloc_mem(cma, 16)
│
├── kzalloc_obj(*mem)           ← cma_mem 할당
├── cma_alloc(cma, 16, 0, false) ← 실제 CMA 할당
│      └── cma_range_alloc()
│             ├── bitmap_find_next_zero_area_off()
│             ├── page_range_contiguous()
│             ├── bitmap_set()
│             └── alloc_contig_frozen_range()
│
└── cma_add_to_cma_mem_list()   ← mem_head에 추가

사용자: echo 16 > /sys/kernel/debug/cma/cma-0/free
│
▼
cma_free_write(data=cma, val=16)
│
└── cma_free_mem(cma, 16)
│
└── while (count)
├── cma_get_entry_from_list()  ← mem_head에서 꺼내기
│
├── mem->n <= count → cma_release() + kfree()
├── order_per_bit == 0 → 부분 해제 가능
└── order_per_bit != 0 → 부분 해제 불가, 중단

---

조건별 비교

DebugFS 파일 유형 비교

파일	권한	동작	함수
`alloc`	0200 (쓰기)	페이지 수 할당	`cma_alloc_write()` → `cma_alloc_mem()`
`free`	0200 (쓰기)	페이지 수 해제	`cma_free_write()` → `cma_free_mem()`
`count`	0444 (읽기)	전체 페이지 수	직접 `&cma->count` 읽기
`order_per_bit`	0444 (읽기)	비트맵 해상도	직접 `&cma->order_per_bit` 읽기
`used`	0444 (읽기)	사용 중인 페이지 수	`cma_used_get()`
`maxchunk`	0444 (읽기)	최대 연속 빈 블록	`cma_maxchunk_get()`
`ranges/N/base_pfn`	0444 (읽기)	범위 시작 PFN	직접 `&cmr->base_pfn` 읽기
`ranges/N/bitmap`	0444 (읽기)	할당 비트맵 (u32 배열)	`debugfs_create_u32_array()`

cma_free_mem() 분기 비교

조건	동작	결과
`mem->n <= count`	블록 전체 해제 + `kfree(mem)`	완전 해제
`order_per_bit == 0`且 `mem->n > count`	부분 해제 (mem->p 갱신)	부분 해제 후 리스트 복귀
`order_per_bit != 0`且 `mem->n > count`	디버그 메시지 + 중단	해제 불가

CMA 디버깅 접근 비교

접근	도구	용도
**DebugFS**	`/sys/kernel/debug/cma/`	런타임 상태 관찰, 수동 테스트
**sysfs**	`/sys/sys/kernel/mm/cma/`	통계 (성공/실패/해제 카운터)
**tracepoint**	`cma:cma_alloc_start/finish`, `cma:cma_release`	할당/해제 이벤트 추적
**dmesg**	`dmesg \	grep cma`	초기화 메시지, 에러 로그

---

관련 문서

18-cma.html — CMA 핵심 구현 (할당/해제/초기화)

01-page_alloc.html — Buddy Allocator (CMA의 하위 할당자)

11-compaction.html — Memory Compaction (CMA 할당 시 페이지 재배치)

20-migrate.html — 페이지 마이그레이션 (CMA의 핵심 메커니즘)

---

참고: DebugFS vs sysfs 통계 비교

CMA는 두 가지 인터페이스로 런타임 정보를 제공합니다:

DebugFS (/sys/kernel/debug/cma/): 디버깅용. 수동 할당/해제, 비트맵 덤프, 멀티 레인지 상세 정보 제공. CONFIG_CMA_DEBUGFS 필요.

sysfs (/sys/sys/kernel/mm/cma/): 운영용. nr_pages_succeeded, nr_pages_failed, nr_pages_released 카운터만 제공. CONFIG_CMA_SYSFS 필요.

운영 환경에서는 sysfs를, 개발/디버깅 환경에서는 DebugFS를 사용하는 것이 일반적입니다.

# sysfs 통계 확인 (CONFIG_CMA_SYSFS)
cat /sys/kernel/mm/cma/cma-0/nr_pages_succeeded
cat /sys/kernel/mm/cma/cma-0/nr_pages_failed
cat /sys/kernel/mm/cma/cma-0/nr_pages_released