eBPF 프레임워크

Linux eBPF(extended Berkeley Packet Filter) 프레임워크를 실무 관점에서 심층 분석합니다. Verifier의 상태 추적과 pruning, BTF·CO-RE 기반 이식성, BPF 맵 설계 패턴, libbpf 스켈레톤 API, BPF 명령어 집합(Instruction Set)(ISA), 프로그램 타입별 hook point, 개발 도구(bpftool/bpftrace), 보안 취약점(Vulnerability) 사례와 성능 최적화까지 단계적으로 정리합니다.

BPF/eBPF 개요

eBPF(extended Berkeley Packet Filter)는 커널 내에서 안전하게 실행되는 프로그래밍 프레임워크입니다. 커널을 재컴파일하지 않고 네트워킹, 보안, 추적, 성능 분석 등의 기능을 확장할 수 있습니다.

개발 환경 설정

BPF/XDP 프로그램을 빌드하고 로드하려면 clang(LLVM 기반 BPF 백엔드), 커널 헤더, libbpf 개발 패키지가 필요합니다. 주요 배포판별 설치 방법은 다음과 같습니다.

배포판별 패키지 설치

# Fedora / RHEL 계열
sudo dnf install clang llvm gcc \
    libbpf-devel bpftool \
    kernel-headers kernel-devel \
    elfutils-libelf-devel zlib-devel

# Debian / Ubuntu 계열
sudo apt install clang llvm gcc \
    libbpf-dev bpftool \
    linux-headers-$(uname -r) \
    libelf-dev zlib1g-dev

# openSUSE 계열
sudo zypper install clang llvm gcc \
    libbpf-devel bpftool \
    kernel-devel \
    libelf-devel zlib-devel

기본 컴파일 흐름

BPF 프로그램은 clang으로 BPF 바이트코드(.o)를 생성한 뒤 커널에 로드합니다.

# 1단계: C → BPF 오브젝트 컴파일
clang -O2 -g -target bpf \
    -D__TARGET_ARCH_x86 \
    -c xdp_prog.c -o xdp_prog.o

# (참고) clang + llc 2단계 파이프라인 (레거시 방식)
# clang -O2 -emit-llvm -c xdp_prog.c -o - | llc -march=bpf -filetype=obj -o xdp_prog.o

# 2단계: 오브젝트 검사
llvm-objdump -d xdp_prog.o       # 명령어 디스어셈블
readelf -S xdp_prog.o             # 섹션 확인 (xdp, maps, license 등)

최소 XDP 프로그램 (XDP_PASS)

/* xdp_pass.c — 모든 패킷을 통과시키는 최소 프로그램 */
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

SEC("xdp")
int xdp_pass_func(struct xdp_md *ctx)
{
    return XDP_PASS;
}

char _license[] SEC("license") = "GPL";

로드 및 확인

# XDP 프로그램 로드 (generic 모드, 모든 드라이버 지원)
sudo ip link set dev eth0 xdpgeneric obj xdp_pass.o sec xdp

# XDP 프로그램 로드 (native 모드, 드라이버 지원 필요)
sudo ip link set dev eth0 xdp obj xdp_pass.o sec xdp

# 로드 확인
ip link show dev eth0
# ... xdp/id:42 ... 형태로 표시

# bpftool로 상세 확인
sudo bpftool prog list
sudo bpftool prog show id 42

# XDP 프로그램 제거
sudo ip link set dev eth0 xdp off

BPF Maps

CO-RE (Compile Once, Run Everywhere)

CO-RE는 BPF 프로그램을 한 번 컴파일하여 다양한 커널 버전에서 실행할 수 있게 합니다. BTF(BPF Type Format)를 활용하여 구조체(Struct) 레이아웃 차이를 자동으로 조정합니다.

BPF Verifier

BPF verifier는 프로그램 로드 시 안전성을 검증합니다. 모든 경로가 종료되는지, 메모리 범위를 벗어나지 않는지, 무한 루프가 없는지 등을 정적으로 분석합니다.

/* Verifier가 검증하는 주요 사항 */
/* 1. 경계 검사: 모든 포인터 접근에 범위 확인 필요 */
if (data + sizeof(struct ethhdr) > data_end)
    return XDP_PASS;  /* 이 검사 없으면 verifier 거부 */

/* 2. 레지스터 상태 추적: R0-R10의 타입과 범위 */
/* 3. 루프 제한: bounded loop만 허용 (5.3+) */
for (int i = 0; i < 256; i++) { /* OK: bounded */
    if (condition) break;
}
/* 4. 명령어 수 제한: 최대 1M instructions (5.2+) */
/* 5. 맵 접근: NULL 체크 필수 */
__u64 *val = bpf_map_lookup_elem(&my_map, &key);
if (val)  /* NULL 체크 없으면 verifier 거부 */
    *val += 1;

BPF 헬퍼 함수

kprobe/tracepoint BPF 프로그램

/* kprobe: 커널 함수 진입 시 실행 */
SEC("kprobe/do_sys_openat2")
int BPF_KPROBE(trace_openat2, int dfd, const char *filename)
{
    u64 pid_tgid = bpf_get_current_pid_tgid();
    u32 pid = pid_tgid >> 32;

    char comm[16];
    bpf_get_current_comm(&comm, sizeof(comm));

    bpf_printk("PID %d (%s) opening file\\n", pid, comm);
    return 0;
}

/* tracepoint: 정적 트레이스포인트에 연결 */
SEC("tracepoint/sched/sched_process_exec")
int trace_exec(struct trace_event_raw_sched_process_exec *ctx)
{
    char comm[16];
    bpf_get_current_comm(&comm, sizeof(comm));
    bpf_printk("exec: %s\\n", comm);
    return 0;
}

BPF Ring Buffer

Ring Buffer는 BPF 프로그램에서 유저스페이스로 이벤트 데이터를 효율적으로 전송하는 메커니즘입니다. perf buffer보다 오버헤드(Overhead)가 낮고 메모리 효율이 좋습니다.

/* BPF 측: 이벤트 전송 */
struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);  /* 256KB */
} events SEC(".maps");

struct event {
    u32 pid;
    char comm[16];
};

SEC("tp/sched/sched_process_fork")
int trace_fork(void *ctx)
{
    struct event *e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
    if (!e) return 0;

    e->pid = bpf_get_current_pid_tgid() >> 32;
    bpf_get_current_comm(&e->comm, sizeof(e->comm));
    bpf_ringbuf_submit(e, 0);
    return 0;
}

libbpf와 BPF 스켈레톤

/* 유저스페이스: libbpf 스켈레톤 활용 */
#include "trace.skel.h"  /* bpftool gen skeleton으로 생성 */

int main(void)
{
    struct trace_bpf *skel;

    skel = trace_bpf__open_and_load();  /* BPF 프로그램 로드 */
    trace_bpf__attach(skel);            /* hook에 연결 */

    /* Ring buffer 폴링 */
    struct ring_buffer *rb;
    rb = ring_buffer__new(
        bpf_map__fd(skel->maps.events),
        handle_event, NULL, NULL);

    while (!exiting)
        ring_buffer__poll(rb, 100);  /* 100ms 타임아웃 */

    trace_bpf__destroy(skel);
}

TC (Traffic Control) BPF

TC BPF는 XDP보다 상위 계층에서 실행되며, 전체 sk_buff 구조체에 접근할 수 있어 더 풍부한 패킷 조작이 가능합니다.

# TC BPF 프로그램 로드
tc qdisc add dev eth0 clsact
tc filter add dev eth0 ingress bpf da obj my_prog.o sec tc_ingress
tc filter add dev eth0 egress  bpf da obj my_prog.o sec tc_egress

# 확인
tc filter show dev eth0 ingress
bpftool prog list

BPF/eBPF 주요 보안 취약점 사례

BPF/eBPF는 커널 내에서 사용자 정의 코드를 실행하는 강력한 메커니즘이지만, Verifier 우회, JIT 취약점, 투기적 실행(Speculative Execution) 등 다양한 공격 벡터가 존재합니다. 아래는 실제로 보고된 주요 보안 취약점 사례와 그 대응 방법입니다.

BPF Verifier 우회 취약점 (CVE-2021-3490)

이 취약점은 BPF Verifier가 ALU32 연산에서 비트 연산(AND, OR, XOR)의 결과 범위를 잘못 계산하는 데서 발생합니다. Verifier는 각 레지스터(Register)의 가능한 값 범위를 tnum(tracked number) 구조체로 추적하는데, 비트 연산 후 tnum 값과 min/max 경계가 불일치하면 실제로는 불가능한 값 범위를 허용하게 됩니다.

/* 취약점을 유발하는 BPF 코드 패턴 (개념 예시) */
/* Verifier가 r0의 범위를 [0, 1]로 추적하지만 */
/* 실제 ALU32 비트 연산 후 범위가 확장될 수 있음 */

BPF_ALU64_IMM(BPF_MOV, BPF_REG_0, 0),
BPF_ALU64_IMM(BPF_OR, BPF_REG_0, 0x7FFFFF00),
/* Verifier는 r0 ≤ 0x7FFFFFFF로 추적하지만 */
/* tnum 분석과 범위 분석의 불일치로 */
/* out-of-bounds 맵 접근이 허용됨 */

BPF_ALU32_IMM(BPF_AND, BPF_REG_0, idx),
/* 이 시점에서 Verifier의 범위 계산 오류 발생 */
BPF_STX_MEM(BPF_DW, BPF_REG_MAP, BPF_REG_0, 0),
/* 맵 경계 밖의 커널 메모리에 쓰기 가능 */

수정 패치(Patch)에서는 ALU 연산의 tnum 검증을 강화하여 비트 연산 후 tnum.value와 tnum.mask가 min/max 경계와 일관성을 유지하도록 했습니다.

# 비특권 BPF 비활성화 (재부팅 시 초기화)
sysctl -w kernel.unprivileged_bpf_disabled=1

# 영구 설정 (/etc/sysctl.d/99-bpf.conf)
kernel.unprivileged_bpf_disabled = 1

BPF JIT Spraying (CVE-2020-8835)

이 취약점은 BPF JIT 컴파일러가 ALU32 연산을 처리할 때 32비트 값의 상위 32비트를 적절히 truncation하지 않아 발생합니다. Verifier는 32비트 연산의 결과를 올바르게 추적하지만, JIT가 생성한 네이티브 코드에서는 64비트 레지스터의 상위 비트가 보존되어 실제 값이 Verifier가 추적한 범위를 벗어나게 됩니다.

