procfs/sysfs/debugfs (Virtual Filesystems)

procfs, sysfs, debugfs는 커널 내부 상태를 사용자 공간에 노출하는 대표 가상 파일시스템입니다. 본 문서는 각 인터페이스의 목적과 경계, seq_file 기반 안전한 대용량 출력, kobject와 sysfs attribute 생성/소멸 수명주기, debugfs의 개발·진단 활용법, ABI 안정성 및 보안 권한 설계 원칙을 커널 모듈 코드와 함께 상세히 설명합니다.

가상 파일시스템 개요

Linux 커널은 여러 가상 파일시스템을 통해 커널 내부 정보를 사용자 공간에 노출합니다. 디스크에 데이터를 저장하지 않으며, 읽기/쓰기 시 커널 함수가 동적으로 데이터를 생성합니다.

procfs (/proc)

주요 /proc 엔트리

procfs 엔트리 생성

#include <linux/proc_fs.h>
#include <linux/seq_file.h>

static int my_proc_show(struct seq_file *m, void *v)
{
    seq_printf(m, "Hello from kernel! jiffies=%lu\\n", jiffies);
    return 0;
}

static int my_proc_open(struct inode *inode, struct file *file)
{
    return single_open(file, my_proc_show, NULL);
}

static const struct proc_ops my_proc_ops = {
    .proc_open    = my_proc_open,
    .proc_read    = seq_read,
    .proc_lseek   = seq_lseek,
    .proc_release = single_release,
};

/* 모듈 초기화 시 */
proc_create("my_entry", 0444, NULL, &my_proc_ops);

sysfs (/sys)

sysfs는 커널의 kobject 계층 구조를 파일시스템으로 노출합니다. 디바이스, 드라이버, 버스 등의 속성을 파일로 표현합니다.

#include <linux/kobject.h>
#include <linux/sysfs.h>

static int my_value = 42;

static ssize_t my_show(struct kobject *kobj,
    struct kobj_attribute *attr, char *buf)
{
    return sysfs_emit(buf, "%d\\n", my_value);
}

static ssize_t my_store(struct kobject *kobj,
    struct kobj_attribute *attr, const char *buf, size_t count)
{
    int ret = kstrtoint(buf, 10, &my_value);
    return ret ? ret : count;
}

static struct kobj_attribute my_attr =
    __ATTR(my_value, 0664, my_show, my_store);

debugfs

debugfs는 개발/디버깅 전용 인터페이스로, 가장 간단하게 커널 데이터를 노출할 수 있습니다.

#include <linux/debugfs.h>

static struct dentry *dbg_dir;
static u32 my_debug_val = 100;

static int __init my_init(void)
{
    dbg_dir = debugfs_create_dir("my_driver", NULL);
    debugfs_create_u32("my_val", 0644, dbg_dir, &my_debug_val);
    debugfs_create_bool("enabled", 0644, dbg_dir, &my_enabled);
    return 0;
}

static void __exit my_exit(void)
{
    debugfs_remove_recursive(dbg_dir);
}

seq_file 인터페이스

seq_file은 큰 데이터를 안전하게 출력하는 헬퍼입니다. 버퍼 오버플로를 자동으로 처리하고, 반복자(iterator) 패턴으로 리스트를 순회합니다.

static void *my_seq_start(struct seq_file *m, loff_t *pos)
{
    return seq_list_start(&my_list, *pos);
}

static void *my_seq_next(struct seq_file *m, void *v, loff_t *pos)
{
    return seq_list_next(v, &my_list, pos);
}

static void my_seq_stop(struct seq_file *m, void *v) { }

static int my_seq_show(struct seq_file *m, void *v)
{
    struct my_item *item = list_entry(v, struct my_item, list);
    seq_printf(m, "id=%d name=%s\\n", item->id, item->name);
    return 0;
}

static const struct seq_operations my_seq_ops = {
    .start = my_seq_start,
    .next  = my_seq_next,
    .stop  = my_seq_stop,
    .show  = my_seq_show,
};

sysctl 인터페이스

/proc/sys/ 아래의 커널 매개변수를 등록하고 관리합니다:

#include <linux/sysctl.h>

static int my_param = 100;
static int my_min = 0, my_max = 1000;

static struct ctl_table my_sysctl_table[] = {
    {
        .procname   = "my_param",
        .data       = &my_param,
        .maxlen     = sizeof(int),
        .mode       = 0644,
        .proc_handler = proc_dointvec_minmax,
        .extra1     = &my_min,
        .extra2     = &my_max,
    },
    { }
};

static struct ctl_table_header *my_sysctl_header;

static int __init my_init(void)
{
    my_sysctl_header = register_sysctl("kernel/my_driver", my_sysctl_table);
    return 0;
}

/* 사용: sysctl kernel.my_driver.my_param=500 */
/* 또는: echo 500 > /proc/sys/kernel/my_driver/my_param */

디바이스 속성 (Device Attributes)

드라이버에서 sysfs 속성을 가장 간편하게 생성하는 방법입니다:

/* DEVICE_ATTR 매크로: show/store 함수를 자동으로 연결 */
static ssize_t status_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
    struct my_priv *priv = dev_get_drvdata(dev);
    return sysfs_emit(buf, "%s\\n", priv->active ? "active" : "idle");
}

static ssize_t status_store(struct device *dev,
    struct device_attribute *attr,
    const char *buf, size_t count)
{
    struct my_priv *priv = dev_get_drvdata(dev);
    priv->active = sysfs_streq(buf, "active");
    return count;
}
static DEVICE_ATTR_RW(status);

/* 속성 그룹으로 일괄 등록 */
static struct attribute *my_attrs[] = {
    &dev_attr_status.attr,
    NULL,
};
ATTRIBUTE_GROUPS(my);

/* 드라이버에서 그룹 연결 */
static struct platform_driver my_driver = {
    .driver = {
        .name = "mydev",
        .dev_groups = my_groups,  /* 자동으로 sysfs 생성/제거 */
    },
};

바이너리 속성 (Binary sysfs Attributes)

구조화된 바이너리 데이터(EEPROM, firmware 등)를 sysfs로 노출할 때 사용합니다:

static ssize_t eeprom_read(struct file *filp,
    struct kobject *kobj,
    struct bin_attribute *attr,
    char *buf, loff_t off, size_t count)
{
    struct device *dev = kobj_to_dev(kobj);
    return read_eeprom(dev, buf, off, count);
}

static BIN_ATTR_RO(eeprom, EEPROM_SIZE);
/* → /sys/devices/.../eeprom (바이너리 파일) */

configfs

sysfs가 커널→유저 방향의 정보 노출이라면, configfs는 유저→커널 방향의 오브젝트 생성/구성입니다:

#include <linux/configfs.h>

/* configfs에서 mkdir로 새 오브젝트 생성 */
/* mkdir /sys/kernel/config/my_subsys/instance1 */
/* → make_item() 콜백 호출 → 커널 오브젝트 생성 */

/* 사용 예: USB gadget configfs */
/* mkdir /sys/kernel/config/usb_gadget/g1 */
/* echo 0x1234 > idVendor */
/* mkdir configs/c.1 */
/* mkdir functions/mass_storage.0 */

/proc 세부 경로 심화

/proc은 커널과 프로세스 상태를 사용자 공간에 노출하는 가상 파일시스템입니다. 각 경로의 정확한 의미와 활용법을 이해하면 커널 디버깅과 시스템 모니터링이 크게 향상됩니다.

프로세스별 /proc/[pid]/ 경로

# 프로세스 메모리 사용량 분석
cat /proc/1234/smaps_rollup
# Rss:              12345 kB   ← 실제 물리 메모리
# Pss:              10234 kB   ← 공유 메모리 비례 할당
# Shared_Clean:      5678 kB   ← 공유+깨끗 (라이브러리 코드)
# Shared_Dirty:       456 kB   ← 공유+더러움 (CoW 전)
# Private_Clean:     2345 kB   ← 개인+깨끗
# Private_Dirty:     3456 kB   ← 개인+더러움 (힙/스택)
# Swap:               789 kB   ← 스왑아웃된 페이지

# 프로세스의 열린 파일 확인
ls -la /proc/1234/fd/
# lrwx------ 1 user user 0 ... 0 -> /dev/pts/0
# lrwx------ 1 user user 0 ... 3 -> socket:[12345]
# lr-x------ 1 user user 0 ... 4 -> /var/log/app.log

# 프로세스의 커널 스택 확인 (D 상태 프로세스 디버깅)
cat /proc/1234/stack
# [<0>] io_schedule+0x46/0x70
# [<0>] wait_on_page_bit+0x10e/0x170
# [<0>] __filemap_fdatawait_range+0x85/0xf0

시스템 전역 /proc/ 경로

/proc/stat — 커널 전체 통계

/proc/stat은 시스템 부팅 이후 누적된 커널 통계를 제공합니다. CPU 사용 시간, 컨텍스트 스위치 횟수, 부팅 시각, 프로세스 생성 수 등 시스템 전반의 활동 지표가 포함됩니다. top, vmstat, sar 같은 도구들이 이 파일을 파싱하여 CPU 사용률을 계산합니다. CPU 행은 10개 컬럼(커널 2.6.24+)으로 구성되며, 9~10번째 컬럼이 KVM 게스트 실행 시간입니다.

# cpu  user    nice   system   idle      iowait  irq   softirq  steal  guest  guest_nice
cpu  12345678 234567 3456789 987654321 456789 98765 234567 12345 56789 1234
cpu0  3086419  58641  864197 246913580 114197  24691  58641  3086 14197  308
cpu1  3086420  58642  864198 246913581 114198  24692  58642  3087 14198  309
cpu2  3086418  58640  864196 246913579 114196  24690  58640  3085 14196  307
cpu3  3086421  58644  864198 246913581 114198  24692  58643  3087 14199  310
# intr: 첫 값=총 인터럽트 수, 이후 IRQ 0번부터 각 라인별 카운터
intr 9876543210 234 0 0 0 0 0 0 987 0 0 1234 0 0 56789 ...
ctxt 1234567890           # 총 컨텍스트 스위치 횟수
btime 1700000000          # 부팅 시각 (Unix timestamp)
processes 987654          # 총 생성된 프로세스/스레드 수
procs_running 3           # 실행 중 또는 런큐 대기 중
procs_blocked 0           # I/O 대기로 블록된 프로세스 수
# softirq: 총계 HI TIMER NET_TX NET_RX BLOCK IRQ_POLL TASKLET SCHED HRTIMER RCU
softirq 2345678901 0 987654321 12345 234567890 123456 0 78901 456789 0 234567

