VM 통계 (vmstat)

개요 (Overview)

VM 통계는 리눅스 커널의 가상 메모리 시스템 동작을 모니터링하고 분석하기 위한 카운터 집합입니다. /proc/vmstat, /proc/meminfo, /proc/buddyinfo, /proc/pagetypeinfo 등의 인터페이스를 통해 사용자 공간에 노출되며, 메모리 할당, 회수, 단편화, 페이지 폴트 등의 이벤트를 추적합니다. 마치 자동차 계기판처럼 메모리 시스템의 건강 상태를 실시간으로 보여주는 역할을 합니다.

이 시스템은 per-CPU 카운터를 사용하여 락 경쟁을 최소화하고, 주기적으로 전역 카운터로 병합(folding)하는 구조를 가지고 있습니다. CONFIG_VM_EVENT_COUNTERS와 CONFIG_SMP 설정에 따라 동작하며, NUMA 환경에서는 추가적인 NUMA 이벤트 카운터를 관리합니다. 메모리 압력이 발생할 때 watermark 기반으로 드리프트를 계산하여 시스템이 적절히 대응하도록 돕습니다.

소스 파일 경로:
├── mm/vmstat.c                    ← 핵심 구현 (카운터 관리, /proc 인터페이스)
├── include/linux/vmstat.h         ← vm_event_state, per_cpu_zonestat 인터페이스
├── include/linux/mmzone.h         ← per_cpu_zonestat, per_cpu_nodestat 정의
└── include/linux/vm_event_item.h  ← NR_VM_EVENT_ITEMS 등 열거형

---

빠른 점검 명령

# /proc/vmstat 전체 내용 확인
cat /proc/vmstat

# 특정 VM 통계 항목 확인 (예: pgfault, pgmajfault)
grep -E "pgfault|pgmajfault|pgpgin|pgpgout|pswpin|pswpout" /proc/vmstat

# 메모리 압력 관련 통계 확인
grep -E "allocstall|compact_stall|drop_pagecache|drop_slab" /proc/vmstat

# 페이지 회수 관련 통계 확인
grep -E "pgscan_kswapd|pgsteal_kswapd|pgscan_direct|pgsteal_direct" /proc/vmstat

# NUMA 이벤트 통계 확인 (NUMA 시스템에서)
grep -E "numa_hit|numa_miss|numa_foreign|numa_local|numa_remote" /proc/vmstat 2>/dev/null || echo "NUMA 통계 없음"

# VM 이벤트 카운터 활성화 여부 확인
zcat /proc/config.gz 2>/dev/null | grep CONFIG_VM_EVENT_COUNTERS || \
grep CONFIG_VM_EVENT_COUNTERS /boot/config-$(uname -r) 2>/dev/null || echo "확인 불가"

# SMP 관련 설정 확인
zcat /proc/config.gz 2>/dev/null | grep CONFIG_SMP || \
grep CONFIG_SMP /boot/config-$(uname -r) 2>/dev/null || echo "확인 불가"

# vmstat 명령어로 실시간 모니터링
vmstat 1 5

# vmstat 명령어로 특정 카운터만 확인
vmstat -s | head -20

# 통계 새로고침 (root 필요)
echo 1 > /proc/sys/vm/stat_refresh 2>/dev/null || echo "stat_refresh 지원 안 함"

# 구조체 크기 확인 (커널 소스 기준)
grep -n "struct vm_event_state" /home/ryotta205/Chamber_linux/linux-7.0-source/include/linux/vmstat.h

# per_cpu_zonestat 구조체 확인
grep -n "struct per_cpu_zonestat" /home/ryotta205/Chamber_linux/linux-7.0-source/include/linux/mmzone.h

# per_cpu_nodestat 구조체 확인
grep -n "struct per_cpu_nodestat" /home/ryotta205/Chamber_linux/linux-7.0-source/include/linux/mmzone.h

# /proc/meminfo에서 기본 메모리 정보 확인
cat /proc/meminfo | head -20

---

핵심 자료구조

1. `vm_event_state` (include/linux/vmstat.h:51)

/* per-CPU VM 이벤트 카운터 구조체 */
struct vm_event_state {
unsigned long event[NR_VM_EVENT_ITEMS];  // 이벤트별 카운터 배열
};

설명: 각 CPU마다 하나씩 존재하는 VM 이벤트 카운터입니다. NR_VM_EVENT_ITEMS 크기의 배열을 가지며, 페이지 폴트, 스왑 인/아웃, IO 이벤트 등의 카운터를 저장합니다. per-CPU로 관리되어 락 경쟁이 없습니다.