/* CVE-2020-8835: 32비트/64비트 불일치 악용 패턴 */

/* 1단계: 64비트 레지스터에 큰 값 로드 */
r1 = 0x100000001    /* 상위 32비트: 1, 하위 32비트: 1 */

/* 2단계: ALU32 연산 — Verifier는 하위 32비트만 추적 */
w1 += 0              /* 32비트 ADD: Verifier는 w1=1로 추적 */
                     /* 그러나 JIT 코드는 상위 비트를 truncate하지 않음 */
                     /* 실제 r1 = 0x100000001 (Verifier 추적 범위 초과) */

/* 3단계: 이 불일치를 이용한 OOB 접근 */
r2 = map_ptr         /* BPF 맵 포인터 */
r2 += r1             /* Verifier: map + 1 (안전) */
                     /* 실제: map + 0x100000001 (OOB!) */
*(r2) = 0            /* 커널 메모리 arbitrary write */

수정 패치에서는 JIT 컴파일러가 모든 ALU32 연산 후에 명시적으로 상위 32비트를 zero-extend하도록 하여 레지스터 값이 Verifier의 추적 범위와 일치하도록 했습니다.

# JIT 상태 확인
cat /proc/sys/net/core/bpf_jit_enable
# 0: 비활성화 (인터프리터)
# 1: 활성화 (기본값, fallback 가능)
# 2: 디버깅 모드 (JIT 이미지 덤프)

# CONFIG_BPF_JIT_ALWAYS_ON=y 시 인터프리터 완전 제거
# JIT 비활성화 불가 — 항상 네이티브 코드 실행

Spectre v1과 BPF (CVE-2019-7308)

Spectre v1(bounds check bypass) 공격은 CPU의 분기 예측(Branch Prediction)기를 훈련시켜, 배열 경계 검사가 완료되기 전에 투기적으로 범위 밖의 데이터를 로드하게 만듭니다. BPF 프로그램은 사용자가 작성한 코드를 커널 내에서 실행하므로, 투기적 실행의 영향을 받는 패턴을 쉽게 만들 수 있었습니다.

/* Spectre v1 공격 패턴 (BPF 맵 배열 접근) */

/* 공격자가 제어하는 인덱스 값 */
r0 = *(u32 *)(r1 + offsetof(ctx, data))  /* 외부 입력 */

/* Verifier는 이 분기를 확인하여 r0 < array_size 보장 */
if r0 >= array_size goto out

/* 그러나 CPU는 투기적으로 분기를 무시하고 실행 */
/* r0가 array_size를 초과하는 값으로 투기적 로드 */
r1 = map_base + r0 * 8   /* 투기적 OOB 포인터 계산 */
r2 = *(u64 *)(r1)        /* 투기적 OOB 로드 — 커널 메모리 읽기 */

/* 캐시 사이드 채널을 통해 r2 값 추출 */
r3 = probe_array + r2 * 64  /* 캐시 라인 크기 단위 접근 */
r4 = *(u64 *)(r3)            /* 캐시에 r2 값의 흔적을 남김 */

수정 패치에서는 Verifier가 투기적 실행에 취약한 패턴을 탐지하여 lfence 명령(직렬화(Serialization) 배리어)을 삽입합니다. 또한 포인터 산술에 대한 BPF_ALU64_REG sanitization을 도입하여, 투기적 실행 경로에서도 포인터가 허용된 범위를 벗어나지 않도록 마스킹합니다.

/* 수정 후: Verifier가 삽입하는 방어 코드 */

if r0 >= array_size goto out

/* Verifier가 자동 삽입하는 sanitization */
r0 &= array_mask        /* 투기적 실행에서도 범위 제한 */
/* x86에서는 lfence 삽입으로 투기적 실행 직렬화 */

r1 = map_base + r0 * 8  /* 이제 투기적 OOB 불가 */
r2 = *(u64 *)(r1)

BPF 맵 경쟁 조건(Race Condition) 사례

BPF_MAP_TYPE_ARRAY는 고정 크기 배열로, 개별 요소에 대한 읽기/쓰기가 원자적(Atomic)이지 않습니다. 멀티 코어 환경에서 동일 요소를 동시에 업데이트하면 torn read/write가 발생하여 일부만 업데이트된 값을 읽을 수 있습니다. BPF_MAP_TYPE_HASH에서는 해시 테이블 resize 과정에서 element가 손실되거나 중복되는 문제가 보고되었습니다.

/* 문제: torn read/write가 발생하는 맵 접근 */
struct stats {
    __u64 packets;
    __u64 bytes;
};

/* CPU 0과 CPU 1이 동시에 같은 키의 stats를 업데이트 */
struct stats *val = bpf_map_lookup_elem(&stats_map, &key);
if (val) {
    val->packets += 1;    /* 비원자적: read-modify-write 경쟁 */
    val->bytes += pkt_len; /* packets과 bytes 사이에 다른 CPU가 끼어들 수 있음 */
    /* 결과: 카운터 손실 또는 packets/bytes 불일치 */
}

bpf_spin_lock을 사용하면 맵 요소에 대한 동기화된 접근이 가능합니다. 커널 5.1부터 지원되며, 맵 value 구조체에 struct bpf_spin_lock 필드를 포함시켜야 합니다.

/* 해결책 1: bpf_spin_lock으로 동기화 */
struct stats_locked {
    struct bpf_spin_lock lock;
    __u64 packets;
    __u64 bytes;
};

struct stats_locked *val = bpf_map_lookup_elem(&stats_map, &key);
if (val) {
    bpf_spin_lock(&val->lock);
    val->packets += 1;
    val->bytes += pkt_len;
    bpf_spin_unlock(&val->lock);
}

/* 해결책 2: per-CPU 맵으로 락 없는 병렬 접근 */
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 256);
    __type(key, __u32);
    __type(value, struct stats);
} stats_percpu SEC(".maps");

/* 각 CPU가 독립적인 복사본에 접근 — 락 불필요 */
struct stats *val = bpf_map_lookup_elem(&stats_percpu, &key);
if (val) {
    val->packets += 1;    /* 경쟁 없음: CPU별 독립 메모리 */
    val->bytes += pkt_len;
}

/* 사용자 공간에서 모든 CPU 값 합산 */
/* bpf_map_lookup_elem()은 ncpus개의 값을 반환 */
__u64 total_packets = 0;
for (int i = 0; i < ncpus; i++)
    total_packets += percpu_vals[i].packets;

eBPF Verifier 상세

BPF Verifier는 커널에서 가장 복잡한 정적 분석기 중 하나입니다. 사용자 공간에서 제출한 BPF 바이트코드가 커널 내에서 안전하게 실행될 수 있는지 로드 시점에 검증합니다. 검증을 통과하지 못한 프로그램은 절대로 커널에서 실행되지 않습니다.

Verifier 아키텍처

Verifier는 추상 해석(abstract interpretation) 기법을 사용합니다. 프로그램의 모든 가능한 실행 경로를 탐색하면서 각 명령어 실행 후의 레지스터 상태를 추적합니다. 핵심 구조체는 struct bpf_verifier_env이며, 검증 과정은 크게 두 단계로 나뉩니다.

BPF 레지스터 규약

eBPF 가상 머신은 11개의 64비트 레지스터(R0~R10)와 512바이트 스택, 프로그램 카운터(PC)를 제공합니다. 이 규약은 호출 규약(calling convention)을 정의하며 BPF 프로그램 작성과 Verifier 이해의 기본이 됩니다.

/* BPF 레지스터 사용 예시 */
SEC("xdp")
int xdp_example(struct xdp_md *ctx)  /* R1 = ctx */
{
    /* R6에 ctx 백업 (callee-saved → 헬퍼 호출 후에도 안전) */
    void *data = (void *)(long)ctx->data;       /* R2 = data */
    void *data_end = (void *)(long)ctx->data_end; /* R3 = data_end */

    /* 헬퍼 호출 시 R1~R5에 인자 전달, R0에 결과 반환 */
    __u64 ts = bpf_ktime_get_ns();  /* R0 = 타임스탬프 */

    /* 스택 변수는 R10(FP) 기준 음수 오프셋 */
    __u32 key = 0;  /* [R10 - 4] = 0 */

    return XDP_PASS;  /* R0 = XDP_PASS (2) */
}

BPF 명령어 집합 (ISA)

eBPF 명령어는 고정 길이 64비트(8바이트) 포맷입니다. 128비트 즉시값(wide immediate)이 필요한 LD_IMM64만 예외적으로 16바이트를 사용합니다. BPF ISA는 2024년 10월 IETF RFC 9669로 공식 표준화되었습니다.

명령어 포맷

산술/논리 연산 (ALU)

ALU 연산은 32비트(BPF_ALU, class 0x04)와 64비트(BPF_ALU64, class 0x07) 두 가지 클래스로 나뉩니다.

점프 연산 (JMP)

점프 연산은 32비트(BPF_JMP32, class 0x06)와 64비트(BPF_JMP, class 0x05) 클래스가 있습니다.

메모리 연산

메모리 접근은 LD/LDX/ST/STX 4가지 클래스를 사용합니다.

크기 지정자:

원자 연산

커널 5.12부터 BPF_STX 클래스에 BPF_ATOMIC 모드(0xc0)가 추가되었습니다. imm 필드에 연산 유형을 지정합니다.

# bpftool로 BPF 프로그램의 명령어 덤프 (JIT 전)
$ sudo bpftool prog dump xlated id 42
   0: (b7) r0 = 2                    # MOV r0, 2 (XDP_PASS)
   1: (95) exit                       # EXIT

# JIT 컴파일된 네이티브 코드 확인
$ sudo bpftool prog dump jited id 42
   0: mov    $0x2,%eax
   5: retq

레지스터 상태 추적

Verifier는 R0~R10 총 11개 레지스터의 상태를 명령어마다 추적합니다. 각 레지스터는 타입(enum bpf_reg_type)과 값 범위(struct tnum — tracked number)를 가지며, 분기 조건에 따라 상태가 정제(refine)됩니다.

/* kernel/bpf/verifier.c — 레지스터 상태 구조체 간소화 */
struct bpf_reg_state {
    enum bpf_reg_type type;  /* PTR_TO_MAP_VALUE, SCALAR_VALUE 등 */
    struct tnum var_off;     /* 비트 단위 알려진 값 추적 */
    s64 smin_value;           /* 부호 있는 최소값 */
    s64 smax_value;           /* 부호 있는 최대값 */
    u64 umin_value;           /* 부호 없는 최소값 */
    u64 umax_value;           /* 부호 없는 최대값 */
    s32 s32_min_value;        /* 32비트 부호 있는 최소 */
    s32 s32_max_value;        /* 32비트 부호 있는 최대 */
    u32 u32_min_value;        /* 32비트 부호 없는 최소 */
    u32 u32_max_value;        /* 32비트 부호 없는 최대 */
};