softirq 행 서브타입 분해: softirq 행의 컬럼 순서는 커널 버전 간 고정입니다.

#!/bin/bash
# CPU 사용률 계산: 2-샘플 차분법
cpu1=($(awk '/^cpu / {print $2,$3,$4,$5,$6,$7,$8,$9}' /proc/stat))
sleep 1
cpu2=($(awk '/^cpu / {print $2,$3,$4,$5,$6,$7,$8,$9}' /proc/stat))
total1=0; for v in "${cpu1[@]}"; do ((total1+=v)); done
total2=0; for v in "${cpu2[@]}"; do ((total2+=v)); done
dtotal=$((total2 - total1))
didle=$((cpu2[3] - cpu1[3]))    # idle delta
dsteal=$((cpu2[7] - cpu1[7]))   # steal delta
# guest(열9)는 user(열1)에 이미 포함 → 별도 차감 불필요
usage=$(( (dtotal - didle) * 100 / dtotal ))
steal_pct=$(( dsteal * 100 / dtotal ))
echo "CPU usage  : ${usage}%"
echo "steal time : ${steal_pct}%   (>5% → 클라우드 CPU 경쟁 의심)"

/proc/meminfo — 메모리 전체 현황

/proc/meminfo는 시스템 메모리의 상세 현황을 KB 단위로 보고합니다. free, top, htop 등 대부분의 메모리 모니터링 도구의 데이터 소스입니다. 가용 메모리 판단 시 MemFree보다 MemAvailable을 우선 사용해야 합니다.

MemTotal:       16384000 kB   # 물리 메모리 총량
MemFree:         1024000 kB   # 완전히 비어 있는 메모리
MemAvailable:    8192000 kB   # 실제로 할당 가능한 메모리 (추정값)
Buffers:          512000 kB   # 블록 디바이스 I/O 버퍼
Cached:          4096000 kB   # 페이지 캐시 (파일 캐시, SwapCached 제외)
SwapCached:        32768 kB   # 스왑 후 메모리로 복귀한 페이지 (스왑 슬롯 유지)
Active:          6144000 kB   # 최근 사용된 페이지
Inactive:        2560000 kB   # 오랫동안 미사용 (회수 대상)
Active(anon):    4096000 kB   # 최근 사용된 익명 페이지
Inactive(anon):   512000 kB   # 오랫동안 미사용 익명 페이지
Active(file):    2048000 kB   # 최근 사용된 파일 페이지
Inactive(file):  2048000 kB   # 오랫동안 미사용 파일 페이지
Unevictable:       65536 kB   # 회수 불가능 (mlockall, 공유 메모리 고정)
Mlocked:           65536 kB   # mlock/mlockall로 잠긴 메모리
SwapTotal:       8192000 kB   # 스왑 공간 총량
SwapFree:        8192000 kB   # 미사용 스왑 공간
Zswap:             16384 kB   # 압축 스왑 캐시 크기 (커널 6.1+)
Zswapped:         131072 kB   # Zswap에 저장된 원본 크기
Dirty:             12288 kB   # 디스크에 쓰기 대기 중인 더티 페이지
Writeback:             0 kB   # 현재 writeback 중인 페이지
AnonPages:       4608000 kB   # 매핑되지 않은 익명 페이지
Mapped:           819200 kB   # mmap으로 매핑된 파일 페이지
Shmem:            204800 kB   # tmpfs/shmem 사용량 (Active(anon)에 포함)
KReclaimable:     901120 kB   # 회수 가능한 커널 메모리 (SReclaimable 포함)
Slab:            1024000 kB   # 커널 slab 할당자 사용 총량
SReclaimable:     819200 kB   # 회수 가능한 slab (dentry/inode 캐시)
SUnreclaim:       204800 kB   # 회수 불가능한 slab (커널 구조체)
KernelStack:       65536 kB   # 커널 스택 (스레드당 8~16KB)
PageTables:        32768 kB   # 페이지 테이블 메모리
SecPageTables:         0 kB   # 보조 페이지 테이블 (arm64 등)
NFS_Unstable:          0 kB   # NFS 서버로 전송 중인 페이지 (레거시)
Bounce:                0 kB   # 32비트 DMA 바운스 버퍼 (레거시 장치용)
WritebackTmp:          0 kB   # FUSE writeback 임시 버퍼
CommitLimit:    16384000 kB   # 허용된 총 커밋 한도
Committed_AS:    8192000 kB   # 현재까지 커밋된 메모리 총량
VmallocTotal:   34359738367 kB # vmalloc 가상 주소 공간 총량
VmallocUsed:      131072 kB   # vmalloc 실제 사용량
VmallocChunk:          0 kB   # 최대 연속 vmalloc 가용 블록
Percpu:            32768 kB   # per-CPU 할당자 사용량
HardwareCorrupted:     0 kB   # ECC 오류로 격리된 메모리
AnonHugePages:    131072 kB   # Transparent Huge Pages (THP)
ShmemHugePages:        0 kB   # tmpfs의 THP
ShmemPmdMapped:        0 kB   # PMD 단위로 매핑된 shmem THP
FileHugePages:         0 kB   # 파일 THP (DAX 등)
FilePmdMapped:         0 kB   # PMD 매핑된 파일 THP
HugePages_Total:       0      # 고정 Huge Pages 총 개수
HugePages_Free:        0      # 미사용 Huge Pages
HugePages_Rsvd:        0      # 예약되었으나 미할당
HugePages_Surp:        0      # 초과 할당된 Huge Pages
Hugepagesize:       2048 kB   # 기본 Huge Page 크기
Hugetlb:               0 kB   # Huge Page 총 메모리
DirectMap4k:      524288 kB   # 4KB 페이지로 직접 매핑
DirectMap2M:    16252928 kB   # 2MB 페이지로 직접 매핑 (TLB 효율↑)
DirectMap1G:           0 kB   # 1GB 페이지로 직접 매핑 (pdpe1gb 플래그 필요)

/proc/cpuinfo — CPU 상세 정보

/proc/cpuinfo는 시스템의 각 논리 CPU 코어에 대한 상세 정보를 제공합니다. 소켓 수, 물리 코어 수, 하이퍼스레딩 여부, 지원 명령어 셋, 알려진 취약점 목록 등을 확인할 수 있습니다. 각 논리 CPU는 processor:로 구분된 별도의 블록으로 표시됩니다.

processor       : 0                 # 논리 CPU 번호 (0부터)
vendor_id       : GenuineIntel      # AMD: AuthenticAMD
cpu family      : 6                 # Intel: 6=Core 계열 / AMD: 25=Zen3, 26=Zen4
model           : 165               # cpu family + model로 정확한 마이크로아키텍처 식별
model name      : Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz
stepping        : 5
microcode       : 0xea              # 적용된 마이크로코드 버전 (취약점 완화에 중요)
cpu MHz         : 2900.000          # 현재 클럭 (turbo 포함 시 변동, 거버너 영향)
cache size      : 16384 KB          # L3 캐시 크기 (소켓당 공유)
physical id     : 0                 # 소켓 번호
siblings        : 16                # 같은 소켓의 논리 CPU 수
core id         : 0                 # 소켓 내 물리 코어 번호
cpu cores       : 8                 # 소켓의 물리 코어 수
apicid          : 0                 # APIC ID (인터럽트 라우팅용)
flags           : fpu vme de pse tsc msr ... vmx aes avx avx2 avx512f ht nx
                  pdpe1gb rdrand rdseed sgx clflushopt
bugs            : spectre_v1 spectre_v2 spec_store_bypass mds srbds
                  retbleed taa rfds bhi its
bogomips        : 5799.77           # 루프 기반 성능 지표 (비교 기준으로만 사용)
TLB size        : 2560 4K pages
clflush size    : 64                # 캐시 라인 크기 (bytes)
cache_alignment : 64
address sizes   : 39 bits physical, 48 bits virtual
power management:                   # 동적 클럭/전압 스케일링 기능 목록

주요 flags 상세:

bugs 필드 — 알려진 취약점:

AMD CPU family 매핑: family 23=Zen/Zen+/Zen2 (Ryzen 1000~3000), 25=Zen3 (Ryzen 5000), 26=Zen4 (Ryzen 7000). lscpu | grep -E "family|Model name"으로 확인.

/proc/buddyinfo — Buddy 할당자 상태

/proc/buddyinfo는 Buddy 메모리 할당자의 현재 상태를 NUMA 노드 및 메모리 존(Zone)별로 보여줍니다. 각 컬럼은 order 0(4KB, 1페이지)부터 order 10(4MB, 1024페이지)까지의 연속된 물리 메모리 블록 개수를 나타냅니다. 메모리 파편화(fragmentation) 정도를 직접 측정하는 핵심 지표입니다.

# NUMA 2-노드 시스템 예시
Node 0, zone      DMA      1      0      1      0      2      1      1      0      1      1      3
Node 0, zone    DMA32    760    234     89     56     21     10      4      2      1      0      0
Node 0, zone   Normal  12345   5678   2345    987    432    198     76     21      4      1      0
Node 0, zone  Movable      0      0      0      0      0      0      0      0      0      0      0
Node 1, zone   Normal   9876   4321   1987    765    321    145     54     12      2      0      0
#                        ↑      ↑      ↑      ↑      ↑      ↑      ↑      ↑      ↑      ↑      ↑
#              order:    0      1      2      3      4      5      6      7      8      9     10
#              크기:   4KB   8KB   16KB  32KB  64KB  128K  256K  512K   1M    2M    4MB
#              용도:   일반  일반  일반  일반  일반  일반  일반  일반  일반  THP  THP

Hugepage 할당 가능 여부 판별: order 9(2MB=512페이지) 값이 0이면 Transparent Huge Page(THP) 할당 실패. order 10(4MB) 값이 모두 0이면 정적 2MB HugePage 할당 불가.

#!/bin/bash
# 메모리 파편화 점수 계산 (높을수록 연속 메모리 많음)
# 파편화 점수 = Σ (order_N_count × 2^N × 4KB)
awk '/^Node 0, zone   Normal/ {
  score=0
  for(i=4; i<=NF; i++) {
    order=i-4
    score += $i * (2^order) * 4    # 단위: KB
  }
  printf "Normal zone 연속 메모리: %.1f MB\n", score/1024
  # THP(2MB) 가능 여부: order 9 = 열 13 (4+9=13번째)
  printf "order-9(2MB) 블록: %d개 (THP 가능: %s)\n", $13, ($13>0?"YES":"NO")
}' /proc/buddyinfo