2. `per_cpu_zonestat` (include/linux/mmzone.h:762)

/* per-CPU 존별 통계 구조체 */
struct per_cpu_zonestat {
#ifdef CONFIG_SMP
s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];  // 존별 카운터 차이값 (drift)
s8 stat_threshold;                         // 드리프트 임계값
#endif
#ifdef CONFIG_NUMA
/* NUMA 이벤트 카운터 (정확하지 않음, 필요 시 폴딩) */
unsigned long vm_numa_event[NR_VM_NUMA_EVENT_ITEMS];
#endif
};

설명: 각 CPU별, 존별로 존재하는 통계 구조체입니다. SMP 환경에서는 per-CPU 카운터와 전역 카운터 사이의 차이값(vm_stat_diff)을 저장하여 드리프트를 관리합니다. NUMA 환경에서는 NUMA 이벤트 카운터도 포함합니다.

3. `per_cpu_nodestat` (include/linux/mmzone.h:777)

/* per-CPU 노드별 통계 구조체 */
struct per_cpu_nodestat {
s8 stat_threshold;                      // 드리프트 임계값
s8 vm_node_stat_diff[NR_VM_NODE_STAT_ITEMS];  // 노드별 카운터 차이값
};

설명: 각 CPU별, 메모리 노드별로 존재하는 통계 구조체입니다. 존 통계와 마찬가지로 per-CPU 카운터와 전역 카운터 사이의 차이값을 저장하여 드리프트를 관리합니다.

4. 전역 카운터 변수들 (mm/vmstat.c:165)

/* 전역 존별 페이지 상태 카운터 */
atomic_long_t vm_zone_stat[NR_VM_ZONE_STAT_ITEMS] __cacheline_aligned_in_smp;

/* 전역 노드별 페이지 상태 카운터 */
atomic_long_t vm_node_stat[NR_VM_NODE_STAT_ITEMS] __cacheline_aligned_in_smp;

/* 전역 NUMA 이벤트 카운터 */
atomic_long_t vm_numa_event[NR_VM_NUMA_EVENT_ITEMS] __cacheline_aligned_in_smp;

설명: 시스템 전체의 존별, 노드별, NUMA별 페이지 상태를 저장하는 전역 atomic 카운터입니다. __cacheline_aligned_in_smp로 캐시 라인 정렬되어 SMP 환경에서 성능이 최적화됩니다.

5. `vmstat_op` 시퀀스 연산 (mm/vmstat.c:1956)

/* /proc/vmstat을 위한 seq_file 연산 */
static const struct seq_operations vmstat_op = {
.start  = vmstat_start,   // 시작 위치 반환
.next   = vmstat_next,    // 다음 항목 반환
.stop   = vmstat_stop,    // 메모리 해제
.show   = vmstat_show,    // 각 항목 표시
};

설명: /proc/vmstat 파일 읽기를 위한 seq_file 인터페이스입니다. vmstat_start에서 모든 카운터 값을 수집하고, vmstat_show에서 각 항목을 name value 형식으로 출력합니다.

---

핵심 함수

1. `vmstat_start` (mm/vmstat.c:1878)

/* /proc/vmstat 읽기 시작 시 호출 */
static void *vmstat_start(struct seq_file *m, loff_t *pos)
{
unsigned long *v;
int i;

if (*pos >= NR_VMSTAT_ITEMS)
return NULL;

/* 모든 카운터 값을 배열에 수집 */
BUILD_BUG_ON(ARRAY_SIZE(vmstat_text) != NR_VMSTAT_ITEMS);
fold_vm_numa_events();  // NUMA 이벤트 폴딩
v = kmalloc_array(NR_VMSTAT_ITEMS, sizeof(unsigned long), GFP_KERNEL);
m->private = v;
if (!v)
return ERR_PTR(-ENOMEM);

/* 존별 카운터 수집 */
for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
v[i] = global_zone_page_state(i);
v += NR_VM_ZONE_STAT_ITEMS;

/* NUMA 이벤트 카운터 수집 */
for (i = 0; i < NR_VM_NUMA_EVENT_ITEMS; i++)
v[i] = global_numa_event_state(i);
v += NR_VM_NUMA_EVENT_ITEMS;

/* 노드별 카운터 수집 */
for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++) {
v[i] = global_node_page_state_pages(i);
if (vmstat_item_print_in_thp(i))
v[i] /= HPAGE_PMD_NR;
}
v += NR_VM_NODE_STAT_ITEMS;