/* tnum: 비트 단위 추적으로 정밀한 범위 분석 */
struct tnum {
    u64 value;  /* 확실히 1인 비트 */
    u64 mask;   /* 알 수 없는 비트 (1=unknown) */
};
/* 예: value=0x10, mask=0xFF → 값은 0x10~0x1F 또는 0x10|0x00~0xFF 범위 */

루프 검증 (Bounded Loops)

커널 5.3부터 Verifier는 bounded loop를 허용합니다. 루프가 허용되려면 다음 조건을 모두 만족해야 합니다:

• 루프 변수가 매 반복마다 단조 증가 또는 단조 감소해야 합니다
• 종료 조건이 정적으로 결정 가능하거나 Verifier가 반복 횟수의 상한을 추론할 수 있어야 합니다
• 루프 본문이 Verifier 복잡도 예산 내에서 완전히 펼쳐(unroll)질 수 있어야 합니다

/* OK: Verifier가 허용하는 bounded loop */
for (int i = 0; i < 256; i++) {
    if (data + i >= data_end)
        break;
    /* 패킷 데이터 처리 */
}

/* OK: bpf_loop() 헬퍼 (커널 5.17+) — 콜백 기반 루프 */
static long loop_callback(u32 index, void *ctx)
{
    /* 루프 본문 */
    return 0;  /* 0=계속, 1=중단 */
}
bpf_loop(1000, loop_callback, &ctx, 0);

/* FAIL: Verifier가 거부하는 패턴 */
while (ptr != NULL) {  /* ← 상한을 알 수 없음 */
    ptr = ptr->next;
}

맵 접근 검증

bpf_map_lookup_elem() 반환값은 PTR_TO_MAP_VALUE_OR_NULL 타입입니다. Verifier는 이 포인터를 사용하기 전에 반드시 NULL 체크가 있는지 확인하며, 체크 후에는 PTR_TO_MAP_VALUE로 타입을 정제합니다. 맵 값에 대한 접근은 value_size 범위 내로 제한됩니다.

/* Verifier의 맵 접근 검증 과정 */
__u32 key = 0;
struct data *val = bpf_map_lookup_elem(&my_map, &key);
/* 여기서 val의 타입: PTR_TO_MAP_VALUE_OR_NULL */

/* ❌ Verifier 거부: NULL일 수 있는 포인터 역참조 */
// val->count++;  // R0 invalid mem access 'map_value_or_null' */

if (!val)
    return 0;

/* ✅ 여기서 val의 타입: PTR_TO_MAP_VALUE (NULL 아님 확정) */
val->count++;  /* offset 0, value_size 내 → OK */

/* ❌ Verifier 거부: value_size 초과 접근 */
// *((char *)val + 4096) = 0;  // invalid access to map value */

Verifier 로그 읽기

프로그램이 검증에 실패하면 Verifier는 상세한 로그를 출력합니다. 이 로그를 읽는 능력은 BPF 개발에서 매우 중요합니다.

# Verifier 로그 확인 방법

# 1. bpftool로 상세 로그 출력
bpftool prog load prog.o /sys/fs/bpf/prog -d 2>&1 | head -100

# 2. libbpf 로그 레벨 조정
# libbpf_set_print(my_print_fn) 또는 LIBBPF_LOG_LEVEL=debug

# Verifier 로그 출력 예시:
# func#0 @0
# 0: (b7) r1 = 0                    ; R1_w=0
# 1: (63) *(u32 *)(r10 -4) = r1     ; R1_w=0 R10=fp0
# 2: (bf) r2 = r10                  ; R2_w=fp0 R10=fp0
# 3: (07) r2 += -4                  ; R2_w=fp-4
# 4: (18) r1 = 0xffff888012345678   ; R1_w=map_ptr(id=0,...)
# 6: (85) call bpf_map_lookup_elem#1
# 7: (15) if r0 == 0x0 goto pc+3    ; R0_w=map_value_or_null
# 8: (61) r1 = *(u32 *)(r0 +0)      ; R0_w=map_value R1_w=scalar
# ...
# 로그에서 R#_w= 은 레지스터의 현재 타입과 추적 범위를 표시

BPF 맵 타입별 상세

BPF 맵은 커널과 유저스페이스, 또는 BPF 프로그램 간에 데이터를 공유하는 핵심 메커니즘입니다. 용도에 따라 적절한 맵 타입을 선택하는 것이 성능과 정확성에 직접적인 영향을 줍니다.

/* 주요 맵 타입 선언 예시 */

/* 1. LRU_HASH: 자동 퇴거되는 연결 추적 테이블 */
struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __uint(max_entries, 100000);
    __type(key, struct flow_key);   /* src_ip, dst_ip, proto, ports */
    __type(value, struct flow_stats);
} conn_table SEC(".maps");

/* 2. LPM_TRIE: CIDR 기반 IP 매칭 */
struct {
    __uint(type, BPF_MAP_TYPE_LPM_TRIE);
    __uint(max_entries, 10000);
    __uint(map_flags, BPF_F_NO_PREALLOC);
    __type(key, struct bpf_lpm_trie_key_u8);  /* prefixlen + data */
    __type(value, __u32);
} ip_blocklist SEC(".maps");

/* 3. STACK_TRACE: 프로파일링용 스택 저장 */
struct {
    __uint(type, BPF_MAP_TYPE_STACK_TRACE);
    __uint(max_entries, 8192);
    __uint(key_size, sizeof(__u32));
    __uint(value_size, 100 * sizeof(__u64));
} stackmap SEC(".maps");

/* 4. QUEUE: 키 없는 FIFO */
struct {
    __uint(type, BPF_MAP_TYPE_QUEUE);
    __uint(max_entries, 1024);
    __type(value, struct event);
} event_queue SEC(".maps");

/* QUEUE 사용법 */
struct event e = { .pid = pid, .ts = ts };
bpf_map_push_elem(&event_queue, &e, BPF_ANY);  /* enqueue */
/* 사용자 공간에서: bpf_map_lookup_and_delete_elem() → dequeue */

CO-RE (Compile Once, Run Everywhere) 상세

CO-RE는 BPF 프로그램의 이식성 문제를 해결하는 핵심 기술입니다. 커널 구조체의 레이아웃은 버전마다 달라질 수 있는데, CO-RE는 BTF(BPF Type Format) 정보를 활용하여 컴파일 시점의 구조체 오프셋을 실행 시점에 자동으로 재조정(relocate)합니다.

BTF (BPF Type Format)

BTF는 BPF 프로그램과 커널의 타입 정보를 컴팩트하게 인코딩하는 형식입니다. DWARF 디버그 정보를 축소한 것으로, 커널 이미지에 포함되어 /sys/kernel/btf/vmlinux에서 접근할 수 있습니다.

# BTF 지원 확인
ls -la /sys/kernel/btf/vmlinux
# 파일이 있으면 BTF 지원 커널

# vmlinux.h 생성 — 모든 커널 타입 정의를 담은 헤더
bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h
# 약 10만 줄 이상의 C 헤더 생성
# 이 헤더만 include하면 커널 헤더 의존성 제거

# 특정 구조체의 BTF 정보 확인
bpftool btf dump file /sys/kernel/btf/vmlinux | grep -A 20 "struct task_struct"

# 커널 모듈의 BTF 확인
bpftool btf dump file /sys/kernel/btf/nf_conntrack

bpf_core_read 매크로(Macro)와 재배치(Relocation)

BPF_CORE_READ() 매크로는 컴파일 시점에 CO-RE 재배치 정보를 생성합니다. libbpf가 프로그램을 로드할 때, 컴파일 시점의 오프셋을 실행 중인 커널의 BTF와 비교하여 자동으로 수정합니다.

#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_core_read.h>

/* CO-RE 방식: 필드 오프셋이 자동 재배치됨 */
SEC("tp/sched/sched_process_exec")
int trace_exec(void *ctx)
{
    struct task_struct *task = (struct task_struct *)bpf_get_current_task();

    /* BPF_CORE_READ: 중첩 포인터를 안전하게 따라감 */
    pid_t pid = BPF_CORE_READ(task, tgid);
    pid_t ppid = BPF_CORE_READ(task, real_parent, tgid);

    /* 구조체 필드 존재 여부 런타임 확인 */
    if (bpf_core_field_exists(task->loginuid)) {
        uid_t loginuid = BPF_CORE_READ(task, loginuid.val);
    }

    /* 필드 크기 확인 (커널 버전별 다를 수 있음) */
    if (bpf_core_field_size(task->comm) == 16) {
        /* TASK_COMM_LEN == 16인 커널 */
    }

    return 0;
}

/* struct flavor: 커널 버전별로 다른 구조체 레이아웃 대응 */
struct task_struct___old {   /* ___old 접미사 = flavor */
    int prio;
    int static_prio;
    /* 이전 커널에서 다른 위치에 있던 필드 */
};

/* bpf_core_type_matches()로 어떤 flavor인지 런타임 판별 */
if (bpf_core_type_matches(struct task_struct___old)) {
    /* 이전 구조체 레이아웃 사용 */
}

CO-RE 워크플로

# CO-RE 개발 워크플로

# 1. vmlinux.h 생성 (개발 머신에서 한 번)
bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h

# 2. BPF 프로그램 컴파일 (CO-RE 활성화)
clang -g -O2 -target bpf \
    -D__TARGET_ARCH_x86 \
    -c prog.bpf.c -o prog.bpf.o

# 3. 스켈레톤 생성
bpftool gen skeleton prog.bpf.o > prog.skel.h

# 4. 사용자 프로그램 컴파일
gcc -g -O2 -o prog prog.c -lbpf -lelf -lz

# 이 바이너리를 다른 커널 버전 시스템에 복사해도 동작!
# libbpf가 로드 시 BTF 재배치를 자동 수행

libbpf 프로그래밍 상세

libbpf는 BPF 프로그램의 로드, 검증, 어태치를 관리하는 공식 사용자 공간 라이브러리입니다. 스켈레톤(skeleton) API는 BPF 프로그램의 맵, 프로그램, 전역 변수에 대한 타입 안전한 접근을 제공합니다.

Skeleton API

/* === BPF 측 (prog.bpf.c) === */
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>

