BPF/eBPF/XDP (BPF and XDP)

Linux BPF/eBPF/XDP를 실무 관점에서 심층 다룹니다. verifier 제약과 BTF·CO-RE 기반 이식성, map 설계 패턴, redirect/tail call, XDP_DROP/PASS/TX/REDIRECT 동작 경로, bpftool·tracepoint 기반 관측, 고 PPS 환경에서의 병목 분석과 디버깅 절차까지 단계적으로 정리합니다.

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

XDP (eXpress Data Path)

XDP는 NIC 드라이버 수준에서 패킷을 처리하는 고성능 데이터 경로입니다. 전체 네트워크 스택을 거치지 않으므로 초저지연 패킷 처리가 가능합니다.

/* XDP program example (C for BPF) */
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <linux/if_ether.h>
#include <linux/ip.h>

SEC("xdp")
int xdp_drop_icmp(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_PASS;

    if (eth->h_proto != htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *iph = (void *)(eth + 1);
    if ((void *)(iph + 1) > data_end)
        return XDP_PASS;

    if (iph->protocol == IPPROTO_ICMP)
        return XDP_DROP;  /* Drop ICMP packets */

    return XDP_PASS;
}

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

# ICE XDP 로드 전 MTU 확인
ip link show eth0 | grep mtu
# MTU 1500이면 XDP 사용 가능 (프레임 = MTU + 헤더 ≈ 1514 < 3072)

# XDP 프로그램 로드
ip link set dev eth0 xdp obj xdp_prog.o sec xdp

# Jumbo Frame + XDP 조합 시 에러 예시
# ip link set eth0 mtu 9000 → XDP 로드 실패 (-EINVAL)

BPF Maps

CO-RE (Compile Once, Run Everywhere)

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

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보다 오버헤드가 낮고 메모리 효율이 좋습니다.

/* 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

SmartNIC과 하드웨어 오프로드

SmartNIC(또는 DPU — Data Processing Unit)은 네트워크 처리를 NIC 자체의 프로세서/FPGA에서 수행하여 호스트 CPU를 해방시키는 차세대 네트워크 인프라 기술입니다.

SmartNIC 유형과 커널 지원

XDP 하드웨어 오프로드

# XDP 실행 모드 비교

# 1. Generic XDP — 모든 NIC에서 동작 (성능 낮음, 테스트/개발용)
ip link set dev eth0 xdpgeneric obj prog.o sec xdp

# 2. Native XDP — NIC 드라이버 지원 필요 (고성능)
ip link set dev eth0 xdp obj prog.o sec xdp

# 3. HW Offload XDP — SmartNIC에서 실행 (최고 성능, 호스트 CPU 0%)
ip link set dev eth0 xdpoffload obj prog.o sec xdp

# 현재 XDP 모드 확인
ip link show dev eth0
# ... xdp/id:42 ... (native)
# ... xdpoffload/id:42 ... (hw offload)

# 성능 비교 (64B 패킷, 단일 코어 기준)
# Generic XDP:  ~5 Mpps
# Native XDP:   ~24 Mpps
# HW Offload:   ~40+ Mpps (NIC 와이어 레이트)

TC Flower 하드웨어 오프로드

# TC flower 규칙을 SmartNIC HW로 오프로드
# — 매칭/액션을 NIC의 eSwitch에서 처리

# switchdev 모드 설정 (eSwitch 활성화)
devlink dev eswitch set pci/0000:03:00.0 mode switchdev

# VF representor를 통한 플로우 오프로드
tc qdisc add dev enp3s0f0_0 ingress
tc filter add dev enp3s0f0_0 ingress protocol ip     flower src_ip 10.0.0.0/24 dst_ip 192.168.1.0/24     action mirred egress redirect dev enp3s0f0_1     skip_sw   # ← skip_sw: HW 전용 (소프트웨어 경로 스킵)

# 오프로드된 플로우 확인
tc -s filter show dev enp3s0f0_0 ingress
# in_hw  ← 하드웨어에서 실행 중임을 표시

SmartNIC 커널 개발 시 고려사항

SmartNIC과 DPDK/AF_XDP 연동

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

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

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

이 취약점은 BPF Verifier가 ALU32 연산에서 비트 연산(AND, OR, XOR)의 결과 범위를 잘못 계산하는 데서 발생합니다. Verifier는 각 레지스터의 가능한 값 범위를 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),
/* 맵 경계 밖의 커널 메모리에 쓰기 가능 */

수정 패치에서는 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의 분기 예측기를 훈련시켜, 배열 경계 검사가 완료되기 전에 투기적으로 범위 밖의 데이터를 로드하게 만듭니다. 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 명령(직렬화 배리어)을 삽입합니다. 또한 포인터 산술에 대한 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 맵 경쟁 조건 사례

BPF_MAP_TYPE_ARRAY는 고정 크기 배열로, 개별 요소에 대한 읽기/쓰기가 원자적이지 않습니다. 멀티 코어 환경에서 동일 요소를 동시에 업데이트하면 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 매크로와 재배치

BPF_CORE_READ() 매크로는 컴파일 시점에 CO-RE 재배치(relocation) 정보를 생성합니다. 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

XDP 드라이버 모드별 성능 비교

XDP는 세 가지 실행 모드를 제공하며, 각 모드는 패킷 처리 위치와 성능이 크게 다릅니다. 실무에서는 NIC 드라이버 지원 여부와 성능 요구사항에 따라 적절한 모드를 선택해야 합니다.

XDP Actions

XDP_REDIRECT와 특수 맵

/* 1. DEVMAP: 다른 NIC으로 패킷 포워딩 */
struct {
    __uint(type, BPF_MAP_TYPE_DEVMAP);
    __uint(max_entries, 256);
    __type(key, __u32);
    __type(value, __u32);  /* ifindex */
} tx_port SEC(".maps");

SEC("xdp")
int xdp_redirect_prog(struct xdp_md *ctx) {
    /* 인덱스 0의 인터페이스로 리다이렉트 */
    return bpf_redirect_map(&tx_port, 0, 0);
}

/* 2. CPUMAP: 특정 CPU로 패킷 분산 */
struct {
    __uint(type, BPF_MAP_TYPE_CPUMAP);
    __uint(max_entries, 64);   /* CPU 수 */
    __type(key, __u32);
    __type(value, __u32);       /* 큐 크기 */
} cpu_map SEC(".maps");

SEC("xdp")
int xdp_cpu_balance(struct xdp_md *ctx) {
    /* 해시 기반으로 CPU 선택 */
    __u32 cpu = compute_hash(ctx) % num_cpus;
    return bpf_redirect_map(&cpu_map, cpu, 0);
}

/* 3. XSKMAP: AF_XDP 소켓으로 전달 */
struct {
    __uint(type, BPF_MAP_TYPE_XSKMAP);
    __uint(max_entries, 64);
    __type(key, __u32);
    __type(value, __u32);  /* xsk fd */
} xsks_map SEC(".maps");

SEC("xdp")
int xdp_to_af_xdp(struct xdp_md *ctx) {
    return bpf_redirect_map(&xsks_map, ctx->rx_queue_index, XDP_PASS);
}

AF_XDP 소켓 아키텍처

AF_XDP는 커널 바이패스에 가까운 성능을 제공하면서도 커널의 XDP 프레임워크와 통합되는 고성능 소켓입니다. DPDK처럼 전체 NIC을 독점하지 않고, XDP 프로그램이 선택한 패킷만 사용자 공간으로 전달합니다.

/* AF_XDP 소켓 설정 (libbpf xsk helpers) */
#include <bpf/xsk.h>

/* UMEM 설정 */
struct xsk_umem_config umem_cfg = {
    .fill_size      = 4096,
    .comp_size      = 4096,
    .frame_size     = 4096,     /* XDP_UMEM_MIN_CHUNK_SIZE */
    .frame_headroom = 0,
    .flags          = 0,        /* XDP_UMEM_UNALIGNED_CHUNK_FLAG 가능 */
};

/* UMEM 생성 */
void *umem_area = mmap(NULL, NUM_FRAMES * FRAME_SIZE,
    PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

struct xsk_umem *umem;
xsk_umem__create(&umem, umem_area, NUM_FRAMES * FRAME_SIZE,
    &fill_ring, &comp_ring, &umem_cfg);

/* 소켓 설정 */
struct xsk_socket_config xsk_cfg = {
    .rx_size = 4096,
    .tx_size = 4096,
    .bind_flags = XDP_USE_NEED_WAKEUP,  /* 절전 모드 지원 */
    .xdp_flags  = XDP_FLAGS_DRV_MODE,   /* native XDP */
};

struct xsk_socket *xsk;
xsk_socket__create(&xsk, "eth0", queue_id,
    umem, &rx_ring, &tx_ring, &xsk_cfg);

/* 수신 루프 */
while (running) {
    __u32 idx_rx = 0, idx_fill = 0;

    /* Fill ring에 빈 프레임 주소 채움 */
    int reserved = xsk_ring_prod__reserve(&fill_ring, BATCH, &idx_fill);
    for (int i = 0; i < reserved; i++)
        *xsk_ring_prod__fill_addr(&fill_ring, idx_fill++) = get_free_frame();
    xsk_ring_prod__submit(&fill_ring, reserved);

    /* RX ring에서 수신된 패킷 읽기 */
    int rcvd = xsk_ring_cons__peek(&rx_ring, BATCH, &idx_rx);
    for (int i = 0; i < rcvd; i++) {
        const struct xdp_desc *desc =
            xsk_ring_cons__rx_desc(&rx_ring, idx_rx++);
        __u8 *pkt = xsk_umem__get_data(umem_area, desc->addr);
        process_packet(pkt, desc->len);
    }
    xsk_ring_cons__release(&rx_ring, rcvd);
}

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 프로그램 개발, 디버깅, 관리를 위한 도구 생태계는 빠르게 성장하고 있습니다. 기본 도구인 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로 추적합니다. 핵심 필드를 살펴보면:

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;
}

XDP Redirect 심화 — devmap, cpumap, AF_XDP

XDP 프로그램의 XDP_REDIRECT 반환값은 단순한 포워딩이 아닙니다. devmap으로 다른 NIC로 전달하거나, cpumap으로 특정 CPU에서 처리하거나, AF_XDP 소켓으로 제로카피 수신할 수 있습니다. 이 세 가지 redirect 경로를 이해하는 것이 XDP 기반 네트워킹의 핵심입니다.

devmap을 이용한 패킷 포워딩

BPF_MAP_TYPE_DEVMAP은 XDP 프로그램이 패킷을 다른 네트워크 인터페이스로 직접 전달할 수 있게 합니다. L2 스위칭, 로드밸런서, hairpin 모드 구현에 핵심적으로 사용됩니다:

struct {
    __uint(type, BPF_MAP_TYPE_DEVMAP);
    __uint(max_entries, 256);
    __type(key, __u32);
    __type(value, __u32);     /* ifindex */
} tx_port SEC(".maps");

/* devmap_val 확장: egress 프로그램 연결 */
struct {
    __uint(type, BPF_MAP_TYPE_DEVMAP);
    __uint(max_entries, 256);
    __type(key, __u32);
    __type(value, struct bpf_devmap_val);
} tx_port_prog SEC(".maps");

SEC("xdp")
int xdp_redirect_port(struct xdp_md *ctx)
{
    __u32 key = 0;  /* 대상 포트 인덱스 */
    return bpf_redirect_map(&tx_port, key, 0);
}

/* devmap egress 프로그램: redirect 직전 패킷 수정 */
SEC("xdp/devmap")
int xdp_egress_rewrite(struct xdp_md *ctx)
{
    void *data = (void *)(long)ctx->data;
    struct ethhdr *eth = data;
    /* MAC 주소 재작성 */
    __builtin_memcpy(eth->h_source, new_src_mac, ETH_ALEN);
    return XDP_PASS;
}

cpumap을 이용한 CPU 분배

RSS(Receive Side Scaling)가 특정 플로우를 하나의 CPU에 집중시키는 문제를 BPF_MAP_TYPE_CPUMAP으로 해결할 수 있습니다:

struct {
    __uint(type, BPF_MAP_TYPE_CPUMAP);
    __uint(max_entries, 64);   /* CPU 수 */
    __type(key, __u32);
    __type(value, __u32);     /* queue_size */
} cpu_map SEC(".maps");

SEC("xdp")
int xdp_cpu_distribute(struct xdp_md *ctx)
{
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
    struct iphdr *iph = data + sizeof(struct ethhdr);

    if ((void *)(iph + 1) > data_end)
        return XDP_PASS;

    /* 5-tuple 해시로 CPU 선택 */
    __u32 cpu = jhash_2words(iph->saddr, iph->daddr, 0) % 8;
    return bpf_redirect_map(&cpu_map, cpu, 0);
}

AF_XDP 제로카피 수신

AF_XDP 소켓은 BPF_MAP_TYPE_XSKMAP을 통해 XDP 프로그램에서 유저스페이스로 직접 패킷을 전달합니다. UMEM(공유 메모리)을 사용한 제로카피 모드에서 최대 성능을 달성합니다:

struct {
    __uint(type, BPF_MAP_TYPE_XSKMAP);
    __uint(max_entries, 64);
    __type(key, __u32);
    __type(value, __u32);
} xsks_map SEC(".maps");

SEC("xdp")
int xdp_sock_prog(struct xdp_md *ctx)
{
    __u32 index = ctx->rx_queue_index;
    /* 해당 큐의 AF_XDP 소켓으로 제로카피 전달 */
    if (bpf_map_lookup_elem(&xsks_map, &index))
        return bpf_redirect_map(&xsks_map, index, 0);
    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;
}

XDP 오프로드 — NIC 하드웨어 실행

XDP 오프로드(XDP_FLAGS_HW_MODE)는 BPF 프로그램을 NIC의 프로그래머블 하드웨어(SmartNIC)에서 직접 실행합니다. CPU를 전혀 사용하지 않으므로 최고의 패킷 처리 성능을 달성할 수 있지만, 지원되는 BPF 기능 집합이 제한적입니다.

오프로드 설정 절차

/* XDP 오프로드 프로그램 로드 (ip 명령) */
// # ip link set dev eth0 xdpoffload obj xdp_prog.o sec xdp

/* bpftool로 오프로드 로드 */
// # bpftool prog load xdp_prog.o /sys/fs/bpf/xdp_offload \
//     type xdp dev eth0 offload

/* 오프로드 BPF 프로그램 제약사항 */
/*
 * 1. 지원 헬퍼 제한: bpf_map_lookup_elem, bpf_map_update_elem 등
 * 2. 루프 불가 (모든 경로가 정적으로 결정)
 * 3. 맵 크기 제한 (하드웨어 메모리에 의존)
 * 4. BPF-to-BPF 호출 미지원
 * 5. 스택 크기 추가 제약 (하드웨어별 상이)
 */

테일 콜과 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);
}