# /proc/pagetypeinfo 연계: Movable/Unmovable/Reclaimable 구분
grep "Normal" /proc/pagetypeinfo | grep -E "Movable|Unmovable"

/proc/crypto — 암호화 알고리즘 목록

/proc/crypto는 커널에 등록된 모든 암호화 알고리즘의 목록과 상세 속성을 표시합니다. 하드웨어 가속 알고리즘과 소프트웨어 폴백 구현이 모두 나열되며, 동일 알고리즘에 여러 드라이버가 존재할 수 있습니다. dm-crypt, TLS, IPsec 등이 사용하는 알고리즘을 확인하는 데 유용합니다.

# 블록 암호 (cipher)
name         : aes
driver       : aes-aesni          # 드라이버명 접미사: -aesni(HW가속)/-avx2/-ssse3/-generic
module       : aesni_intel
priority     : 400                # 높을수록 선호 (하드웨어 가속 구현 > 소프트웨어)
refcnt       : 3                  # 0=미사용, 양수=현재 활성 (언로드 불가)
selftest     : passed
internal     : no                 # yes=래퍼 알고리즘 빌딩블록 (직접 사용 불가)
type         : cipher
blocksize    : 16
min keysize  : 16
max keysize  : 32

# AEAD 인증 암호화 (aead) — AES-GCM 예시
name         : gcm(aes)
driver       : generic-gcm-aesni
module       : gcm
priority     : 350
type         : aead               # Authenticated Encryption with Associated Data
async        : yes
blocksize    : 1
ivsize       : 12                 # 초기화 벡터 크기 (GCM: 12 bytes = 96비트)
maxauthsize  : 16                 # 최대 인증 태그 크기 (16=128비트)
geniv        : 

# 동기 해시 (shash)
name         : sha256
driver       : sha256-avx2
module       : sha256_ssse3
priority     : 170
type         : shash
blocksize    : 64
digestsize   : 32

# 비동기 해시 (ahash) — 하드웨어 가속
name         : sha256
driver       : sha256-ce           # ARM Crypto Extensions
module       : sha2-ce
priority     : 300
type         : ahash
async        : yes
blocksize    : 64
digestsize   : 32

# 키 합의 (kpp)
name         : ecdh
driver       : ecdh-generic
type         : kpp

# 난수 생성기 (rng)
name         : stdrng
driver       : drbg_nopr_hmac_sha256
type         : rng

# SIMD 최적화 정보
walksize     : 64                 # SIMD 일괄 처리 크기 (bytes). 클수록 스루풋 향상

/proc/devices — 등록된 디바이스 번호

/proc/devices는 커널에 등록된 모든 Character 디바이스와 Block 디바이스의 major 번호와 이름을 나열합니다. /dev 디렉터리의 디바이스 파일과 커널 드라이버를 연결하는 매핑 테이블입니다. udev가 이 정보를 참조하여 /dev에 자동으로 디바이스 노드를 생성합니다.

Character devices:
  1 mem          # /dev/mem, /dev/null, /dev/zero, /dev/full, /dev/random, /dev/urandom
  4 /dev/vc/0    # 가상 콘솔 (첫 번째)
  4 tty          # TTY 디바이스
  5 /dev/tty     # 현재 프로세스의 제어 터미널
  5 /dev/console # 시스템 콘솔
  5 /dev/ptmx    # 가상 터미널 마스터 (pty 쌍 생성)
  7 vcs          # 가상 콘솔 화면 덤프
 10 misc         # misc 드라이버 (minor로 구분: 229=fuse, 200=tun, 58=autofs)
 13 input        # 입력 디바이스 (마우스, 키보드, 조이스틱)
 21 sg           # SCSI 제네릭 디바이스
 29 fb           # 프레임버퍼 (/dev/fb0)
 89 i2c          # I2C 버스 어댑터
 90 mtd          # MTD (NAND/NOR 플래시)
116 snd          # ALSA 사운드 디바이스
136 pts          # 가상 터미널 슬레이브 (ssh, xterm 등)
166 ttyACM       # USB ACM 시리얼 (모뎀, Arduino)
188 ttyUSB       # USB-to-Serial 어댑터 (CP210x, FTDI)
189 usb          # USB 디바이스 raw 접근
226 drm          # DRM GPU 직접 렌더링 (/dev/dri/card0)
# 동적 할당 영역: 234~254 (커널이 런타임에 free major 자동 배정)
234 ttyXR        # (예시) 동적 할당 드라이버
235 (empty)      # 미사용

Block devices:
  7 loop         # 루프백 디바이스 (/dev/loop0~7)
  8 sd           # SCSI/SATA/SAS 디스크 (최대 16 minor/disk)
 11 sr           # SCSI/ATAPI CD-ROM
 65 sd           # SCSI 추가 major (sd[q-af], 디스크 수 초과 시)
179 mmc          # MMC/SD 카드 (/dev/mmcblk0)
252 device-mapper # LVM 논리 볼륨, dm-crypt
253 virtblk      # virtio 블록 디바이스 (KVM 게스트)
259 blkext       # NVMe, nvme0n1 (확장 블록 major)

misc(major 10) 주요 minor 목록:

/proc/diskstats — 디스크 I/O 통계

/proc/diskstats는 각 블록 디바이스의 누적 I/O 통계를 제공합니다. iostat, iotop, dstat 등 디스크 성능 모니터링 도구의 데이터 소스입니다. 전체 디스크와 파티션이 각각 별도의 행으로 나타납니다. 커널 4.18에서 열 15~18(discard 통계), 커널 5.5에서 열 19~20(flush 통계)이 추가되었습니다.

#열:  1   2    3        4     5       6      7     8     9      10      11    12    13     14    15   16    17    18   19   20
  8   0   sda  12345  678  9876543  56789 23456 789 8765432 123456   0  45678 180234  5678  123 234567  4321  890  123
  8   1   sda1   234    0    18720    456    12   0     192    234   0    345    690     0    0      0     0    0    0
259   0 nvme0n1 98765  432  7654321  34567 43210 654 6543210  56789   0  23456  91356  3456   87 456789  2345  567   89
# 섹터 크기 주의: 항상 512 bytes (물리 4KB 섹터와 무관한 논리 단위)
# 파티션(sda1): ios_in_progress(열12)는 항상 0 (파티션에서 미집계)

#!/bin/bash
# 2-샘플 차분으로 IOPS/Bandwidth/await 계산
DISK=${1:-sda}
get_stats() { awk -v d="$DISK" '$3==d {print $4,$6,$7,$8,$10,$11,$13}' /proc/diskstats; }
read r1 rs1 rms1 w1 ws1 wms1 io1 <<< $(get_stats); sleep 1
read r2 rs2 rms2 w2 ws2 wms2 io2 <<< $(get_stats)
dr=$((r2-r1)); dw=$((w2-w1))
echo "Read  IOPS : ${dr}/s,  BW: $(( (rs2-rs1)*512/1024 )) KB/s"
echo "Write IOPS : ${dw}/s,  BW: $(( (ws2-ws1)*512/1024 )) KB/s"
total=$((dr+dw))
[ $total -gt 0 ] && echo "await : $(( (rms2-rms1+wms2-wms1)/total )) ms"
echo "util% : $(( (io2-io1)/10 ))%   (ms_io delta / 1000ms)"

/proc/interrupts — 인터럽트 통계

/proc/interrupts는 각 IRQ 라인별로 CPU별 인터럽트 발생 횟수와 인터럽트 유형, 디바이스 이름을 보여줍니다. 인터럽트 불균형 탐지, 공유 인터럽트 확인, 네트워크/디스크 지연 원인 분석에 필수적인 도구입니다.

           CPU0       CPU1       CPU2       CPU3
  0:     156234          0          0          0  IO-APIC    2-edge      timer
  1:          0          0        987          0  IO-APIC    1-edge      i8042
  8:          0          0          0          1  IO-APIC    8-edge      rtc0
 16:          0          0      12345          0  IO-APIC   16-fasteoi   uhci_hcd:usb3
 24:      98765      87654      76543      65432  PCI-MSI 327680-edge    xhci_hcd
 25:    2345678          0          0          0  PCI-MSI 524288-edge    ahci[0000:00:17.0]
 26:          0          0          0    5678901  PCI-MSI 278528-edge    enp3s0
# 가상(소프트웨어) IRQ — 각 CPU별 독립 카운터
NMI:       1234       1234       1234       1234  Non-maskable interrupts
LOC:   98765432   87654321   76543210   65432109  Local timer interrupts
SPU:          0          0          0          0  Spurious interrupts
PMI:       5678       5679       5680       5681  Performance monitoring interrupts
IWI:        123        234        345        456  IRQ work interrupts
RTR:          0          0          0          0  APIC ICR read retries
RES:     123456     234567     345678     456789  Rescheduling interrupts
CAL:       4567       5678       6789       7890  Function call interrupts
TLB:      23456      34567      45678      56789  TLB shootdowns
TRM:          0          0          0          0  Thermal event interrupts
THR:          0          0          0          0  Threshold APIC interrupts
DFR:          0          0          0          0  Deferred Error APIC interrupts
MCE:          0          0          0          0  Machine check exceptions
MCP:         12         12         12         12  Machine check polls
HYP:          0          0          0          0  Hypervisor callback interrupts
ERR:          0   # 0이 아니면 IRQ 오류 (공유 인터럽트 충돌 등)
MIS:          0   # 0이 아니면 spurious IRQ (하드웨어 문제 의심)

smp_affinity 설정: /proc/irq/N/smp_affinity는 16진수 비트마스크로 IRQ를 처리할 CPU를 지정합니다.

# IRQ 26번(NIC)을 CPU2,3(비트마스크 0xc=1100)에 고정
echo c > /proc/irq/26/smp_affinity

# IRQ 25번(SATA)을 CPU0 전용(0x1)으로 설정
echo 1 > /proc/irq/25/smp_affinity

# 현재 affinity 확인 (smp_affinity_list: 사람이 읽기 쉬운 형식)
cat /proc/irq/26/smp_affinity_list   # → 2-3

# 모든 IRQ affinity 확인
for irq in /proc/irq/[0-9]*/smp_affinity_list; do
  echo "IRQ $(dirname $irq | xargs basename): $(cat $irq)"
done

/proc/iomem — 물리 메모리 주소 공간 맵