/* 전역 변수: 사용자 공간에서 직접 읽기/쓰기 가능 */
const volatile pid_t target_pid = 0;  /* .rodata → 로드 시 설정 */
__u64 event_count = 0;                  /* .bss → 런타임 업데이트 */

struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);
} events SEC(".maps");

SEC("tp/sched/sched_process_exec")
int handle_exec(void *ctx)
{
    pid_t pid = bpf_get_current_pid_tgid() >> 32;
    if (target_pid && pid != target_pid)
        return 0;

    __sync_fetch_and_add(&event_count, 1);
    /* ... 이벤트 전송 ... */
    return 0;
}

/* === 사용자 측 (prog.c) === */
#include "prog.skel.h"  /* bpftool gen skeleton으로 생성 */

int main(int argc, char **argv)
{
    struct prog_bpf *skel;

    /* 1단계: open — ELF 파싱, 맵/프로그램 탐색 */
    skel = prog_bpf__open();
    if (!skel) return 1;

    /* 2단계: 로드 전 설정 — 전역 변수, 맵 크기 조정 */
    skel->rodata->target_pid = atoi(argv[1]);
    bpf_map__set_max_entries(skel->maps.events, 512 * 1024);

    /* 3단계: load — verifier 검증, JIT 컴파일, 맵 생성 */
    if (prog_bpf__load(skel)) {
        fprintf(stderr, "BPF load failed\n");
        goto cleanup;
    }

    /* 4단계: attach — hook point에 연결 */
    if (prog_bpf__attach(skel)) {
        fprintf(stderr, "BPF attach failed\n");
        goto cleanup;
    }

    /* 5단계: 이벤트 수신 (ring buffer) */
    struct ring_buffer *rb = ring_buffer__new(
        bpf_map__fd(skel->maps.events),
        handle_event, NULL, NULL);

    while (!exiting) {
        ring_buffer__poll(rb, 100);
        /* 전역 변수 읽기 (mmap 기반) */
        printf("events: %llu\n", skel->bss->event_count);
    }

cleanup:
    ring_buffer__free(rb);
    prog_bpf__destroy(skel);
    return 0;
}

프로그램 타입별 Attach

/* libbpf 수동 attach 예시 */

/* kprobe — 커널 함수 진입점 */
struct bpf_link *link = bpf_program__attach_kprobe(
    skel->progs.my_kprobe, false, "tcp_v4_connect");

/* tracepoint — 정적 트레이스포인트 */
link = bpf_program__attach_tracepoint(
    skel->progs.my_tp, "net", "net_dev_xmit");

/* perf event — 하드웨어/소프트웨어 이벤트 */
link = bpf_program__attach_perf_event(
    skel->progs.my_perf, pmu_fd);

/* XDP — 네트워크 인터페이스 */
link = bpf_program__attach_xdp(
    skel->progs.my_xdp, ifindex);

/* cgroup — cgroup 경로 기반 */
link = bpf_program__attach_cgroup(
    skel->progs.my_cgroup, cgroup_fd);

/* LSM — 보안 모듈 hook */
/* SEC("lsm/bprm_check_security") → 자동 attach */

/* struct_ops — 커널 ops 테이블 교체 */
link = bpf_map__attach_struct_ops(skel->maps.my_tcp_cc);

Perf Buffer vs Ring Buffer

BPF 프로그램 타입

BPF 프로그램은 타입에 따라 커널의 특정 hook point에 부착됩니다. 각 타입은 컨텍스트 구조체, 사용 가능한 헬퍼 함수, 반환값의 의미가 다릅니다.

/* 주요 프로그램 타입 예시 */

/* fentry/fexit — kprobe보다 오버헤드가 낮은 BTF 기반 트레이싱 */
SEC("fentry/tcp_v4_connect")
int BPF_PROG(trace_tcp_connect, struct sock *sk,
            struct sockaddr *uaddr, int addr_len)
{
    /* BTF 기반: 인자를 직접 타입으로 받음 (pt_regs 불필요) */
    __u16 dport = sk->__sk_common.skc_dport;
    bpf_printk("connecting to port %d\n", ntohs(dport));
    return 0;
}

/* struct_ops — TCP 혼잡 제어 알고리즘 BPF로 구현 */
SEC("struct_ops/my_cong_init")
void BPF_PROG(my_cong_init, struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    tp->snd_cwnd = 10;  /* 초기 혼잡 윈도우 */
}

SEC(".struct_ops")
struct tcp_congestion_ops my_bpf_cc = {
    .init       = (void *)my_cong_init,
    .ssthresh   = (void *)my_ssthresh,
    .cong_avoid = (void *)my_cong_avoid,
    .name       = "bpf_my_cc",
};

/* LSM — 동적 보안 정책 */
SEC("lsm/bprm_check_security")
int BPF_PROG(restrict_exec, struct linux_binprm *bprm)
{
    /* 특정 바이너리의 실행을 차단 */
    const char *filename = BPF_CORE_READ(bprm, filename);
    /* 정책에 따라 -EPERM 반환으로 차단 */
    return 0;  /* 0=허용, 음수=차단 */
}

BPF 헬퍼 함수 상세

BPF 헬퍼 함수는 BPF 프로그램이 커널 기능에 접근하는 유일한 인터페이스입니다. 각 프로그램 타입마다 사용 가능한 헬퍼가 다르며, Verifier가 컴파일 시점에 이를 강제합니다.

맵 조작 헬퍼

/* 맵 조작 — 모든 프로그램 타입에서 사용 가능 */

/* 조회: 키에 해당하는 값의 포인터 반환 (NULL 가능) */
void *bpf_map_lookup_elem(struct bpf_map *map, const void *key);

/* 갱신: flags로 동작 제어 */
long bpf_map_update_elem(struct bpf_map *map,
    const void *key, const void *value, __u64 flags);
/* flags: BPF_ANY(0)=삽입 또는 갱신
         BPF_NOEXIST(1)=없을 때만 삽입
         BPF_EXIST(2)=있을 때만 갱신 */

/* 삭제: 해시 맵 전용 (배열은 삭제 불가) */
long bpf_map_delete_elem(struct bpf_map *map, const void *key);

/* 원자적 갱신: per-CPU가 아닌 맵에서 카운터 증가 */
__u64 *val = bpf_map_lookup_elem(&counter_map, &key);
if (val)
    __sync_fetch_and_add(val, 1);  /* 원자적 증가 */

메모리 읽기와 트레이싱 헬퍼

/* 커널 메모리 안전 읽기 (kprobe, tracepoint, fentry) */
long bpf_probe_read_kernel(void *dst, __u32 size, const void *unsafe_ptr);
long bpf_probe_read_kernel_str(void *dst, __u32 size, const void *unsafe_ptr);

/* 사용자 공간 메모리 읽기 */
long bpf_probe_read_user(void *dst, __u32 size, const void *unsafe_ptr);
long bpf_probe_read_user_str(void *dst, __u32 size, const void *unsafe_ptr);

/* 프로세스 정보 */
__u64 bpf_get_current_pid_tgid(void);    /* 상위 32비트=tgid, 하위=pid */
__u64 bpf_get_current_uid_gid(void);    /* 상위 32비트=gid, 하위=uid */
long  bpf_get_current_comm(void *buf, __u32 size);
struct task_struct *bpf_get_current_task(void);

/* 타임스탬프 */
__u64 bpf_ktime_get_ns(void);            /* 부팅 후 나노초 */
__u64 bpf_ktime_get_boot_ns(void);       /* 슬립 포함 나노초 */

/* 디버그 출력 — /sys/kernel/debug/tracing/trace_pipe에서 확인 */
long bpf_trace_printk(const char *fmt, __u32 fmt_size, ...);
/* 최대 3개 인자, %d/%u/%x/%lld/%llu/%llx/%p/%s 지원 */
/* 프로덕션에서는 사용 금지 — 성능 오버헤드 큼 */

네트워크 헬퍼

/* XDP/TC 전용 네트워크 헬퍼 */

/* 패킷 리다이렉트 */
long bpf_redirect(__u32 ifindex, __u64 flags);
long bpf_redirect_map(struct bpf_map *map, __u32 key, __u64 flags);

/* 패킷 데이터 수정 (TC) */
long bpf_skb_store_bytes(struct __sk_buff *skb,
    __u32 offset, const void *from, __u32 len, __u64 flags);

/* L3/L4 체크섬 재계산 */
long bpf_l3_csum_replace(struct __sk_buff *skb,
    __u32 offset, __u64 from, __u64 to, __u64 flags);
long bpf_l4_csum_replace(struct __sk_buff *skb,
    __u32 offset, __u64 from, __u64 to, __u64 flags);

/* 패킷 크기 조정 */
long bpf_skb_change_head(struct __sk_buff *skb, __u32 len, __u64 flags);
long bpf_skb_change_tail(struct __sk_buff *skb, __u32 len, __u64 flags);

/* XDP 패킷 크기 조정 */
long bpf_xdp_adjust_head(struct xdp_md *xdp, int delta);
long bpf_xdp_adjust_tail(struct xdp_md *xdp, int delta);

/* FIB (라우팅 테이블) 조회 */
long bpf_fib_lookup(void *ctx, struct bpf_fib_lookup *params,
    int plen, __u32 flags);
/* XDP/TC에서 커널 라우팅 테이블을 직접 조회하여 L2 헤더 완성 */

BPF 개발 도구

BPF 프로그램 개발, 디버깅(Debugging), 관리를 위한 도구 생태계는 빠르게 성장하고 있습니다. 기본 도구인 bpftool부터 고수준 프레임워크까지 용도에 따라 적절한 도구를 선택합니다.

bpftool

bpftool은 BPF 프로그램과 맵을 관리하는 공식 CLI 도구입니다. 커널 소스 트리의 tools/bpf/bpftool/에서 빌드됩니다.

# 프로그램 관리
bpftool prog list                          # 로드된 BPF 프로그램 목록
bpftool prog show id 42                    # 특정 프로그램 상세 정보
bpftool prog dump xlated id 42             # BPF 바이트코드 덤프
bpftool prog dump jited id 42              # JIT 네이티브 코드 덤프
bpftool prog dump xlated id 42 visual      # DOT 그래프 (graphviz용)

# 맵 관리
bpftool map list                            # BPF 맵 목록
bpftool map dump id 5                       # 맵 전체 내용 덤프
bpftool map lookup id 5 key 0x01 0x00 0x00 0x00  # 특정 키 조회
bpftool map update id 5 key 1 0 0 0 value 100 0 0 0  # 값 갱신