/* 전역 통계 수집 */
global_dirty_limits(v + NR_DIRTY_BG_THRESHOLD, v + NR_DIRTY_THRESHOLD);
v[NR_MEMMAP_PAGES] = atomic_long_read(&nr_memmap_pages);
v[NR_MEMMAP_BOOT_PAGES] = atomic_long_read(&nr_memmap_boot_pages);
v += NR_VM_STAT_ITEMS;

/* VM 이벤트 카운터 수집 */
all_vm_events(v);
v[PGPGIN] /= 2;  // 섹터 → KB 변환
v[PGPGOUT] /= 2;

return (unsigned long *)m->private + *pos;
}

역할: /proc/vmstat 파일 읽기 시작 시 모든 카운터 값을 배열에 수집합니다. per-CPU 카운터들을 전역 카운터로 병합한 후 반환합니다.

2. `vmstat_show` (mm/vmstat.c:1931)

/* 각 VM 통계 항목을 출력 */
static int vmstat_show(struct seq_file *m, void *arg)
{
unsigned long *l = arg;
unsigned long off = l - (unsigned long *)m->private;

/* "이름 값" 형식으로 출력 */
seq_puts(m, vmstat_text[off]);
seq_put_decimal_ull(m, " ", *l);
seq_putc(m, '\n');

/* 마지막 항목인 경우 deprecated 카운터 추가 */
if (off == NR_VMSTAT_ITEMS - 1) {
seq_puts(m, "nr_unstable 0\n");
}
return 0;
}

역할: 수집된 각 카운터를 이름 값 형식으로 출력합니다. vmstat_text 배열에서 항목 이름을 가져옵니다.

3. `all_vm_events` (mm/vmstat.c:133)

/* 모든 CPU의 VM 이벤트 카운터를 전역으로 합산 */
void all_vm_events(unsigned long *ret)
{
cpus_read_lock();
sum_vm_events(ret);
cpus_read_unlock();
}

역할: 모든 CPU의 per-CPU VM 이벤트 카운터를 전역으로 합산합니다. cpus_read_lock()으로 CPU 핫플러그를 보호합니다.

4. `vm_events_fold_cpu` (mm/vmstat.c:147)

/* 특정 CPU의 이벤트를 전역 카운터로 병합 (fold) */
void vm_events_fold_cpu(int cpu)
{
struct vm_event_state *fold_state = &per_cpu(vm_event_states, cpu);
int i;

for (i = 0; i < NR_VM_EVENT_ITEMS; i++) {
count_vm_events(i, fold_state->event[i]);  // 전역 카운터에 추가
fold_state->event[i] = 0;  // per-CPU 카운터 초기화
}
}

역할: 특정 CPU가 오프라인될 때 해당 CPU의 per-CPU 카운터를 전역 카운터로 병합하고 per-CPU 카운터를 초기화합니다.

5. `__mod_zone_page_state` (mm/vmstat.c:345)

/* 존별 페이지 상태 카운터 수정 (인터럽트 비활성화 상태에서 사용) */
void __mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
long delta)
{
struct per_cpu_zonestat __percpu *pcp = zone->per_cpu_zonestats;
s8 __percpu *p = pcp->vm_stat_diff + item;
long x;
long t;

/* PREEMPT_RT 커널에서는 preemption 비활성화로 원자성 보장 */
preempt_disable_nested();

x = delta + __this_cpu_read(*p);     // per-CPU 차이값에 delta 더하기
t = __this_cpu_read(pcp->stat_threshold);  // 임계값 읽기

/* 임계값의 절대값을 초과하면 전역 카운터에 반영 */
if (unlikely(abs(x) > t)) {
zone_page_state_add(x, zone, item);
x = 0;
}
__this_cpu_write(*p, x);             // per-CPU 카운터 저장

preempt_enable_nested();
}

역할: 존별 페이지 상태 카운터를 수정할 때 per-CPU 차이값을 업데이트하고, 임계값의 절대값을 초과하면 전역 카운터에 반영합니다. preempt_disable_nested()/preempt_enable_nested()로 원자성을 보장하며, 락 없이도 빠르게 카운터를 업데이트할 수 있게 합니다.

6. `__mod_node_page_state` (mm/vmstat.c:376)