/proc/iomem은 시스템의 물리 주소 공간을 구역별로 표시합니다. RAM, ROM, MMIO(메모리 맵 I/O), PCI 디바이스 레지스터, ACPI 테이블 등이 어느 물리 주소에 매핑되어 있는지 계층적 구조로 보여줍니다. 들여쓰기는 서브 영역을 나타내며, 드라이버 개발이나 하드웨어 문제 진단 시 필수 참조 자료입니다.

00000000-00000fff : Reserved
00001000-0009f7ff : System RAM
0009f800-0009ffff : Reserved
000a0000-000bffff : PCI Bus 0000:00
  000a0000-000bffff : Video RAM area   # 레거시 VGA 프레임버퍼 (640~768KB)
000c0000-000c7fff : Video ROM
000f0000-000fffff : System ROM         # BIOS/UEFI 레거시 ROM
00100000-bffdffff : System RAM         # 메인 DRAM 영역
  01000000-01c531d9 : Kernel code      # 커널 텍스트 섹션
  01c531da-02047fff : Kernel rodata    # 커널 읽기 전용 데이터
  02048000-025437ff : Kernel data      # 커널 읽기/쓰기 데이터
  025d7000-028bcfff : Kernel bss       # 커널 미초기화 데이터
  09000000-09ffffff : Crash kernel     # kdump 전용 예약 영역 (crashkernel= 파라미터)
bffe0000-bfffffff : Reserved
bf800000-bfffffff : ACPI Tables        # ACPI 테이블 (읽기 가능)
  bf900000-bf9fffff : ACPI NVS         # 절전 상태 유지 데이터 (OS 접근 불가)
  bfa00000-bfafffff : ACPI Reclaim     # 부팅 후 OS가 재사용 가능
c0000000-febfffff : PCI Bus 0000:00    # PCIe MMCONFIG 영역 시작
  d0000000-dfffffff : PCI MMCONFIG 0000 [bus 00-ff]  # PCIe 확장 구성 공간
  fd000000-fdffffff : 0000:00:02.0     # GPU MMIO (PCI 주소:버스:장치.기능)
    fd000000-fdffffff : i915 drm       # → 들여쓰기: 드라이버가 클레임한 서브 영역
  fe000000-fe003fff : 0000:00:1f.3     # HDA 사운드 MMIO
    fe000000-fe003fff : ICH HD audio
fee00000-fee00fff : Local APIC         # 각 CPU 로컬 인터럽트 컨트롤러
fec00000-fec00fff : IOAPIC 0           # I/O APIC (IRQ 라우팅)
fed00000-fed003ff : HPET 0             # 고정밀 이벤트 타이머
fedc0000-fedc0fff : PNPACPI[01]        # ACPI PNP 장치
# EFI Runtime Services — 런타임 서비스 메모리 (OS 종료 후에도 유지)
7fe00000-7fefffff : EFI Runtime Services Code
7ff00000-7fffffff : EFI Runtime Services Data
100000000-43fffffff : System RAM       # DRAM 4GB 이상 (high memory, 64비트 전용)

/proc/ioports — x86 I/O 포트 맵

/proc/ioports는 x86 아키텍처에서 사용되는 I/O 포트 주소 공간을 영역별로 표시합니다. I/O 포트는 메모리 주소와 별개인 64KB(0x0000~0xFFFF) 주소 공간으로, in/out 명령어로 접근합니다. 0x000~0x3FF 영역은 전통적인 ISA 레거시 포트 영역입니다. 현대 PCIe 디바이스는 MMIO를 선호하지만, 레거시 디바이스(키보드, 시리얼, IDE 등)는 여전히 I/O 포트를 사용합니다.

0000-0000 : PCI Bus 0000:00
# ── ISA 레거시 영역 (0x000-0x3FF) ──────────────────────────────
0000-001f : dma1            # 8237A DMA 컨트롤러 1 (8비트 채널 0~3)
0020-0021 : pic1            # 8259A 마스터 PIC (IRQ 0~7)
0040-0043 : timer0          # 8254 PIT (1.193182 MHz 기준 클럭)
0060-0060 : keyboard        # PS/2 키보드 데이터 포트 (i8042)
0064-0064 : keyboard        # PS/2 키보드 상태/명령 포트
0070-0077 : rtc0            # MC146818 CMOS RTC + NMI 마스크 (0x70 bit7)
0080-008f : dma page reg    # DMA 페이지 레지스터 (상위 주소 비트)
00a0-00a1 : pic2            # 8259A 슬레이브 PIC (IRQ 8~15)
00c0-00df : dma2            # 8237A DMA 컨트롤러 2 (16비트 채널 4~7)
00f0-00ff : fpu             # x87 FPU 오류 상태 (레거시)
# IDE/ATA 포트
01f0-01f7 : ide0            # Primary IDE (ISA/ATA)
0170-0177 : ide1            # Secondary IDE
03f6-03f6 : ide0            # Primary IDE 제어 포트
0376-0376 : ide1            # Secondary IDE 제어 포트
# 시리얼 포트 (UART 16550)
03f8-03ff : serial          # COM1 (IRQ 4)
02f8-02ff : serial          # COM2 (IRQ 3)
03e8-03ef : serial          # COM3 (IRQ 4, 공유)
02e8-02ef : serial          # COM4 (IRQ 3, 공유)
# 병렬 포트 (LPT)
0378-037f : parport0        # LPT1 (IRQ 7)
0278-027f : parport1        # LPT2 (IRQ 5)
# 레거시 사운드 (ISA SoundBlaster)
# 0220-022f : sb_audio      # SoundBlaster 기본 포트
# 0388-038b : opl3          # OPL2/OPL3 FM 합성기 (AdLib 호환)
# PCI 구성 공간 접근
0cf8-0cff : PCI conf1       # CONFIG_ADDRESS(0xCF8)+CONFIG_DATA(0xCFC)
# PCI/PCIe 동적 할당 영역
0d00-ffff : PCI Bus 0000:00
  e000-e03f : 0000:00:1f.4  # SMBus 컨트롤러 I/O 포트
  e060-e07f : 0000:00:1f.0  # LPC 컨트롤러

/proc/slabinfo — Slab 캐시 상태

/proc/slabinfo는 커널 Slab 할당자가 관리하는 모든 오브젝트 캐시의 상세 통계를 제공합니다. 커널은 자주 할당/해제되는 구조체(태스크, 파일, inode 등)를 사전 할당된 Slab에서 관리하여 메모리 단편화와 할당 지연을 줄입니다. 현대 커널(4.x+)은 기본적으로 SLUB 할당자를 사용합니다. 커널 메모리 누수 탐지와 메모리 사용량 분석에 필수 도구입니다. root만 읽기 가능합니다.

slabinfo - version: 2.1
# name         <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab>
#            : tunables <limit> <batchcount> <sharedfactor>
#            : slabdata <active_slabs> <num_slabs> <sharedavail>
task_struct        1234    1280    7168    4    8 : tunables    0    0    0 : slabdata    320    320      0
files_cache         876     896     832   19    4 : tunables    0    0    0 : slabdata     47     47      0
dentry            45678   46080     192   21    1 : tunables    0    0    0 : slabdata   2194   2194      0
inode_cache        8765    9024     648   25    4 : tunables    0    0    0 : slabdata    361    361      0
ext4_inode_cache   3456    3465    1128   29    8 : tunables    0    0    0 : slabdata    119    119      0
# kmalloc 계열: 범용 커널 메모리 할당 (kmalloc() 호출 시 크기에 따라 선택)
kmalloc-8             0      0       8  512    1 : tunables    0    0    0 : slabdata      0      0      0
kmalloc-16          234    256      16  256    1 : tunables    0    0    0 : slabdata      1      1      0
kmalloc-32         1234   1280      32  128    1 : tunables    0    0    0 : slabdata     10     10      0
kmalloc-64        98765  102400     64   64    1 : tunables    0    0    0 : slabdata   1600   1600      0
kmalloc-128       23456   23552    128   32    1 : tunables    0    0    0 : slabdata    736    736      0
kmalloc-256       12345   13056    256   16    1 : tunables    0    0    0 : slabdata    816    816      0
kmalloc-512        5678    5632    512    8    1 : tunables    0    0    0 : slabdata    704    704      0
kmalloc-1k         2345    2352   1024    8    2 : tunables    0    0    0 : slabdata    294    294      0
kmalloc-2k          456     456   2048    4    2 : tunables    0    0    0 : slabdata    114    114      0
kmalloc-4k          123     128   4096    4    4 : tunables    0    0    0 : slabdata     32     32      0
# SLUB에서 tunables 값은 항상 0 (SLAB에서만 의미 있음)

SLUB vs SLAB: 현대 커널은 기본으로 SLUB(CONFIG_SLUB) 사용. SLAB은 CONFIG_SLAB으로 선택 가능 (레거시). SLUB은 tunables 미지원 대신 /sys/kernel/slab/에서 per-캐시 세부 통계를 제공합니다.

# Slab 메모리 사용량 상위 20개 확인 (objsize × num_objs = 캐시 총 메모리)
awk 'NR>2 {print $1, $3*$4/1024"KB"}' /proc/slabinfo | sort -t' ' -k2 -rn | head -20

# 누수 의심 캐시 모니터링: 5초 간격으로 num_objs 증가 추적
watch -d -n5 "awk 'NR>2 {print \$1, \$3}' /proc/slabinfo | sort -k2 -rn | head -20"

# reclaimable slab 즉시 회수 (dentry/inode 캐시)
echo 2 > /proc/sys/vm/drop_caches

# SLUB per-캐시 세부 통계 경로 (root 필요)
ls /sys/kernel/slab/task_struct/
# alloc_calls, free_calls, partial, cpu_slabs, objects 등

/proc/vmstat — 가상 메모리 세부 통계

/proc/vmstat은 커널 가상 메모리 서브시스템의 수백 가지 카운터를 제공합니다. 페이지 폴트, 스왑 I/O, 메모리 스캔/회수, 페이지 압축, NUMA 균형 조정 등의 활동을 상세히 추적합니다. vmstat 명령어 및 sar -B가 이 파일을 파싱합니다.