# BTF 관리
bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h
bpftool btf dump id 1                       # BTF 정보 덤프

# 스켈레톤 생성
bpftool gen skeleton prog.bpf.o > prog.skel.h

# 프로그램 pin/unpin (BPF 파일시스템)
bpftool prog pin id 42 /sys/fs/bpf/my_prog
bpftool prog load prog.o /sys/fs/bpf/my_prog type xdp

# 네트워크 관련
bpftool net list                            # XDP/TC에 부착된 프로그램 목록

# 기능 지원 확인
bpftool feature probe                       # 현재 커널의 BPF 기능 점검

bpftrace

bpftrace는 AWK와 유사한 고수준 트레이싱 언어로, 한 줄짜리 스크립트로 강력한 커널 분석이 가능합니다.

# bpftrace 원라이너 예시

# 시스템 콜 빈도 상위 10개
bpftrace -e 'tracepoint:raw_syscalls:sys_enter { @[comm] = count(); }'

# TCP 연결 추적
bpftrace -e 'kprobe:tcp_v4_connect { printf("%s -> %s\n", comm, str(arg0)); }'

# 프로세스별 read 지연 히스토그램
bpftrace -e '
kprobe:vfs_read { @start[tid] = nsecs; }
kretprobe:vfs_read /@start[tid]/ {
    @us[comm] = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

# XDP 드롭 패킷 수 모니터링
bpftrace -e 'tracepoint:xdp:xdp_bulk_tx { @drops = count(); }'

# CPU별 소프트 IRQ 처리 시간
bpftrace -e '
tracepoint:irq:softirq_entry { @start[cpu] = nsecs; }
tracepoint:irq:softirq_exit /@start[cpu]/ {
    @ns[cpu, args->vec] = hist(nsecs - @start[cpu]);
    delete(@start[cpu]);
}'

BPF 라이브러리 생태계

// cilium/ebpf (Go) 사용 예시
package main

import (
    "github.com/cilium/ebpf"
    "github.com/cilium/ebpf/link"
)

//go:generate go run github.com/cilium/ebpf/cmd/bpf2go counter counter.bpf.c

func main() {
    objs := counterObjects{}
    if err := loadCounterObjects(&objs, nil); err != nil {
        log.Fatal(err)
    }
    defer objs.Close()

    // kprobe에 BPF 프로그램 부착
    kp, _ := link.Kprobe("tcp_v4_connect", objs.TraceTcpConnect, nil)
    defer kp.Close()

    // 맵에서 값 읽기
    var count uint64
    objs.CounterMap.Lookup(uint32(0), &count)
}

// Aya (Rust) 사용 예시
use aya::{Bpf, programs::Xdp, maps::HashMap};
use aya::programs::XdpFlags;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut bpf = Bpf::load_file("prog.o")?;

    // XDP 프로그램 로드 및 부착
    let program: &mut Xdp = bpf.program_mut("xdp_prog")?
        .try_into()?;
    program.load()?;
    program.attach("eth0", XdpFlags::default())?;

    // 맵 접근
    let blocklist: HashMap<_, u32, u32> =
        HashMap::try_from(bpf.map_mut("blocklist")?)?;
    blocklist.insert(167772161, 1, 0)?;  // 10.0.0.1 차단

    Ok(())
}

BPF 검증기 — 상태 탐색과 Pruning

BPF Verifier는 프로그램의 모든 실행 경로를 추상 해석(abstract interpretation)으로 탐색합니다. 각 분기점에서 레지스터의 타입(type)과 값 범위(range)를 추적하며, 이미 검증된 상태와 동일한 상태에 도달하면 가지치기(pruning)로 중복 탐색을 제거합니다. 이 메커니즘이 없으면 명령어 100만 개 제한 내에서 실제 프로그램 대부분을 검증할 수 없습니다.

상태 추적 구조체

Verifier는 각 명령어 실행 후의 레지스터 상태를 struct bpf_reg_state로 추적합니다. 핵심 필드를 살펴보면:

/* kernel/bpf/verifier.c — Verifier 레지스터/프레임 상태 간소화 */
struct bpf_reg_state {
    enum bpf_reg_type type;     /* PTR_TO_MAP_VALUE, SCALAR_VALUE 등 */
    struct tnum var_off;           /* 비트 단위 known/unknown 마스크 */
    s64 smin_value, smax_value;    /* 부호 있는 최솟값/최댓값 */
    u64 umin_value, umax_value;    /* 부호 없는 최솟값/최댓값 */
    s32 s32_min_value, s32_max_value;
    u32 u32_min_value, u32_max_value;
    s64 off;                       /* 포인터 오프셋 */
    u32 id;                        /* 조건부 NULL 검사 연결 ID */
};

/* 프레임 상태: 레지스터 + 스택 슬롯 */
struct bpf_func_state {
    struct bpf_reg_state regs[MAX_BPF_REG]; /* R0-R10 */
    struct bpf_stack_state *stack;
    int allocated_stack;
    int callsite;
};

Pruning 알고리즘

상태 가지치기(state pruning)는 Verifier 성능의 핵심입니다. 매 분기점(prune point)에서 이전에 검증된 상태 목록과 현재 상태를 비교합니다:

/* kernel/bpf/verifier.c — states_equal() 핵심 로직 */
static bool states_equal(struct bpf_verifier_env *env,
                         struct bpf_verifier_state *old,
                         struct bpf_verifier_state *cur)
{
    /* 모든 프레임의 모든 레지스터를 비교 */
    for (i = 0; i <= cur->curframe; i++) {
        for (j = 0; j < MAX_BPF_REG; j++) {
            /* cur 상태가 old 상태의 부분집합인지 확인 */
            if (!regsafe(env, &old_regs[j], &cur_regs[j], idmap))
                return false;
        }
    }
    return true;
}

Bounded Loop 검증

커널 5.3 이후 BPF 프로그램에서 제한된 루프가 허용됩니다. Verifier는 루프 카운터의 범위를 추적하여 반복 횟수가 유한함을 정적으로 증명합니다:

/* 커널이 허용하는 bounded loop 패턴 */
SEC("xdp")
int xdp_parse_headers(struct xdp_md *ctx)
{
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
    struct ethhdr *eth = data;

    /* Verifier가 허용: 루프 상한 명확 */
    #pragma unroll
    for (int i = 0; i < 10; i++) {
        if ((void *)(eth + 1) > data_end)
            break;
        /* VLAN 태그 파싱 */
        if (eth->h_proto == bpf_htons(ETH_P_8021Q))
            eth = (void *)eth + 4;
        else
            break;
    }
    return XDP_PASS;
}

BPF 맵 타입 비교와 선택 가이드

BPF 맵은 BPF 프로그램과 유저스페이스 간의 데이터 공유 채널이자, BPF 프로그램 간 상태 공유 수단입니다. 맵 타입 선택이 성능과 동시성 특성을 결정하므로, 각 타입의 특성을 정확히 이해해야 합니다.

맵 타입 상세 비교

PERCPU 맵 패턴: 카운터 집계

PERCPU 맵은 각 CPU가 독립적인 값 복사본을 가지므로 lock 없이 고빈도 업데이트가 가능합니다. 단, 읽기 시 모든 CPU의 값을 집계해야 합니다:

/* BPF 측: PERCPU_ARRAY로 패킷/바이트 카운터 */
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 1);
    __type(key, __u32);
    __type(value, struct counters);
} stats SEC(".maps");

struct counters {
    __u64 packets;
    __u64 bytes;
};

SEC("xdp")
int xdp_count(struct xdp_md *ctx)
{
    __u32 key = 0;
    struct counters *cnt = bpf_map_lookup_elem(&stats, &key);
    if (cnt) {
        cnt->packets++;
        cnt->bytes += (ctx->data_end - ctx->data);
    }
    return XDP_PASS;
}

/* 유저스페이스: PERCPU 값 집계 */
int ncpus = libbpf_num_possible_cpus();
struct counters values[ncpus];
__u32 key = 0;

bpf_map_lookup_elem(map_fd, &key, values);

__u64 total_pkts = 0, total_bytes = 0;
for (int i = 0; i < ncpus; i++) {
    total_pkts += values[i].packets;
    total_bytes += values[i].bytes;
}

테일 콜과 BPF-to-BPF 호출

BPF 프로그램의 로직이 복잡해지면 단일 프로그램의 명령어 제한(1M)과 스택 제한(512B)에 부딪힙니다. 테일 콜(tail call)과 BPF-to-BPF 호출(BPF subprogram)은 이 문제를 해결하는 두 가지 메커니즘입니다.

테일 콜 구현 패턴

/* PROG_ARRAY 맵 정의 */
struct {
    __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
    __uint(max_entries, 8);
    __type(key, __u32);
    __type(value, __u32);
} jmp_table SEC(".maps");

/* 프로토콜별 파서를 분리하는 패턴 */
SEC("xdp")
int xdp_dispatcher(struct xdp_md *ctx)
{
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
    struct ethhdr *eth = data;

    if ((void *)(eth + 1) > data_end)
        return XDP_DROP;

    switch (bpf_ntohs(eth->h_proto)) {
    case ETH_P_IP:
        bpf_tail_call(ctx, &jmp_table, 0);  /* IPv4 파서로 */
        break;
    case ETH_P_IPV6:
        bpf_tail_call(ctx, &jmp_table, 1);  /* IPv6 파서로 */
        break;
    case ETH_P_ARP:
        bpf_tail_call(ctx, &jmp_table, 2);  /* ARP 처리기로 */
        break;
    }
    /* tail call 실패 시 폴백 */
    return XDP_PASS;
}

SEC("xdp/ipv4")
int xdp_parse_ipv4(struct xdp_md *ctx)
{
    /* IPv4 전용 처리 로직 */
    return XDP_PASS;
}

BPF-to-BPF 호출 (서브프로그램)

/* static 함수로 선언하면 BPF-to-BPF 호출로 컴파일 */
static __always_inline int
parse_eth_header(struct xdp_md *ctx, struct ethhdr **eth_out)
{
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
    struct ethhdr *eth = data;

    if ((void *)(eth + 1) > data_end)
        return -1;

    *eth_out = eth;
    return 0;
}

/* 인라인하지 않는 서브프로그램 (스택 프레임 별도) */
static __noinline int
process_packet(struct xdp_md *ctx, __u32 src_ip)
{
    __u32 *blocked = bpf_map_lookup_elem(&blocklist, &src_ip);
    if (blocked)
        return XDP_DROP;
    return XDP_PASS;
}