/* 노드별 페이지 상태 카운터 수정 */
void __mod_node_page_state(struct pglist_data *pgdat, enum node_stat_item item,
long delta)
{
struct per_cpu_nodestat __percpu *pcp = pgdat->per_cpu_nodestats;
s8 __percpu *p = pcp->vm_node_stat_diff + item;
long x;
long t;

/* 바이트 단위 항목은 페이지 단위로 변환 */
if (vmstat_item_in_bytes(item)) {
VM_WARN_ON_ONCE(delta & (PAGE_SIZE - 1));
delta >>= PAGE_SHIFT;
}

preempt_disable_nested();

x = delta + __this_cpu_read(*p);
t = __this_cpu_read(pcp->stat_threshold);

if (unlikely(abs(x) > t)) {
node_page_state_add(x, pgdat, item);
x = 0;
}
__this_cpu_write(*p, x);

preempt_enable_nested();
}

역할: 노드별 페이지 상태 카운터를 수정할 때 per-CPU 차이값을 업데이트합니다. vm_stat_item_in_bytes()가 true인 항목(예: NR_SLAB_RECLAIMABLE_B)은 바이트를 페이지 단위로 변환하여 저장합니다.

7. `vmstat_cpu_dead` (mm/vmstat.c:2204)

/* CPU 오프라인 시 호출됨 */
static int vmstat_cpu_dead(unsigned int cpu)
{
const struct cpumask *node_cpus;
int node;

node = cpu_to_node(cpu);

refresh_zone_stat_thresholds();   // 존별 임계값 재계산
node_cpus = cpumask_of_node(node);
if (!cpumask_empty(node_cpus))
return 0;

node_clear_state(node, N_CPU);    // 노드에 CPU 없으면 N_CPU 해제

return 0;
}

역할: CPU 오프라인 시 존별 드리프트 임계값을 재계산합니다. 해당 노드에 온라인 CPU가 없으면 N_CPU 상태를 해제합니다.

8. `refresh_zone_stat_thresholds` (mm/vmstat.c:275)

/* 모든 존의 드리프트 임계값을 갱신 */
void refresh_zone_stat_thresholds(void)
{
struct pglist_data *pgdat;
struct zone *zone;
int cpu;
int threshold;

/* 기존 노드 임계값 초기화 */
for_each_online_pgdat(pgdat) {
for_each_online_cpu(cpu) {
per_cpu_ptr(pgdat->per_cpu_nodestats, cpu)->stat_threshold = 0;
}
}

for_each_populated_zone(zone) {
struct pglist_data *pgdat = zone->zone_pgdat;
unsigned long max_drift, tolerate_drift;

threshold = calculate_normal_threshold(zone);

for_each_online_cpu(cpu) {
per_cpu_ptr(zone->per_cpu_zonestats, cpu)->stat_threshold
= threshold;

/* 가장 큰 존의 임계값을 노드 임계값으로 설정 */
int pgdat_threshold = per_cpu_ptr(pgdat->per_cpu_nodestats, cpu)->stat_threshold;
per_cpu_ptr(pgdat->per_cpu_nodestats, cpu)->stat_threshold
= max(threshold, pgdat_threshold);
}

/* percpu_drift_mark: min watermark 위반 위험 시 설정 */
tolerate_drift = low_wmark_pages(zone) - min_wmark_pages(zone);
max_drift = num_online_cpus() * threshold;
if (max_drift > tolerate_drift)
zone->percpu_drift_mark = high_wmark_pages(zone) + max_drift;
}
}

역할: 모든 온라인 존의 per-CPU 드리프트 임계값을 재계산합니다. 임계값은 CPU 수와 존 크기에 따라 로그 스케일로 결정됩니다. 최대값은 125입니다.

9. `calculate_normal_threshold` (mm/vmstat.c:225)

/* 일반 시나리오 드리프트 임계값 계산 */
int calculate_normal_threshold(struct zone *zone)
{
int threshold;
int mem;    /* 128MB 단위 메모리 */

mem = zone_managed_pages(zone) >> (27 - PAGE_SHIFT);
threshold = 2 * fls(num_online_cpus()) * (1 + fls(mem));
threshold = min(125, threshold);

return threshold;
}

역할: CPU 수와 존 크기를 기반으로 드리프트 임계값을 계산합니다. fls()를 사용한 로그 스케일링으로 CPU 수가 많거나 메모리가 클수록 임계값이 높아집니다.

10. `calculate_pressure_threshold` (mm/vmstat.c:201)

/* 메모리 압력 시나리오 드리프트 임계값 계산 */
int calculate_pressure_threshold(struct zone *zone)
{
int threshold;
int watermark_distance;

/* low - min 워터마크 차이에서 임계값 산출 */
watermark_distance = low_wmark_pages(zone) - min_wmark_pages(zone);
threshold = max(1, (int)(watermark_distance / num_online_cpus()));
threshold = min(125, threshold);

return threshold;
}