# ── 페이지 수 (현재 상태, 누적 아님) ──────────────────────────
nr_free_pages 524288         # 현재 free 페이지 수 (MemFree/4KB)
nr_zone_inactive_anon 12800  # inactive LRU 익명 페이지 (스왑 대상)
nr_zone_active_anon 104960   # active LRU 익명 페이지
nr_zone_inactive_file 52480  # inactive LRU 파일 페이지 (드롭 대상)
nr_zone_active_file 52480    # active LRU 파일 페이지
nr_zone_unevictable 3200     # 회수 불가 페이지 (mlockall, 핀드 메모리)
nr_slab_reclaimable 204800   # 회수 가능 slab 페이지 수
nr_slab_unreclaimable 51200  # 회수 불가 slab 페이지 수
nr_writeback 0               # 현재 writeback 중인 더티 페이지 수
nr_page_table_pages 8192     # 페이지 테이블이 차지하는 페이지 수
# ── 이벤트 카운터 (부팅 이후 누적) ────────────────────────────
pgfault 98765432             # 총 페이지 폴트 (minor + major)
pgmajfault 1234              # Major 폴트 (디스크 I/O 발생)
pgfree 456789012             # 해제된 페이지 수
pgalloc_normal 432109876     # Normal 존 할당 성공 횟수
pgalloc_dma32 12345          # DMA32 존 할당 횟수
# ── 직접 회수 (pgreclaim_direct → 응용 프로그램 블로킹) ────────
allocstall_normal 0          # Normal 존 직접 회수 발동 횟수
allocstall_dma32 0           # DMA32 존 직접 회수 발동 횟수
# ── kswapd 회수 ───────────────────────────────────────────────
pgscan_kswapd 2345678        # kswapd가 스캔한 페이지 수
pgsteal_kswapd 1987654       # kswapd가 실제로 회수한 페이지 수
kswapd_low_wmark_hit_quickly 12  # kswapd가 low wmark 빠르게 복구한 횟수
kswapd_high_wmark_hit_quickly 8  # kswapd가 high wmark 빠르게 복구한 횟수
# ── 스왑 I/O ──────────────────────────────────────────────────
pswpin 0                     # 스왑에서 읽은 페이지 (swap in)
pswpout 0                    # 스왑으로 쓴 페이지 (swap out)
# ── Working Set 통계 ──────────────────────────────────────────
workingset_refault_anon 0    # anon 페이지 재폴트 (스왑 후 재접근)
workingset_refault_file 12345 # 파일 페이지 재폴트 (드롭 후 재접근)
workingset_activate_anon 0   # anon 페이지 active LRU로 승격
workingset_activate_file 3456 # 파일 페이지 active LRU로 승격
workingset_restore_anon 0    # anon 페이지 shadow entry로 복원
workingset_restore_file 890  # 파일 페이지 shadow entry로 복원
# ── OOM 및 직접 회수 ──────────────────────────────────────────
oom_kill 0                   # OOM 킬러 발동으로 종료된 프로세스 수
pgreclaim_direct 234         # 직접 회수(응용 블로킹) 발생 횟수
# ── 메모리 압축 ───────────────────────────────────────────────
compact_migrate_scanned 456  # 압축 시 스캔한 이동 가능 페이지
compact_free_scanned 789     # 압축 시 스캔한 free 페이지
compact_isolated 234         # 압축으로 격리된 페이지
# ── NUMA 균형 ─────────────────────────────────────────────────
numa_local 9876543           # 로컬 NUMA 노드 할당 성공
numa_miss 12345              # 원하는 NUMA 노드 할당 실패
numa_foreign 5678            # 다른 NUMA 노드에서 할당된 페이지
numa_interleave 0            # interleave 정책으로 할당된 페이지
# ── THP ───────────────────────────────────────────────────────
thp_fault_alloc 5678         # 페이지 폴트 시 THP 할당 성공
thp_fault_fallback 123       # THP 할당 실패 → 4KB 폴백
thp_collapse_alloc 234       # 기존 4KB 페이지 → THP 병합 성공
thp_split_page 45            # THP → 4KB 분할 횟수 (파편화 원인)
# ── VM 풍선 (가상화) ──────────────────────────────────────────
balloon_inflate 0            # 하이퍼바이저가 게스트 메모리 회수
balloon_deflate 0            # 하이퍼바이저가 게스트 메모리 반환

/proc/vmallocinfo — vmalloc 영역 상세

/proc/vmallocinfo는 커널 vmalloc 영역의 각 할당 블록에 대한 상세 정보를 제공합니다. vmalloc은 물리적으로 불연속적인 메모리를 가상 주소 공간에서 연속적으로 보이게 매핑할 때 사용합니다. 커널 모듈, ioremap, vmalloc 직접 호출 등이 이 영역을 사용합니다. 블록 사이에는 가드 페이지(4KB)가 삽입되어 주소가 불연속적입니다. root 권한이 필요합니다.

# 형식: start-end  size  caller  [flags] [phys=...] [pages=N] [NX=M]
0xffffc90000000000-0xffffc90000009000   36864 alloc_large_system_hash+0x... phys=0x1234000 ioremap
0xffffc90001000000-0xffffc90001201000 2101248 __vmalloc_node_range+0x... pages=512 vmalloc N0=512
0xffffc90001201000-0xffffc90001400000 2093056 text_poke_bp_batch+0x...  pages=511 vmalloc
0xffffc90004000000-0xffffc90004021000  135168 ioremap+0x...             phys=0xfe000000 ioremap
0xffffc90005000000-0xffffc90005041000  266240 my_module_init [mymod]+0x0 pages=64 vmalloc N0=64
#   ↑ 가상 주소 범위           ↑ 크기   ↑ 호출자(함수+심볼) [모듈명]    ↑ 플래그/속성

# vm_map_ram: vmap_block 이용한 RAM 직접 매핑 (소규모, 단편화 방지)
0xffffc90006000000-0xffffc90006001000    4096 vmap_block_queue_drain+0x... vm_map_ram

# vmap_block: 소규모 vmap 블록 풀 (vmalloc 영역 단편화 감소)
0xffffc90007000000-0xffffc90007020000  131072 vb_alloc+0x...              vmap_block

# vpages: 물리 페이지 없는 가상 주소만 예약 (guard hole 등)
0xffffc90008000000-0xffffc90008001000    4096 guard_page+0x...             vpages

# 커널 모듈: module text/data는 vmalloc 영역에 배치
0xffffffffc0000000-0xffffffffc0040000  262144 load_module+0x...  pages=63 vmalloc N0=63
#   ↑ 모듈 전용 영역 (0xffffffffc0000000~)                         [CONFIG_MODULES_TREE_LOOKUP]

# user: userspace가 요청한 vmalloc 매핑 (mmap with MAP_POPULATE 등)
0xffffc9000a000000-0xffffc9000a010000   65536 vmap_pfn+0x...              user

가드 페이지: 각 vmalloc 블록 뒤에 매핑되지 않은 4KB 가드 페이지가 삽입됩니다. 버퍼 오버플로를 커널 패닉으로 즉시 탐지하는 메모리 보호 장치입니다. 이 때문에 vmalloc 블록 간 주소가 불연속하게 보입니다.

모듈 영역 패턴: 커널 모듈은 0xffffffffc0000000 이상의 모듈 전용 vmalloc 영역에 배치됩니다. text(실행 코드), data, bss 섹션이 각각 별도 vmalloc 항목으로 나타납니다.

/proc/zoneinfo — 메모리 존 상세

/proc/zoneinfo는 각 NUMA 노드의 메모리 존(DMA, DMA32, Normal, Movable)별 상세 통계를 제공합니다. 워터마크(watermark), 실제 가용 페이지, 페이지 타입별 통계, LRU 리스트 크기 등을 포함합니다. OOM(Out Of Memory) 킬러 동작 분석과 메모리 압박 임계값 이해에 필수적인 파일입니다.

# ── NUMA 2-노드 예시 ────────────────────────────────────────────
Node 0, zone      DMA
  pages free      1234
        min          3
        low          3
        high         4
        spanned      4096
        present      3998
        managed      3977
        cma             0
  protection[]: 0, 3035, 15608, 15608, 15608   # 하위 존 보호 예약 배열

Node 0, zone   Normal
  pages free     524288       # 현재 즉시 할당 가능한 free 페이지
        min       12345       # min 워터마크 (Direct Reclaim 발동 임계값)
        low       15431       # low 워터마크 (kswapd 깨어남 임계값)
        high      18517       # high 워터마크 (kswapd 수면 복귀 임계값)
        spanned  4194304
        present  4100000
        managed  4050000      # buddy 할당자 관리 페이지 (=present-reserved-holes)
        cma           0       # CMA(연속 메모리 할당자) 예약 페이지
  nr_zone_inactive_anon 12800
  nr_zone_active_anon   104960
  nr_zone_inactive_file 52480
  nr_zone_active_file   52480
  nr_zone_unevictable   3200  # mlockall/공유 메모리 고정 페이지
  nr_zone_write_pending 1024  # dirty + writeback 페이지 합계
  nr_mlock              3200  # mlock/mlockall로 잠긴 페이지
  nr_page_table_pages    512
  nr_kernel_misc_reclaimable 0
  nr_bounce                0  # 32비트 DMA 바운스 버퍼 페이지
  nr_free_cma              0  # 미사용 CMA 예약 페이지
  lowmem_reserve[]: 0  0  0  0   # [DMA,DMA32,Normal,Movable] 하위존 예약량

Node 0, zone  Movable         # 핫플러그/메모리 오프라인 전용 존
  pages free      98765
        min        2345
        low        2931
        high       3517
        managed   524288      # 이동 가능 페이지만 배치

Node 1, zone   Normal         # 두 번째 NUMA 소켓
  pages free     389000
        min       11000
        low       13750
        high      16500
        managed  3800000

워터마크 계산 공식: vm.min_free_kbytes → min_free_pages = min_free_kbytes / 4 (4KB 기준). 각 존의 워터마크 = min_free_pages × (zone_managed / total_managed) 비례 배분.

sysctl (/proc/sys/) 주요 경로

/sys (sysfs) 세부 경로 심화

sysfs는 커널 오브젝트(kobject) 계층을 사용자 공간에 반영합니다. 디바이스, 드라이버, 버스, 클래스 등의 정보와 제어를 제공합니다.

sysfs 주요 디렉터리 구조

# PCI 디바이스 정보 확인
ls /sys/bus/pci/devices/0000:01:00.0/
# vendor, device, class, irq, resource, driver, numa_node, ...

cat /sys/bus/pci/devices/0000:01:00.0/vendor  # 0x8086 (Intel)
cat /sys/bus/pci/devices/0000:01:00.0/device  # 디바이스 ID
cat /sys/bus/pci/devices/0000:01:00.0/numa_node  # NUMA 노드

# 네트워크 인터페이스 정보
ls /sys/class/net/eth0/
# address, carrier, duplex, mtu, operstate, speed, statistics/, ...