SEC("xdp")
int xdp_main(struct xdp_md *ctx)
{
    struct ethhdr *eth;
    if (parse_eth_header(ctx, &eth) < 0)
        return XDP_DROP;
    /* ... IPv4 파싱 후 process_packet 호출 ... */
    return process_packet(ctx, iph->saddr);
}

실전 예제: BPF 기반 L4 로드밸런서

XDP_REDIRECT와 BPF 맵을 결합하면 커널 공간(Kernel Space)에서 고성능 L4 로드밸런서를 구현할 수 있습니다. 이 방식은 Facebook의 Katran, Cilium의 로드밸런서에서 사용하는 패턴입니다.

L4 로드밸런서 핵심 코드

// xdp_lb.bpf.c — XDP L4 로드밸런서
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>

struct vip_key {
    __u32 vip;
    __u16 port;
    __u8  proto;
    __u8  pad;
};

struct backend_info {
    __u32 addr;
    unsigned char mac[6];
    __u16 port;
    __u32 ifindex;      /* redirect 대상 인터페이스 */
};

struct conn_key {
    __u32 saddr;
    __u32 daddr;
    __u16 sport;
    __u16 dport;
    __u8  proto;
};

/* VIP → 서비스 ID 매핑 */
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, struct vip_key);
    __type(value, __u32);           /* service_id */
    __uint(max_entries, 256);
} vip_map SEC(".maps");

/* 백엔드 서버 배열 (Maglev 해시 결과 인덱스) */
struct {
    __uint(type, BPF_MAP_TYPE_ARRAY);
    __type(key, __u32);
    __type(value, struct backend_info);
    __uint(max_entries, 65537);     /* Maglev table size (prime) */
} backend_map SEC(".maps");

/* 연결 추적 (기존 연결 유지) */
struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __type(key, struct conn_key);
    __type(value, __u32);           /* backend index */
    __uint(max_entries, 1000000);
} ct_map SEC(".maps");

/* devmap for redirect */
struct {
    __uint(type, BPF_MAP_TYPE_DEVMAP_HASH);
    __type(key, __u32);
    __type(value, struct bpf_devmap_val);
    __uint(max_entries, 256);
} tx_port SEC(".maps");

static __always_inline __u32 hash_tuple(struct conn_key *key)
{
    /* 간단한 해시 — 프로덕션에서는 jhash 사용 */
    return (key->saddr ^ key->daddr ^ key->sport ^ key->dport) % 65537;
}

SEC("xdp")
int xdp_lb(struct xdp_md *ctx)
{
    void *data     = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_DROP;
    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end)
        return XDP_DROP;

    /* TCP만 처리 (UDP LB도 동일 패턴) */
    if (ip->protocol != IPPROTO_TCP)
        return XDP_PASS;

    struct tcphdr *tcp = (void *)ip + (ip->ihl * 4);
    if ((void *)(tcp + 1) > data_end)
        return XDP_DROP;

    /* VIP 조회 */
    struct vip_key vk = {
        .vip   = ip->daddr,
        .port  = tcp->dest,
        .proto = ip->protocol,
    };
    __u32 *svc_id = bpf_map_lookup_elem(&vip_map, &vk);
    if (!svc_id)
        return XDP_PASS;  /* VIP 아님 → 정상 경로 */

    /* 연결 추적 조회 (기존 연결 유지) */
    struct conn_key ck = {
        .saddr = ip->saddr, .daddr = ip->daddr,
        .sport = tcp->source, .dport = tcp->dest,
        .proto = ip->protocol,
    };
    __u32 *existing = bpf_map_lookup_elem(&ct_map, &ck);
    __u32 backend_idx;

    if (existing) {
        backend_idx = *existing;
    } else {
        backend_idx = hash_tuple(&ck);
        bpf_map_update_elem(&ct_map, &ck, &backend_idx, BPF_ANY);
    }

    /* 백엔드 조회 */
    struct backend_info *be = bpf_map_lookup_elem(&backend_map, &backend_idx);
    if (!be)
        return XDP_DROP;

    /* IP 헤더 재작성 (DNAT) */
    ip->daddr = be->addr;
    ip->check = 0;  /* 체크섬은 offload 또는 incremental 업데이트 */

    /* MAC 헤더 재작성 */
    __builtin_memcpy(eth->h_dest, be->mac, 6);

    /* XDP_REDIRECT로 백엔드 인터페이스로 전달 */
    return bpf_redirect_map(&tx_port, be->ifindex, 0);
}

char LICENSE[] SEC("license") = "GPL";

실전 예제: eBPF 기반 네트워크 모니터링

소켓 필터와 tracepoint BPF 프로그램을 활용하면 시스템의 네트워크 동작을 실시간(Real-time)으로 관측할 수 있습니다. tcpdump와 달리 커널 내부에서 집계하므로 오버헤드가 극히 낮습니다.

// net_monitor.bpf.c — 연결별 트래픽 모니터링
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_core_read.h>

struct conn_info {
    __u64 bytes_sent;
    __u64 bytes_recv;
    __u64 pkts_sent;
    __u64 pkts_recv;
    __u64 retransmits;
    __u32 srtt_us;          /* smoothed RTT (μs) */
    __u32 last_cwnd;        /* congestion window */
};

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, __u64);             /* socket cookie */
    __type(value, struct conn_info);
    __uint(max_entries, 65536);
} conn_stats SEC(".maps");

/* Ring buffer for events */
struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);
} events SEC(".maps");

struct event {
    __u32 pid;
    __u32 saddr;
    __u32 daddr;
    __u16 sport;
    __u16 dport;
    __u64 bytes;
    __u32 srtt_us;
};

SEC("tracepoint/tcp/tcp_probe")
int trace_tcp_probe(struct trace_event_raw_tcp_probe *ctx)
{
    __u64 cookie = BPF_CORE_READ(ctx, sock_cookie);
    struct conn_info *ci = bpf_map_lookup_elem(&conn_stats, &cookie);

    if (!ci) {
        struct conn_info new_ci = {};
        bpf_map_update_elem(&conn_stats, &cookie, &new_ci, BPF_NOEXIST);
        ci = bpf_map_lookup_elem(&conn_stats, &cookie);
        if (!ci) return 0;
    }

    ci->srtt_us   = BPF_CORE_READ(ctx, srtt_us);
    ci->last_cwnd = BPF_CORE_READ(ctx, snd_cwnd);
    ci->bytes_sent += BPF_CORE_READ(ctx, data_len);
    ci->pkts_sent++;

    return 0;
}

SEC("tracepoint/tcp/tcp_retransmit_skb")
int trace_tcp_retransmit(struct trace_event_raw_tcp_retransmit_skb *ctx)
{
    __u64 cookie = BPF_CORE_READ(ctx, sock_cookie);
    struct conn_info *ci = bpf_map_lookup_elem(&conn_stats, &cookie);
    if (ci)
        __sync_fetch_and_add(&ci->retransmits, 1);

    /* 재전송 이벤트 ring buffer 전달 */
    struct event *e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
    if (e) {
        e->pid   = bpf_get_current_pid_tgid() >> 32;
        e->saddr = BPF_CORE_READ(ctx, saddr);
        e->daddr = BPF_CORE_READ(ctx, daddr);
        e->sport = BPF_CORE_READ(ctx, sport);
        e->dport = BPF_CORE_READ(ctx, dport);
        bpf_ringbuf_submit(e, 0);
    }
    return 0;
}

char LICENSE[] SEC("license") = "GPL";

bpftrace를 이용한 빠른 모니터링

# TCP 연결별 재전송 카운트 (상위 10)
bpftrace -e 'tracepoint:tcp:tcp_retransmit_skb {
    @retrans[ntop(args->saddr), ntop(args->daddr), args->sport, args->dport] = count();
}
interval:s:5 { print(@retrans, 10); clear(@retrans); }'

# XDP 프로그램 처리 시간 분포 (ns)
bpftrace -e 'kprobe:bpf_prog_run_xdp { @start[tid] = nsecs; }
kretprobe:bpf_prog_run_xdp /@start[tid]/ {
    @latency_ns = hist(nsecs - @start[tid]);
    delete(@start[tid]);
}'

# 소켓별 송수신 바이트 실시간 추적
bpftrace -e 'tracepoint:sock:sock_send_length {
    @send_bytes[comm, args->length] = count();
}
tracepoint:sock:sock_recv_length {
    @recv_bytes[comm, args->length] = count();
}'

흔한 실수와 안티패턴

BPF/XDP 개발에서 자주 발생하는 실수와 안티패턴을 정리합니다. 이 패턴들을 미리 파악하면 디버깅 시간을 크게 줄일 수 있습니다.

Verifier 에러 패턴

Map 크기 설계 실수

/* 안티패턴: 단일 CPU에서 전역 해시 맵으로 고 PPS 카운터 */
struct {
    __uint(type, BPF_MAP_TYPE_HASH);      /* ✗ 잠금 경합 발생 */
    __type(key, __u32);
    __type(value, __u64);
    __uint(max_entries, 1000000);
} bad_counter SEC(".maps");

/* 올바른 패턴: per-CPU 맵 사용 */
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_HASH);  /* ✓ CPU별 독립 */
    __type(key, __u32);
    __type(value, __u64);
    __uint(max_entries, 1000000);
} good_counter SEC(".maps");

/* 안티패턴: 고정 크기 해시 맵으로 동적 엔트리 관리 */
struct {
    __uint(type, BPF_MAP_TYPE_HASH);      /* ✗ 가득 차면 새 엔트리 삽입 실패 */
    __type(key, __u32);
    __type(value, __u64);
    __uint(max_entries, 1024);
} bad_flow_table SEC(".maps");

/* 올바른 패턴: LRU 해시로 자동 퇴거 */
struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);  /* ✓ 오래된 엔트리 자동 제거 */
    __type(key, __u32);
    __type(value, __u64);
    __uint(max_entries, 1024);
} good_flow_table SEC(".maps");

XDP MTU/프래그먼트 처리 누락

/* 안티패턴: 단일 선형 버퍼만 가정 */
SEC("xdp")
int bad_xdp(struct xdp_md *ctx)
{
    void *data     = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
    /* ✗ 멀티버퍼 패킷이면 data~data_end가 전체가 아님 */
    int pkt_len = data_end - data;  /* 선형 부분만 */
    ...
}