ftrace/bpftrace를 이용한 XDP 성능 분석

XDP 프로그램의 성능 문제를 진단할 때 ftrace tracepoint와 bpftrace는 가장 강력한 도구입니다. 패킷 드롭 원인, 처리 지연, CPU 병목을 실시간으로 관찰할 수 있습니다.

XDP Tracepoint 활용

커널은 XDP 관련 tracepoint를 /sys/kernel/debug/tracing/events/xdp/에 제공합니다:

# XDP 예외(에러) 모니터링
# bpftrace -e 'tracepoint:xdp:xdp_exception { \
#   @drops[args->act] = count(); }'

# XDP redirect 성공/실패 추적
# bpftrace -e 'tracepoint:xdp:xdp_redirect_err { \
#   printf("redirect err: ifindex=%d map=%d err=%d\n", \
#          args->to_ifindex, args->map_id, args->err); }'

# XDP 액션별 패킷 수 집계 (1초 간격)
# bpftrace -e 'tracepoint:xdp:xdp_redirect, \
#              tracepoint:xdp:xdp_exception { \
#   @[probe] = count(); } \
#   interval:s:1 { print(@); clear(@); }'

bpftrace 성능 분석 스크립트

/* XDP 프로그램 실행 시간 히스토그램 (bpftrace 스크립트) */
// #!/usr/bin/env bpftrace
// kprobe:bpf_prog_run_xdp {
//     @start[tid] = nsecs;
// }
// kretprobe:bpf_prog_run_xdp /@start[tid]/ {
//     @ns = hist(nsecs - @start[tid]);
//     delete(@start[tid]);
// }
// interval:s:5 { print(@ns); clear(@ns); }