cat /sys/class/net/eth0/speed     # 링크 속도 (Mbps)
cat /sys/class/net/eth0/carrier   # 1=링크 업, 0=다운
cat /sys/class/net/eth0/mtu       # MTU (쓰기로 변경 가능)

# 블록 디바이스 정보
cat /sys/block/sda/queue/scheduler      # I/O 스케줄러
cat /sys/block/sda/queue/nr_requests    # 큐 깊이
cat /sys/block/sda/queue/rotational     # 0=SSD, 1=HDD
cat /sys/block/sda/queue/read_ahead_kb  # 읽기 선행 크기

# CPU 토폴로지
cat /sys/devices/system/cpu/cpu0/topology/core_id
cat /sys/devices/system/cpu/cpu0/topology/physical_package_id
cat /sys/devices/system/cpu/cpu0/cache/index0/size  # L1 캐시 크기

# NUMA 메모리 정보
cat /sys/devices/system/node/node0/meminfo

# 모듈 파라미터 확인/변경
cat /sys/module/my_module/parameters/debug_level
echo 3 > /sys/module/my_module/parameters/debug_level

# 전원 상태
cat /sys/power/state            # freeze mem disk
cat /sys/power/mem_sleep        # s2idle [deep]

sysfs에서 드라이버 속성 구현

/* 드라이버에서 sysfs 속성 노출 */
static ssize_t my_attr_show(struct device *dev,
                            struct device_attribute *attr,
                            char *buf)
{
    struct my_device *mydev = dev_get_drvdata(dev);
    return sysfs_emit(buf, "%d\\n", mydev->value);
    /* sysfs_emit: sprintf 대신 사용 (버퍼 오버플로 방지) */
}

static ssize_t my_attr_store(struct device *dev,
                             struct device_attribute *attr,
                             const char *buf, size_t count)
{
    struct my_device *mydev = dev_get_drvdata(dev);
    int ret = kstrtoint(buf, 10, &mydev->value);
    return ret ? ret : count;
}

static DEVICE_ATTR_RW(my_attr);
/* DEVICE_ATTR_RO(name): 읽기 전용 */
/* DEVICE_ATTR_WO(name): 쓰기 전용 */

/* 속성 그룹으로 등록 (권장) */
static struct attribute *my_attrs[] = {
    &dev_attr_my_attr.attr,
    NULL,
};
ATTRIBUTE_GROUPS(my);

/* 드라이버에서 사용 */
static struct platform_driver my_driver = {
    .driver = {
        .name = "my_device",
        .dev_groups = my_groups,  /* 자동 생성/제거 */
    },
};

/sys/kernel/debug (debugfs) 세부 경로 심화

debugfs는 개발/디버깅 전용 가상 파일시스템입니다. ABI 안정성이 보장되지 않으므로 프로덕션 도구가 의존해서는 안 됩니다.

debugfs 주요 경로

# debugfs 마운트 확인/수동 마운트
mount | grep debugfs
mount -t debugfs none /sys/kernel/debug

# kmemleak으로 메모리 누수 탐지
echo scan > /sys/kernel/debug/kmemleak
cat /sys/kernel/debug/kmemleak
# unreferenced object 0xffff88810a3b4c00 (size 128):
#   comm "my_app", pid 1234, jiffies 4294967296
#   backtrace:
#     kmalloc_trace+0x28/0x40
#     my_alloc_func+0x15/0x30 [my_module]

# kmemleak 필터링
echo clear > /sys/kernel/debug/kmemleak          # 결과 초기화
echo "not scan" > /sys/kernel/debug/kmemleak      # 스캔 중지

# GPIO 상태 확인
cat /sys/kernel/debug/gpio
# gpiochip0: GPIOs 0-31, parent: platform/fe200000.gpio, pinctrl-bcm2711:
#  gpio-4   (                    |sysfs    ) out hi
#  gpio-17  (                    |button   ) in  lo IRQ

# 클록 트리 확인 (임베디드/SoC)
cat /sys/kernel/debug/clk/clk_summary

# regmap 레지스터 덤프
cat /sys/kernel/debug/regmap/0-0050/registers
# 00: 01 02 03 04
# 04: aa bb cc dd

debugfs 파일 생성 방법

/* 드라이버에서 debugfs 인터페이스 추가 */
struct dentry *dbg_dir;

static int __init my_init(void)
{
    dbg_dir = debugfs_create_dir("my_driver", NULL);
    if (IS_ERR(dbg_dir))
        return PTR_ERR(dbg_dir);

    /* 단일 값 파일 (자동 read/write 구현) */
    debugfs_create_u32("counter", 0644, dbg_dir, &my_counter);
    debugfs_create_bool("enabled", 0644, dbg_dir, &my_enabled);
    debugfs_create_x64("reg_value", 0444, dbg_dir, &my_reg);
    debugfs_create_size_t("buf_size", 0444, dbg_dir, &my_size);

    /* 커스텀 파일 (file_operations) */
    debugfs_create_file("status", 0444, dbg_dir, my_dev, &my_fops);

    /* 바이너리 Blob (레지스터 덤프 등) */
    my_blob.data = reg_base;
    my_blob.size = 256;
    debugfs_create_blob("reg_dump", 0444, dbg_dir, &my_blob);

    return 0;
}

static void __exit my_exit(void)
{
    debugfs_remove_recursive(dbg_dir);  /* 하위 전체 제거 */
}

보안과 접근 제어

가상 파일시스템은 커널 내부 정보를 노출하므로 보안 관점에서 접근 제어가 매우 중요합니다. 특히 컨테이너와 멀티테넌트 환경에서는 정보 유출 방지가 필수입니다.

hidepid — /proc 프로세스 정보 격리

hidepid 마운트 옵션은 다른 사용자의 /proc/[pid]/ 정보 접근을 제한합니다:

# hidepid 적용 (런타임)
mount -o remount,hidepid=2 /proc

# /etc/fstab에서 영구 적용
proc  /proc  proc  defaults,hidepid=2,gid=monitor  0  0

# gid 옵션: 지정된 그룹은 제한 면제 (모니터링 도구용)
# 예: gid=monitor → monitor 그룹 사용자는 모든 프로세스 볼 수 있음

# subset 옵션 (5.8+): 특정 항목만 숨김
mount -o remount,subset=pid /proc  # PID 디렉터리만 제한

Capability 기반 접근 제어

YAMA ptrace_scope

# /proc/sys/kernel/yama/ptrace_scope
# 0: 클래식 ptrace 권한 (같은 uid면 가능)
# 1: 부모 프로세스만 ptrace 가능 (기본값, Ubuntu 등)
# 2: CAP_SYS_PTRACE를 가진 프로세스만 ptrace 가능
# 3: ptrace 완전 비활성화 (재부팅 전까지 변경 불가)

# scope=1일 때 특정 프로세스를 디버깅 허용하려면:
# 대상 프로세스에서 prctl(PR_SET_PTRACER, debugger_pid)

SELinux / AppArmor 정책

MAC(Mandatory Access Control)은 /proc, /sys 접근에 추가적인 정책 계층을 적용합니다:

# SELinux: /proc 접근 거부 감사 로그
# avc: denied { read } for pid=1234 comm="app" name="kcore"
#   scontext=user_t tcontext=proc_kcore_t tclass=file

# SELinux 부울 제어
setsebool -P deny_ptrace 1          # ptrace 전역 차단

# AppArmor: 프로필에서 /proc 접근 제어
# /etc/apparmor.d/my_app:
# deny /proc/*/mem r,
# deny /proc/sys/** w,
# /proc/sys/net/** rw,  # 네트워크 튜닝만 허용

debugfs 접근 제한과 lockdown

커널 lockdown 기능(5.4+)은 Secure Boot 환경에서 debugfs 등을 통한 커널 변조를 방지합니다:

# lockdown 모드 확인
cat /sys/kernel/security/lockdown
# [none] integrity confidentiality

# integrity 모드: 커널 코드/데이터 변경 차단
#   - debugfs 쓰기 제한
#   - /dev/mem, /dev/kmem, /proc/kcore 접근 차단
#   - kexec_load 차단
#   - 모듈 서명 강제

# confidentiality 모드: integrity + 커널 정보 읽기 차단
#   - /proc/kallsyms 주소 숨김
#   - dmesg 접근 제한
#   - perf 제한

# debugfs 마운트 자체를 커널 파라미터로 비활성화
# 부팅 옵션: debugfs=off  (또는 debugfs=no-mount)

네임스페이스와 가상 FS

Linux 네임스페이스는 /proc, /sys의 보이는 내용을 격리하여 컨테이너 환경에서 프로세스별로 독립된 뷰를 제공합니다.

PID 네임스페이스와 /proc 격리

각 PID 네임스페이스는 독립된 /proc 뷰를 가집니다. 컨테이너 내부에서 /proc를 마운트하면 해당 네임스페이스의 프로세스만 보입니다:

/* PID 네임스페이스 생성 후 /proc 마운트 */
/* unshare(CLONE_NEWPID) → fork() → mount("proc", "/proc", "proc", 0, NULL) */

/* 커널 내부: proc_pid_readdir()가 현재 pid_namespace 기준으로 필터링 */
struct pid_namespace *ns = task_active_pid_ns(current);
/* ns->child_reaper = 네임스페이스 내 init(PID 1) 프로세스 */
/* ns->level = 네임스페이스 깊이 (루트=0) */

# 새 PID 네임스페이스에서 /proc 확인
unshare --pid --fork --mount-proc bash
ps aux   # 네임스페이스 내 프로세스만 보임
ls /proc/ # PID 1 = 현재 bash

# /proc/[pid]/status에서 NSpid 확인
cat /proc/self/status | grep NSpid
# NSpid:  1234  1   (호스트 PID: 1234, 네임스페이스 내 PID: 1)

sysctl 네임스페이스 인식 파라미터

일부 sysctl 파라미터는 네임스페이스별로 독립적입니다:

# 네트워크 네임스페이스에서 독립적인 sysctl
ip netns add test_ns
ip netns exec test_ns sysctl net.ipv4.ip_forward=1
# → test_ns 네임스페이스에서만 IP 포워딩 활성화

# 호스트의 net.ipv4.ip_forward는 변경되지 않음
sysctl net.ipv4.ip_forward
# → 0 (호스트 기본값 유지)

컨테이너에서의 procfs/sysfs 마운트 주의