/* 올바른 패턴: 멀티버퍼 인식 (6.x+) */
SEC("xdp.frags")
int good_xdp(struct xdp_md *ctx)
{
    void *data     = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    /* 선형 부분 + 프래그먼트 = 전체 패킷 */
    int linear_len = data_end - data;
    /* bpf_xdp_get_buff_len()으로 전체 길이 확인 (6.5+) */
    __u64 total_len = bpf_xdp_get_buff_len(ctx);

    /* 프래그먼트 접근은 bpf_xdp_load_bytes() 사용 */
    char buf[64];
    if (bpf_xdp_load_bytes(ctx, linear_len, buf, sizeof(buf)) < 0)
        return XDP_PASS;  /* 프래그먼트 없으면 정상 처리 */
    ...
}

CO-RE 미사용으로 인한 호환성 문제

/* 안티패턴: 커널 헤더 직접 포함 (빌드 환경 커널에 종속) */
#include <linux/sched.h>

SEC("tp_btf/sched_switch")
int bad_trace(u64 *ctx)
{
    struct task_struct *prev = (void *)ctx[0];
    /* ✗ task_struct 오프셋이 커널 버전마다 다름 */
    int pid = prev->pid;
    ...
}

/* 올바른 패턴: CO-RE + vmlinux.h + BPF_CORE_READ */
#include "vmlinux.h"
#include <bpf/bpf_core_read.h>

SEC("tp_btf/sched_switch")
int good_trace(u64 *ctx)
{
    struct task_struct *prev = (void *)ctx[0];
    /* ✓ BTF 기반으로 런타임에 오프셋 재배치 */
    int pid = BPF_CORE_READ(prev, pid);
    ...
}

/* CO-RE 필드 존재 확인 (조건부 접근) */
SEC("tp_btf/sched_switch")
int safe_trace(u64 *ctx)
{
    struct task_struct *prev = (void *)ctx[0];

    /* 필드가 존재하는 커널에서만 접근 */
    if (bpf_core_field_exists(prev->se.cfs_rq)) {
        void *cfs_rq = BPF_CORE_READ(prev, se.cfs_rq);
        /* ... */
    }
    ...
}

실습 가이드: bpftool/bpftrace 디버깅

BPF 프로그램의 디버깅은 일반 프로그램과 다릅니다. 커널 내 실행이므로 GDB를 직접 사용할 수 없지만 bpftool, bpftrace, tracepoint을 활용하면 효과적으로 디버깅할 수 있습니다.

bpftool 디버깅 기법

# 로드된 BPF 프로그램 목록 (상세)
sudo bpftool prog list -j | python3 -m json.tool

# 프로그램 상세 정보 (JIT, 맵 바인딩)
sudo bpftool prog show id 42 --pretty

# BPF 바이트코드 덤프 (verifier가 본 명령어)
sudo bpftool prog dump xlated id 42

# JIT 어셈블리 덤프 (실제 실행 코드)
sudo bpftool prog dump jited id 42

# 프로그램 실행 통계 (활성화 필요)
sudo sysctl kernel.bpf_stats_enabled=1
sudo bpftool prog show id 42
# run_cnt: 15234  run_time_ns: 892340
# → 평균 실행 시간: 892340/15234 ≈ 58.6ns

# 맵 조회/수정
sudo bpftool map show
sudo bpftool map dump id 5
sudo bpftool map update id 5 key 0x01 0x00 0x00 0x00 value 0xFF 0x00 0x00 0x00

# BTF 정보 확인
sudo bpftool btf show
sudo bpftool btf dump id 1 format c | head -50

# 프로그램 Pin (파일시스템에 고정)
sudo bpftool prog pin id 42 /sys/fs/bpf/my_xdp_prog
ls -la /sys/fs/bpf/my_xdp_prog

bpftrace 활용 디버깅

# XDP 프로그램 호출 빈도 추적
sudo bpftrace -e 'tracepoint:xdp:xdp_bulk_tx { @bulk[args->action] = count(); }'

# XDP 액션별 카운트
sudo bpftrace -e '
tracepoint:xdp:xdp_redirect { @redirect = count(); }
tracepoint:xdp:xdp_redirect_err { @redirect_err = count(); }
tracepoint:xdp:xdp_exception { @exception[args->act] = count(); }
'

# BPF 프로그램 로드/언로드 이벤트
sudo bpftrace -e '
tracepoint:bpf:bpf_prog_load {
    printf("LOAD prog_id=%d type=%d name=%s\n",
           args->prog_id, args->prog_type, str(args->prog_name));
}
tracepoint:bpf:bpf_prog_free {
    printf("FREE prog_id=%d\n", args->prog_id);
}'

# verifier 로그 확인 (로드 실패 시)
# libbpf 로그 레벨 설정
export LIBBPF_LOG_LEVEL=debug

# 또는 코드에서:
# struct bpf_object_open_opts opts = { .sz = sizeof(opts) };
# libbpf_set_print(my_log_fn);

# 맵 연산 추적
sudo bpftrace -e '
kprobe:htab_map_update_elem {
    @update_map = count();
}
kprobe:htab_map_lookup_elem {
    @lookup_map = count();
}
interval:s:1 { print(@update_map); print(@lookup_map);
    clear(@update_map); clear(@lookup_map); }'

BPF 성능 최적화

BPF 프로그램의 성능을 극대화하기 위한 JIT 최적화, batch 연산, 효율적 맵 선택 등의 기법을 다룹니다.

JIT 컴파일 최적화

# JIT 활성화 확인 및 설정
cat /proc/sys/net/core/bpf_jit_enable
# 0: 비활성, 1: 활성, 2: 디버그 모드 (프로덕션에서 사용 금지)
sudo sysctl net.core.bpf_jit_enable=1

# JIT kallsyms 활성화 (perf에서 BPF 함수명 표시)
sudo sysctl net.core.bpf_jit_kallsyms=1

# JIT 하드닝 (보안 강화, 약간의 성능 비용)
cat /proc/sys/net/core/bpf_jit_harden
# 0: 비활성, 1: unprivileged만, 2: 모든 프로그램
sudo sysctl net.core.bpf_jit_harden=1

Batch 연산

/* 맵 Batch 연산 (5.6+) — 대량 읽기/쓰기 성능 향상 */
#include <bpf/bpf.h>

/* 일반 방식: O(n) 시스템 콜 */
for (int i = 0; i < 10000; i++)
    bpf_map_lookup_elem(fd, &keys[i], &values[i]);  /* 10,000번 syscall */

/* Batch 방식: O(1) 시스템 콜 */
__u32 count = 10000;
DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts, .elem_flags = 0, .flags = 0);

/* 한 번의 syscall로 10,000개 항목 조회 */
bpf_map_lookup_batch(fd, NULL, &next_key,
                     keys, values, &count, &opts);

/* Batch 업데이트 */
bpf_map_update_batch(fd, keys, values, &count, &opts);

/* Batch 삭제 */
bpf_map_delete_batch(fd, keys, &count, &opts);

/* Lookup-and-delete Batch (통계 수집에 이상적) */
bpf_map_lookup_and_delete_batch(fd, NULL, &next_key,
                                keys, values, &count, &opts);

Bloom Filter Map (5.16+)

/* BPF_MAP_TYPE_BLOOM_FILTER — 빠른 존재 확인 (false positive 허용) */
struct {
    __uint(type, BPF_MAP_TYPE_BLOOM_FILTER);
    __type(value, __u32);
    __uint(max_entries, 1000000);
    __uint(map_extra, 3);       /* hash 함수 개수 (2-5 권장) */
} bloom SEC(".maps");

SEC("xdp")
int xdp_with_bloom(struct xdp_md *ctx)
{
    /* ... 패킷 파싱 ... */
    __u32 saddr = ip->saddr;

    /* 1단계: Bloom Filter로 빠른 검사 (O(k), k=hash 함수 수) */
    if (bpf_map_peek_elem(&bloom, &saddr) != 0)
        return XDP_PASS;  /* 확실히 블랙리스트 아님 */

    /* 2단계: 정확한 해시 맵 조회 (Bloom 양성일 때만) */
    if (bpf_map_lookup_elem(&blacklist, &saddr))
        return XDP_DROP;

    return XDP_PASS;
}
/* → Bloom Filter가 대부분의 정상 트래픽을 O(1)로 통과시켜 성능 향상 */

struct_ops 기반 커널 확장

BPF_PROG_TYPE_STRUCT_OPS(5.6+)는 커널 내부의 함수 포인터 테이블을 BPF 프로그램으로 대체하는 메커니즘입니다. TCP 혼잡 제어 알고리즘, 스케줄러(sched_ext) 등을 커널 모듈(Kernel Module) 없이 BPF로 구현할 수 있습니다.

BPF TCP 혼잡 제어 예제

// bpf_cc.bpf.c — BPF 기반 TCP 혼잡 제어
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>

/* 간단한 AIMD (Additive Increase, Multiplicative Decrease) 구현 */

SEC("struct_ops")
void BPF_PROG(bpf_aimd_init, struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    tp->snd_cwnd = 10;  /* 초기 cwnd */
}

SEC("struct_ops")
void BPF_PROG(bpf_aimd_cong_avoid, struct sock *sk, __u32 ack, __u32 acked)
{
    struct tcp_sock *tp = tcp_sk(sk);

    if (tp->snd_cwnd < tp->snd_ssthresh) {
        /* Slow Start: 지수적 증가 */
        tp->snd_cwnd += acked;
    } else {
        /* Congestion Avoidance: 선형 증가 */
        tp->snd_cwnd_cnt += acked;
        if (tp->snd_cwnd_cnt >= tp->snd_cwnd) {
            tp->snd_cwnd++;
            tp->snd_cwnd_cnt = 0;
        }
    }
}

SEC("struct_ops")
__u32 BPF_PROG(bpf_aimd_ssthresh, struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    /* Multiplicative Decrease: cwnd / 2 */
    return max(tp->snd_cwnd >> 1, 2U);
}

SEC("struct_ops")
__u32 BPF_PROG(bpf_aimd_undo_cwnd, struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    return max(tp->snd_cwnd, tp->snd_ssthresh);
}

SEC(".struct_ops")
struct tcp_congestion_ops bpf_aimd = {
    .init       = (void *)bpf_aimd_init,
    .cong_avoid = (void *)bpf_aimd_cong_avoid,
    .ssthresh   = (void *)bpf_aimd_ssthresh,
    .undo_cwnd  = (void *)bpf_aimd_undo_cwnd,
    .name       = "bpf_aimd",
};

char LICENSE[] SEC("license") = "GPL";

# struct_ops 등록
sudo bpftool struct_ops register bpf_cc.bpf.o

# 등록된 struct_ops 확인
sudo bpftool struct_ops list