/* 패킷 드롭 역추적 (bpftrace 스크립트) */
// #!/usr/bin/env bpftrace
// tracepoint:skb:kfree_skb {
//     @reason[args->reason] = count();
//     if (args->reason == 2 /* SKB_DROP_REASON_NOT_SPECIFIED */) {
//         @stacks[kstack] = count();
//     }
// }
// interval:s:10 {
//     printf("\n--- Drop reasons ---\n");
//     print(@reason); clear(@reason);
//     printf("\n--- Drop stacks ---\n");
//     print(@stacks, 5); clear(@stacks);
// }

XDP 디버깅 체크리스트

XDP 성능 비교와 튜닝 가이드

고성능 패킷 처리에서 XDP, iptables(Netfilter), DPDK는 각각 다른 계층에서 동작하며 성능 특성이 크게 다릅니다. 이 섹션에서는 실측 기반 벤치마크와 실전 튜닝 포인트를 정리합니다.

솔루션별 상세 비교

XDP 성능 튜닝 가이드

## 1. NIC 하드웨어 설정
# RSS 큐 수를 CPU 수에 맞춤
# ethtool -L eth0 combined 16

# Ring buffer 크기 최대화
# ethtool -G eth0 rx 4096 tx 4096

# 인터럽트 coalescing 조정 (저지연 vs 처리량)
# ethtool -C eth0 rx-usecs 0 rx-frames 1    # 저지연
# ethtool -C eth0 rx-usecs 50 rx-frames 64   # 고처리량