# Docker 기본 /proc 마스킹 확인
docker run --rm alpine mount | grep proc
# proc on /proc type proc (rw,nosuid,nodev,noexec)
# tmpfs on /proc/acpi type tmpfs (ro,...)
# tmpfs on /proc/kcore type tmpfs (rw,...,size=0k)
# tmpfs on /proc/scsi type tmpfs (ro,...)

# OCI 런타임 스펙의 maskedPaths/readonlyPaths
# maskedPaths: /proc/kcore, /proc/keys, /proc/timer_list, ...
# readonlyPaths: /proc/bus, /proc/fs, /proc/irq, /proc/sys, ...

lxcfs를 통한 /proc 가상화

컨테이너 내부의 /proc/meminfo, /proc/cpuinfo 등은 호스트의 값을 보여줍니다. lxcfs는 이를 cgroup 제한에 맞게 가상화합니다:

# lxcfs 설치 및 시작
lxcfs /var/lib/lxcfs

# 컨테이너에서 lxcfs 마운트
docker run -v /var/lib/lxcfs/proc/meminfo:/proc/meminfo:ro \
           -v /var/lib/lxcfs/proc/cpuinfo:/proc/cpuinfo:ro \
           -v /var/lib/lxcfs/proc/stat:/proc/stat:ro \
           -v /var/lib/lxcfs/proc/uptime:/proc/uptime:ro \
           --memory 512m alpine cat /proc/meminfo
# MemTotal:      524288 kB   ← cgroup 제한(512MB)을 반영
# (lxcfs 없으면 호스트의 전체 메모리가 보임)

# lxcfs가 해결하는 문제:
# - JVM 등이 /proc/meminfo를 읽어 힙 크기를 잘못 결정
# - top/free 등 도구가 호스트 메모리를 보여 혼란 유발
# - /proc/cpuinfo가 호스트의 전체 CPU를 보여줌

성능과 부작용

가상 파일시스템의 읽기/쓰기는 커널 내부 자료구조에 직접 접근하므로, 예상치 못한 성능 비용과 부작용이 발생할 수 있습니다.

/proc 읽기 비용

# /proc/[pid]/smaps 읽기 비용 측정
time cat /proc/$(pgrep -f java)/smaps > /dev/null
# real: 0m0.350s  ← JVM 프로세스의 수천 VMA 순회

# 대안: smaps_rollup (합산값만, 5.4+)
time cat /proc/$(pgrep -f java)/smaps_rollup > /dev/null
# real: 0m0.005s  ← 70x 빠름

# /proc 순회 비용 (대량 프로세스)
time ls /proc/*/status > /dev/null 2>&1  # 1만 프로세스 → 수 초

대량 프로세스 환경에서의 /proc 순회

/* /proc 디렉터리 순회 시 tasklist_lock 비용 */
/* proc_pid_readdir() → next_tgid() → rcu_read_lock() + for_each_process() */
/*
 * 문제: 프로세스가 10,000개 이상이면 /proc 순회 자체가 느림
 * - ps aux, top 등이 모든 /proc/[pid]/ 순회
 * - 모니터링 에이전트가 주기적으로 순회하면 CPU 부담
 *
 * 대안:
 * - /proc/[pid]/stat만 읽기 (smaps 대신 statm)
 * - cgroup 기반 모니터링 (cgroupfs가 더 효율적)
 * - BPF iter (5.8+)로 task 순회 (커널 내에서 필터링)
 * - pidfd_open() + pidfd_getfd()로 특정 프로세스만 조회
 */

seq_file 메모리 사용

seq_file은 출력을 임시 버퍼에 저장한 뒤 사용자 공간으로 복사합니다. 대량 데이터 출력 시 메모리 사용이 급증할 수 있습니다:

/* seq_file 내부 버퍼 관리 */
/*
 * seq_read() → traverse() → show()
 * 초기 버퍼: PAGE_SIZE (4KB)
 * 부족 시 2배씩 증가: 4K → 8K → 16K → ... → kmalloc 한계까지
 *
 * 주의: single_open()은 전체 출력을 한 번에 메모리에 저장
 *       대량 데이터 시 seq_operations (start/next/stop/show) 사용 필수
 */

/* 나쁜 예: single_open으로 대량 데이터 출력 */
static int bad_show(struct seq_file *m, void *v)
{
    struct my_item *item;
    list_for_each_entry(item, &huge_list, list)
        seq_printf(m, "%d %s\\n", item->id, item->name);
    return 0;
    /* → 리스트가 크면 버퍼가 수십 MB까지 증가 */
}

/* 좋은 예: seq_operations으로 반복자 패턴 사용 */
/* → 한 번에 하나의 항목만 출력, 버퍼 크기 일정 유지 */

sysfs 폴링 vs uevent

/* 나쁜 패턴: 사용자 공간에서 sysfs를 주기적으로 폴링 */
/* while (1) { read("/sys/class/net/eth0/carrier"); sleep(1); } */
/* → 매 읽기마다 커널 show 콜백 호출, CPU 낭비 */

/* 좋은 패턴: uevent / poll() 사용 */
/* 1. sysfs_notify()로 커널에서 변경 알림 */
sysfs_notify(&dev->kobj, NULL, "status");
/* 2. 사용자 공간에서 poll()/select()로 대기 */
/* fd = open("/sys/..../status"); poll(fd, POLLPRI | POLLERR); */
/* → 변경 시에만 깨어남, CPU 사용 최소화 */

/* 또는 udev/netlink로 uevent 수신 */
kobject_uevent(&dev->kobj, KOBJ_CHANGE);
/* → udevadm monitor 로 확인 가능 */

debugfs와 lock contention

tracefs 심화

tracefs는 커널 5.1+에서 debugfs로부터 분리된 독립 파일시스템으로, ftrace 트레이싱 인터페이스를 제공합니다. /sys/kernel/tracing/ (또는 레거시 경로 /sys/kernel/debug/tracing/)에 마운트됩니다.

tracefs 구조

ftrace 이벤트 설정

# tracefs 마운트 위치 확인
mount | grep tracefs
# tracefs on /sys/kernel/tracing type tracefs (rw,nosuid,nodev,noexec)

# 스케줄러 이벤트 트레이싱
echo 1 > /sys/kernel/tracing/events/sched/sched_switch/enable
cat /sys/kernel/tracing/trace_pipe
# bash-1234 [002] 12345.678: sched_switch: prev=bash next=kworker/2:0

# 특정 이벤트 필터링
echo 'prev_comm == "my_app"' > /sys/kernel/tracing/events/sched/sched_switch/filter

# 여러 이벤트 카테고리 동시 활성화
echo 1 > /sys/kernel/tracing/events/net/enable     # 네트워크 이벤트 전체
echo 1 > /sys/kernel/tracing/events/block/enable   # 블록 I/O 이벤트 전체

# 이벤트 포맷 확인
cat /sys/kernel/tracing/events/sched/sched_switch/format
# name: sched_switch
# field:char prev_comm[16]; field:pid_t prev_pid; ...

kprobe / uprobe 동적 트레이싱

# kprobe: 커널 함수 진입점에 동적 트레이스 포인트 삽입
echo 'p:my_probe do_sys_open filename=+0(%si):string' > /sys/kernel/tracing/kprobe_events
echo 1 > /sys/kernel/tracing/events/kprobes/my_probe/enable
cat /sys/kernel/tracing/trace_pipe
# bash-1234 [001] 12345.678: my_probe: (do_sys_open+0x0) filename="/etc/passwd"

# kretprobe: 함수 리턴 값 캡처
echo 'r:my_ret do_sys_open ret=$retval' >> /sys/kernel/tracing/kprobe_events

# uprobe: 사용자 공간 함수 트레이싱
echo 'p:my_uprobe /usr/bin/bash:0x4a2e0' > /sys/kernel/tracing/uprobe_events
echo 1 > /sys/kernel/tracing/events/uprobes/my_uprobe/enable

# kprobe/uprobe 제거
echo '-:my_probe' >> /sys/kernel/tracing/kprobe_events

# 주의: kprobe는 인라인 함수, static 함수에는 동작하지 않을 수 있음
# /proc/kallsyms에서 주소를 확인하여 사용

trace_pipe vs trace

trace_marker — 사용자 공간 이벤트 기록

/* 사용자 공간 프로그램에서 커널 트레이스 버퍼에 마커 기록 */
int trace_fd = open("/sys/kernel/tracing/trace_marker", O_WRONLY);
dprintf(trace_fd, "my_app: transaction_start id=%d\\n", txn_id);
/* ... 작업 수행 ... */
dprintf(trace_fd, "my_app: transaction_end id=%d latency=%lldns\\n",
        txn_id, latency);
close(trace_fd);

/* trace_marker_raw: 바이너리 데이터 기록 (구조화된 이벤트) */
/* 사용 예: Android의 atrace/systrace가 trace_marker 사용 */

Android atrace/Perfetto: Android의 시스템 트레이싱은 커널의 trace_marker를 핵심으로 활용한다. atrace 도구가 Android 프레임워크 이벤트를 trace_marker에 기록하고, 커널 tracepoint(sched, binder, block 등)와 함께 수집한다. 현재 표준 도구인 Perfetto는 유저스페이스와 커널 트레이스를 통합하며, /sys/kernel/tracing/의 ftrace 인프라를 백엔드로 사용한다. Binder 트랜잭션 지연, 스케줄러 문제, I/O 병목 등을 분석할 때 커널 tracepoint가 핵심 데이터를 제공한다. 자세한 내용은 Android 커널 — 디버깅과 ftrace/Tracepoints를 참고하라.

per-CPU 버퍼와 인스턴스

# per-CPU 버퍼 크기 설정 (기본: 1408KB)
echo 4096 > /sys/kernel/tracing/buffer_size_kb  # 4MB per CPU

# CPU별 독립 트레이스 읽기
cat /sys/kernel/tracing/per_cpu/cpu0/trace
cat /sys/kernel/tracing/per_cpu/cpu3/trace_pipe

# 독립 트레이스 인스턴스 생성 (다중 사용자/도구 동시 사용)
mkdir /sys/kernel/tracing/instances/my_trace
echo function > /sys/kernel/tracing/instances/my_trace/current_tracer
echo 'vfs_*' > /sys/kernel/tracing/instances/my_trace/set_ftrace_filter
# → 메인 버퍼와 독립적으로 VFS 함수만 트레이싱

# 인스턴스 삭제
rmdir /sys/kernel/tracing/instances/my_trace

# 주의: 인스턴스마다 per-CPU 버퍼를 할당하므로 메모리 사용량 증가
# 인스턴스 수 × buffer_size_kb × nr_cpus = 총 메모리 사용량