# 소켓에 혼잡 제어 알고리즘 적용
sysctl net.ipv4.tcp_congestion_control=bpf_aimd

# 또는 소켓 옵션으로 개별 적용
# setsockopt(fd, IPPROTO_TCP, TCP_CONGESTION, "bpf_aimd", 9);

# 해제
sudo bpftool struct_ops unregister name bpf_aimd

BPF 토큰과 보안 모델 (6.9+)

BPF 토큰은 컨테이너(Container)/샌드박스(Sandbox) 환경에서 BPF 기능에 대한 세밀한 권한 위임을 가능하게 하는 보안 메커니즘입니다. 기존의 CAP_BPF/CAP_SYS_ADMIN 바이너리 권한 모델을 대체합니다.

/* BPF 토큰 생성 (호스트에서) */
#include <linux/bpf.h>
#include <bpf/bpf.h>

/* 토큰이 허용할 BPF 기능 정의 */
LIBBPF_OPTS(bpf_token_create_opts, token_opts,
    .flags = 0,
);

/* BPF 파일시스템에 토큰 고정 */
int bpffs_fd = open("/sys/fs/bpf/container_a", O_DIRECTORY);
int token_fd = bpf_token_create(bpffs_fd, &token_opts);

/* 토큰을 컨테이너에 전달 (fd 또는 UDS 경유) */

/* 컨테이너 내부에서 토큰 사용 */
LIBBPF_OPTS(bpf_prog_load_opts, prog_opts,
    .token_fd = token_fd,
);
/* 토큰 범위 내의 프로그램만 로드 가능 */

BPF Map 타입별 구조 비교

BPF Arena — 공유 메모리 맵(Memory Map) (6.9+)

BPF arena는 Alexei Starovoitov가 2024년 제안하고 커널 6.9에 BPF_MAP_TYPE_ARENA로 머지된 새로운 맵 타입입니다. 최대 4 GB 크기의 희소(sparse) 공유 메모리 영역을 생성하여 BPF 프로그램과 사용자 공간이 동일한 주소 공간(Address Space)(포인터 호환)을 통해 무복사(zero-copy) 양방향 접근을 하도록 합니다. 기존 맵들이 key-value 구조였다면, arena는 실제 포인터 기반 자료구조(연결 리스트(Linked List), 트리, 그래프)를 자연스럽게 구현할 수 있는 첫 번째 맵입니다.

기존 맵과의 비교

BPF Arena 사용 예제

/* arena_prog.bpf.c — 커널 측 BPF 프로그램 */
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>

struct {
    __uint(type, BPF_MAP_TYPE_ARENA);
    __uint(map_flags, BPF_F_MMAPABLE);
    __uint(max_entries, 1024);            /* 페이지 수 — 지연 할당 */
    #ifdef __TARGET_ARCH_x86
    __ulong(map_extra, 0x1ull << 44);      /* 사용자 공간 고정 주소 힌트 */
    #endif
} arena SEC(".maps");

/* arena 전용 포인터 어노테이션 — 주소 범위가 재배치됨 */
struct node {
    int value;
    struct node __arena *next;
};

struct node __arena *head = NULL;

/* kfunc: 페이지 할당 — 6.9+ */
extern void *bpf_arena_alloc_pages(void *map, void *addr,
                                     __u32 page_cnt, int node_id, __u64 flags) __ksym;

SEC("tracepoint/syscalls/sys_enter_write")
int push_node(void *ctx)
{
    struct node __arena *n;

    n = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
    if (!n)
        return 0;

    n->value = bpf_get_prandom_u32();
    n->next  = head;               /* 진짜 포인터 */
    head     = n;                   /* 원자 업데이트 권장 */
    return 0;
}

/* 사용자 공간 — 동일한 arena 메모리를 mmap으로 매핑 */
#include <bpf/libbpf.h>

struct node {
    int value;
    struct node *next;          /* 동일 주소 공간이므로 역참조 가능 */
};

int main(void)
{
    struct arena_prog_bpf *skel = arena_prog_bpf__open_and_load();
    arena_prog_bpf__attach(skel);

    int fd   = bpf_map__fd(skel->maps.arena);
    size_t sz = 4096 * 1024;
    void *base = mmap((void *)(0x1ull << 44), sz,
                      PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, fd, 0);

    /* BPF가 채운 리스트를 사용자 공간에서 순회 — syscall 없이 */
    struct node *p = *(struct node **)base;
    while (p) {
        printf("value=%d\n", p->value);
        p = p->next;
    }
}

주요 활용 사례

• 대규모 스케줄러(sched_ext) — CPU별 런큐(Runqueue)/태스크(Task) 큐를 arena에 구성하여 사용자 공간 디버거가 zero-copy로 상태를 관찰
• networking 상태 테이블 — 수백만 개의 conntrack/flow 엔트리를 linked hash로 구현, agentless 덤프(Dump) 지원
• BPF JIT 최적화 — arena 포인터는 검증기가 PTR_TO_ARENA로 추적하므로 일반 맵 조회보다 3~10배 빠른 역참조 성능
• GPU/NPU 런타임과 공유 — BPF_F_MMAPABLE + DMA-BUF 조합으로 가속기가 동일 메모리에 접근 (연구 중)

BPF 2026 최신 동향 요약

커널 6.9~6.18 범위에서 BPF 서브시스템에 추가된 주요 기능을 요약합니다. 각 항목의 상세는 해당 섹션 또는 외부 링크를 참조하세요.

참고자료

표준 및 공식 사양

• RFC 9669 — BPF Instruction Set Architecture (ISA) — IETF 공식 표준 (2024.10)
• BPF ISA Specification (커널 문서) — 커널 트리 내 표준 사양
• BPF ABI Conventions — 레지스터 호출 규약, 바이트 순서
• IETF BPF Working Group — BPF 표준화 작업 그룹, 드래프트 문서

커널 공식 문서

• BPF Documentation Hub — 커널 BPF 문서 최상위
• BPF Verifier — Verifier 동작 원리
• BPF Design Q&A — 설계 결정 배경 (스택 512B, 명령어 1M 등)
• BPF kfuncs — 커널 함수 직접 호출 인터페이스
• Classic BPF vs eBPF — cBPF→eBPF 비교
• libbpf Overview (커널 문서)
• AF_XDP Documentation — AF_XDP 공식 문서
• eBPF Userspace API
• BPF Maps — 맵 타입별 동작, 동시성 보장, BTF 맵 정의
• BPF Type Format (BTF) — CO-RE의 핵심, 타입 정보 인코딩
• BPF_PROG_RUN — 유닛 테스트용 BPF 프로그램 실행 인터페이스
• BPF CPUMAP — XDP에서 다른 CPU로 패킷 리다이렉션
• BPF Ring Buffer — BPF_MAP_TYPE_RINGBUF, perf buffer 대비 장점

커뮤니티 및 생태계

• ebpf.io — eBPF Foundation 공식 포털
• eBPF Docs — 개발자 중심 지식 베이스
• Cilium BPF & XDP Reference Guide — 아키텍처/opcode/맵 상세 설명
• BPF CO-RE (Andrii Nakryiko) — CO-RE 설계 원리와 사용법
• BPF CO-RE Reference Guide — 매크로별 상세 레퍼런스
• Meta BPF Blog — Meta의 BPF 프로덕션 활용 사례
• Isovalent Blog — Cilium/eBPF 개발사의 기술 블로그
• BPF 메일링 리스트 아카이브 — 커널 BPF 패치, 리뷰, 논의

도구 및 라이브러리

• libbpf (GitHub) — 공식 BPF 라이브러리
• libbpf API Documentation
• bpftool (GitHub) — BPF 프로그램/맵 관리 CLI
• BCC (BPF Compiler Collection) — Python/Lua 기반 BPF 도구
• bpftrace — 고수준 트레이싱 언어
• XDP Tutorial — 단계별 XDP 학습
• XDP Tools — xdp-loader, xdp-filter 등
• Cilium (GitHub) — eBPF 기반 CNI, 네트워크 보안, 로드 밸런싱
• Falco Libs (GitHub) — eBPF 기반 런타임 보안 감지
• Tetragon (GitHub) — eBPF 기반 보안 관찰 및 정책 강제
• Tracee (GitHub) — eBPF 기반 런타임 보안 및 포렌식

주요 참고 글

• Linux eBPF Tracing Tools (Brendan Gregg)
• Dive into BPF (Quentin Monnet) — BPF 역사와 생태계 총정리
• Bounded loops in BPF for the 5.3 kernel (LWN)
• Atomics for eBPF (LWN) — 커널 5.12 원자 연산 추가
• The BPF ISA is now RFC 9669 (LWN)
• BPF as a revolutionary technology (LWN) — BPF의 리눅스 커널 내 위치와 미래
• Calling kernel functions from BPF (LWN) — kfunc 메커니즘 소개
• Extending BPF for network scheduling (LWN) — EDT 기반 패킷 스케줄링
• BPF, pair and loop (LWN) — BPF linked list, kptr 지원
• eBPF Instruction Sets (Paul Chaignon) — v1/v2/v3 명령어 세트 비교
• Cloudflare: Programmable Packet Filtering with eBPF — 프로덕션 XDP 방화벽(Firewall) 사례

커널 소스 경로

• kernel/bpf/verifier.c — BPF Verifier 구현
• kernel/bpf/core.c — BPF 인터프리터/JIT 진입점(Entry Point)
• kernel/bpf/syscall.c — bpf() 시스템 콜(System Call) 처리
• net/core/filter.c — 네트워크 BPF 헬퍼 함수
• net/core/dev.c — XDP 훅 포인트 (generic XDP)
• include/uapi/linux/bpf.h — BPF UAPI (프로그램 타입, 맵 타입, 헬퍼 정의)
• include/linux/filter.h — BPF 명령어 매크로
• tools/lib/bpf/ — libbpf 소스
• tools/bpf/bpftool/ — bpftool 소스
• samples/bpf/ — BPF 예제 프로그램

관련 문서

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

• BPF/eBPF/XDP 허브 — BPF와 XDP 전체 개요
• XDP (Express Data Path) — XDP 패킷 처리 전용 문서
• 네트워크 스택 — 네트워크 스택과 BPF
• sk_buff — 패킷 처리
• Netfilter — 전통적인 패킷 필터링
• 디바이스 드라이버 — BPF 지원 드라이버
• 개발 도구 — bpftrace 추적 도구
• AF_XDP — AF_XDP 소켓 상세
• DPDK — 커널 바이패스 패킷 처리
• eBPF 보안 정책 — BPF 기반 보안