## 2. IRQ affinity 설정
# CPU 코어별 1:1 매핑
# for i in $(seq 0 15); do
#   echo $i > /proc/irq/$(cat /sys/class/net/eth0/device/msi_irqs/ \
#     | sed -n "$((i+1))p")/smp_affinity_list
# done

## 3. CPU isolation (성능 크리티컬)
# GRUB: isolcpus=4-15 nohz_full=4-15 rcu_nocbs=4-15
# XDP 전용 CPU에서 다른 워크로드 배제

## 4. busy_poll 활성화 (AF_XDP와 함께)
# sysctl -w net.core.busy_poll=50
# sysctl -w net.core.busy_read=50

## 5. NUMA 로컬 메모리 확인
# numactl --cpubind=0 --membind=0 ./xdp_app

벤치마크 방법론

정확한 XDP 벤치마크를 위해 다음 조건을 통제해야 합니다:

참고자료

표준 및 공식 사양

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

커널 공식 문서

• 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

커뮤니티 및 생태계

• ebpf.io — eBPF Foundation 공식 포털
• eBPF Docs — 개발자 중심 지식 베이스
• Cilium BPF & XDP Reference Guide — 아키텍처/opcode/맵 상세 설명
• BPF CO-RE (Andrii Nakryiko) — CO-RE 설계 원리와 사용법
• BPF CO-RE Reference Guide — 매크로별 상세 레퍼런스

도구 및 라이브러리

• 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 등

주요 참고 글

• 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)

커널 소스 경로

• kernel/bpf/verifier.c — BPF Verifier 구현
• kernel/bpf/core.c — BPF 인터프리터/JIT 진입점
• kernel/bpf/syscall.c — bpf() 시스템 콜 처리
• 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 예제 프로그램

관련 문서

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

• 네트워크 스택 — 네트워크 스택과 XDP
• sk_buff — 패킷 처리
• Netfilter — 전통적인 패킷 필터링
• 디바이스 드라이버 — XDP 지원 드라이버
• 개발 도구 — bpftrace 추적 도구
• AF_XDP — AF_XDP 소켓 상세
• DPDK — 커널 바이패스 패킷 처리
• eBPF 보안 정책 — BPF 기반 보안