커널 버전별 변경사항

procfs, sysfs, debugfs API는 커널 버전에 따라 지속적으로 변경됩니다. 모듈 코드의 호환성을 유지하려면 주요 변경사항을 파악해야 합니다.

proc_ops 도입 (5.6+)

/* 커널 5.6 이전: file_operations 사용 */
static const struct file_operations my_proc_fops = {
    .owner   = THIS_MODULE,
    .open    = my_proc_open,
    .read    = seq_read,
    .llseek  = seq_lseek,
    .release = single_release,
};
proc_create("my_entry", 0444, NULL, &my_proc_fops);

/* 커널 5.6 이후: proc_ops 전용 구조체 */
static const struct proc_ops my_proc_ops = {
    .proc_open    = my_proc_open,
    .proc_read    = seq_read,
    .proc_lseek   = seq_lseek,
    .proc_release = single_release,
    /* .owner 필드 없음 — 항상 THIS_MODULE */
    /* proc_flags 추가: PROC_ENTRY_PERMANENT 등 */
};
proc_create("my_entry", 0444, NULL, &my_proc_ops);

/* 변경 이유: file_operations는 VFS 전반에 사용되어 불필요한 필드가 많음.
 * proc_ops는 procfs에 필요한 필드만 포함하여 구조체 크기 절약.
 * proc_compat_ioctl 등 compat 지원도 proc_ops에 직접 포함. */

sysfs_emit 도입 (5.10+)

/* 커널 5.10 이전: sprintf/scnprintf 사용 (위험) */
static ssize_t old_show(struct kobject *kobj,
    struct kobj_attribute *attr, char *buf)
{
    return sprintf(buf, "%d\\n", value);
    /* 위험: buf는 PAGE_SIZE 크기이지만 sprintf는 경계 검사 없음 */
}

/* 커널 5.10 이후: sysfs_emit 사용 (권장) */
static ssize_t new_show(struct kobject *kobj,
    struct kobj_attribute *attr, char *buf)
{
    return sysfs_emit(buf, "%d\\n", value);
    /* 안전: 항상 PAGE_SIZE 경계 내에서 출력 */
    /* buf가 PAGE_SIZE 경계에 정렬되어 있는지 검증 (WARN) */
}

/* sysfs_emit_at: 오프셋 지정 출력 (여러 값을 순차 출력할 때) */
ssize_t len = 0;
len += sysfs_emit_at(buf, len, "field1: %d\\n", val1);
len += sysfs_emit_at(buf, len, "field2: %d\\n", val2);
/* 주의: one-value-per-file 원칙에 어긋나지만
 * 일부 레거시 sysfs 파일에서 불가피하게 사용 */

register_sysctl 변경 (6.x)

/* 커널 6.5 이전: register_sysctl_table(deprecated) 또는 register_sysctl() */
static struct ctl_table my_table[] = {
    { .procname = "my_param", .data = &val, .maxlen = sizeof(int),
      .mode = 0644, .proc_handler = proc_dointvec },
    { }  /* sentinel */
};
my_header = register_sysctl("kernel/mydriver", my_table);

/* 커널 6.6+: register_sysctl_table 제거, register_sysctl만 유지 */
/* ctl_table의 child 필드 제거 (중첩 테이블 불가) */
/* 경로는 register_sysctl()의 첫 인자로 지정 */

/* 커널 6.11+: 센티널(빈 엔트리) 불필요 */
static struct ctl_table my_table[] = {
    { .procname = "my_param", .data = &val, .maxlen = sizeof(int),
      .mode = 0644, .proc_handler = proc_dointvec },
    /* 센티널 불필요 — 배열 크기를 register_sysctl_sz()에 전달 */
};
my_header = register_sysctl_sz("kernel/mydriver", my_table, ARRAY_SIZE(my_table));

debugfs 권한 강화 이력

#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0)
  /* proc_ops 사용 */
#else
  /* file_operations 사용 */
#endif

procfs에서 BPF iter (5.8+)

/* BPF iter: /proc 순회 대신 커널 내에서 직접 task 순회 */
/* 장점: 커널-유저 공간 전환 최소화, 필터링 효율적 */

/* BPF 프로그램 (bpf_iter__task) */
SEC("iter/task")
int dump_task(struct bpf_iter__task *ctx)
{
    struct task_struct *task = ctx->task;
    if (!task) return 0;

    if (task->tgid == task->pid)  /* 메인 스레드만 */
        BPF_SEQ_PRINTF(ctx->meta->seq, "%d %s %llu\\n",
                       task->pid, task->comm, task->utime);
    return 0;
}

/* 사용: bpf_iter_link_create()로 /proc/my_tasks에 바인딩 */
/* 읽기 시 BPF 프로그램이 실행되어 필터링된 결과만 출력 */
/* → /proc/[pid]/ 일일이 순회하는 것보다 수십 배 빠름 */

흔한 실수와 함정

가상 파일시스템 코드에서 자주 발생하는 실수와 그 해결법을 정리합니다.

실수 1: sprintf 사용 (sysfs)

/* ✗ 나쁜 코드: sprintf로 sysfs 출력 */
static ssize_t show(struct kobject *kobj,
    struct kobj_attribute *attr, char *buf)
{
    return sprintf(buf, "%s\\n", very_long_string);
    /* 위험: very_long_string이 PAGE_SIZE(4096)를 초과하면 버퍼 오버플로 */
    /* 커널 패닉이나 메모리 손상 발생 가능 */
}

/* ✓ 올바른 코드: sysfs_emit 사용 */
static ssize_t show(struct kobject *kobj,
    struct kobj_attribute *attr, char *buf)
{
    return sysfs_emit(buf, "%s\\n", very_long_string);
    /* 안전: PAGE_SIZE 초과 시 잘려서 출력, 오버플로 없음 */
}

/* checkpatch.pl이 sprintf→sysfs_emit 변환을 경고함 */
/* WARNING: use sysfs_emit or sysfs_emit_at ... */

실수 2: proc 엔트리 race condition

/* ✗ 나쁜 코드: 모듈 언로드 시 race condition */
static void __exit my_exit(void)
{
    remove_proc_entry("my_entry", NULL);
    kfree(my_data);  /* 위험! 다른 프로세스가 아직 읽는 중일 수 있음 */
}

/* 시나리오:
 * 1. 프로세스 A가 /proc/my_entry를 open() → proc_ops.proc_open() 호출
 * 2. 모듈 rmmod 실행 → remove_proc_entry() → kfree(my_data)
 * 3. 프로세스 A가 read() → show() 콜백에서 해제된 my_data 접근 → UAF!
 */

/* ✓ 올바른 코드: proc_remove()와 적절한 동기화 */
static void __exit my_exit(void)
{
    proc_remove(my_proc_entry);
    /* proc_remove()는 진행 중인 read/write가 완료될 때까지 대기 */
    /* 이후 my_data를 안전하게 해제 가능 */
    kfree(my_data);
}

/* 추가 보호: pde_data() 사용으로 private data를 proc_dir_entry에 연결 */
proc_create_data("my_entry", 0444, NULL, &my_proc_ops, my_data);
/* show에서: struct my_data *data = pde_data(file_inode(file)); */

실수 3: sysfs에서 여러 값 출력

/* ✗ sysfs "one value per file" 원칙 위반 */
static ssize_t status_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
    return sysfs_emit(buf, "%d %d %d %s\\n",
                       dev->temp, dev->voltage, dev->rpm, dev->state);
    /* 문제:
     * - 파싱이 복잡해짐 (어떤 값이 어떤 필드인지 불명확)
     * - ABI 변경 어려움 (필드 추가/순서 변경 불가)
     * - Documentation/ABI/ 심사에서 거부됨
     */
}

/* ✓ 올바른 패턴: 값 하나당 파일 하나 */
/* /sys/devices/.../temp → "45\n" */
/* /sys/devices/.../voltage → "3300\n" */
/* /sys/devices/.../rpm → "1200\n" */
/* /sys/devices/.../state → "active\n" */

/* 예외: hwmon 등 일부 서브시스템은 관례적으로 여러 값 허용 */

실수 4: debugfs에 ABI 의존

# ✗ 나쁜 패턴: 프로덕션 스크립트가 debugfs에 의존
# my_monitoring_script.sh:
# cat /sys/kernel/debug/my_driver/stats  ← 커널 업데이트 시 경로 변경 가능!

# debugfs의 ABI 정책:
# "debugfs interfaces are not considered a stable ABI"
# "They can change at any time without notice"
# "No userspace tool should depend on them"

# ✓ 올바른 패턴:
# - 안정적 인터페이스가 필요하면 sysfs 사용
# - 모니터링 → sysfs 또는 netlink
# - 디버깅 → debugfs (개발자만 사용)
# - 프로파일링 → perf/BPF (안정적 tracepoint)

실수 5: seq_file 콜백에서 sleep/mutex

/* ✗ 위험한 패턴: show 콜백에서 장시간 블로킹 */
static int my_show(struct seq_file *m, void *v)
{
    mutex_lock(&global_mutex);  /* 핫 패스 mutex를 잡음 */
    seq_printf(m, "%d\\n", shared_counter);
    mutex_unlock(&global_mutex);
    return 0;
    /* 문제:
     * - 사용자가 cat /proc/my_entry 할 때마다 global_mutex 경합
     * - seq_file이 버퍼 리사이즈하면 show()가 재호출됨!
     *   → start() → show() [버퍼 부족] → stop() → start() → show() [재시도]
     *   → mutex를 두 번 잡으려고 시도할 수 있음 (deadlock 아니면 데이터 불일치)
     */
}

/* ✓ 개선 패턴: start/stop에서 lock, show에서는 lock 없이 */
static void *my_start(struct seq_file *m, loff_t *pos)
{
    mutex_lock(&my_mutex);
    return seq_list_start(&my_list, *pos);
}
static void my_stop(struct seq_file *m, void *v)
{
    mutex_unlock(&my_mutex);
}
/* start()~stop() 사이에서 show()가 여러 번 호출되어도 lock은 한 번만 */

함정 요약 체크리스트

관련 문서

procfs/sysfs와 관련된 다른 주제를 더 깊이 이해하고 싶다면 다음 문서를 참고하세요.

• VFS — 가상 파일 시스템
• 프로세스 관리 — /proc 프로세스 정보
• 디버깅 — /proc을 통한 커널 정보 확인
• 디바이스 드라이버 — sysfs 디바이스 정보