역할: 메모리 압력 상황에서 min watermark 위반을 방지하도록 보수적인 임계값을 계산합니다. set_pgdat_percpu_threshold()에서 vmscan이 호출될 때 사용됩니다.

---

호출 흐름

1. /proc/vmstat 읽기 흐름

cat /proc/vmstat
↓
seq_read()
↓
vmstat_op.start (vmstat_start)
├── fold_vm_numa_events()          ← NUMA 이벤트 폴딩
├── global_zone_page_state()       ← 존별 카운터 수집
├── global_numa_event_state()      ← NUMA 이벤트 수집
├── global_node_page_state_pages() ← 노드별 카운터 수집
├── global_dirty_limits()          ← 더티 한도 수집
└── all_vm_events()                ← VM 이벤트 수집
↓
vmstat_op.show (vmstat_show)
├── seq_puts(vmstat_text[off])     ← 항목 이름 출력
└── seq_put_decimal_ull(value)     ← 카운터 값 출력
↓
vmstat_op.next (vmstat_next)
↓
vmstat_op.stop (vmstat_stop)
└── kfree(m->private)             ← 메모리 해제

2. VM 카운터 업데이트 흐름

메모리 이벤트 발생 (예: 페이지 할당)
↓
__mod_zone_page_state(zone, item, delta)  (mm/vmstat.c:345)
├── preempt_disable_nested()
├── x = delta + __this_cpu_read(*p)   ← per-CPU 차이값에 delta 더하기
├── t = __this_cpu_read(stat_threshold) ← 임계값 읽기
├── abs(x) > t 이면
│   ├── zone_page_state_add(x)        ← 전역 카운터에 반영
│   └── x = 0
└── __this_cpu_write(*p, x)           ← per-CPU 카운터 저장

3. CPU 오프라인 시 카운터 병합 흐름

CPU 오프라인
↓
vmstat_cpu_dead(cpu)  (mm/vmstat.c:2204)
├── refresh_zone_stat_thresholds() ← 존별 임계값 재계산
└── (노드에 남은 CPU 없으면)
└── node_clear_state(node, N_CPU)

CPU 오프라인 +존 비활성화 시
↓
drain_zonestat(zone, pzstats)  (mm/vmstat.c:948)
├── zone_page_state_add()    ← 존별 차이값 전역 반영
└── zone_numa_event_add()    ← NUMA 이벤트 전역 반영

---

조건별 비교

VM 카운터 유형 비교

카운터 유형	저장 위치	업데이트 방식	용도
VM Zone Stat	per-CPU + 전역	차이값 기반 임계값	존별 페이지 상태
VM Node Stat	per-CPU + 전역	차이값 기반 임계값	노드별 페이지 상태
VM Event Stat	per-CPU	주기적 폴딩	VM 이벤트 발생 횟수
VM NUMA Event	per-CPU + 존별 + 전역	차이값 기반	NUMA 이벤트

드리프트 관리 방식 비교

구조체	필드	역할
per_cpu_zonestat	vm_stat_diff[]	존별 카운터 차이값
per_cpu_zonestat	stat_threshold	드리프트 임계값
per_cpu_nodestat	vm_node_stat_diff[]	노드별 카운터 차이값
per_cpu_nodestat	stat_threshold	드리프트 임계값

/proc 인터페이스 비교

파일	내용	형식
/proc/vmstat	VM 통계 카운터	텍스트 (이름-값 쌍)
/proc/meminfo	메모리 요약 정보	텍스트 (이름-값-단위)
/proc/buddyinfo	버디 할당자 상태	텍스트 (노드, 존, 주문별)
/proc/pagetypeinfo	페이지 타입별 정보	텍스트 (이동 타입별)

---

관련 문서

00-overview.html — 메모리 관리 개요

01-page_alloc.html — 버디 할당자

05-page_reclaim.html — 페이지 회수

12-folio.html — 폴리오 / 페이지 캐시

32-workingset.html — 워킹셋

39-vmpressure.html — VM 압력

---

참고 사항

VM 통계는 시스템 성능 분석과 메모리 문제 진단에 필수적입니다.

per-CPU 카운터 구조로 SMP 환경에서 높은 성능을 유지합니다.

드리프트 임계값은 CPU 수와 메모리 크기에 따라 동적으로 계산됩니다.

NUMA 이벤트는 정확하지 않으므로 필요 시 수동으로 폴딩이 필요합니다.

/proc/sys/vm/stat_refresh를 통해 수동으로 카운터를 새로고침할 수 있습니다.