本番環境におけるeBPF：低オーバーヘッドなLinuxオブザーバビリティ、トレーシング、カーネルプロファイリング

// ファイル: syscall_tracer.c
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#include <bpf/bpf_core_read.h>

#define MAX_FILENAME_LEN 256

// ユーザ空間に送信するイベント構造体
struct event {
    u32 pid;
    u64 latency_ns;
    char comm[16];
    char filename[MAX_FILENAME_LEN];
};

// スレッドID (TID) をキーにして開始時刻を保持するハッシュマップ
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 10240);
    __type(key, u32);
    __type(value, u64);
} start SEC(".maps");

// ユーザ空間へのイベント送信用リングバッファ
struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024); // 256 KB
} events SEC(".maps");

// openatシステムコールの開始トレースポイント
SEC("tracepoint/syscalls/sys_enter_openat")
int tracepoint__syscalls__sys_enter_openat(struct trace_event_raw_sys_enter* ctx) {
    u64 id = bpf_get_current_pid_tgid();
    u32 tid = (u32)id;
    u64 ts = bpf_ktime_get_ns();

    // 開始タイムスタンプを記録
    bpf_map_update_elem(&start, &tid, &ts, BPF_ANY);
    return 0;
}

// openatシステムコールの終了トレースポイント
SEC("tracepoint/syscalls/sys_exit_openat")
int tracepoint__syscalls__sys_exit_openat(struct trace_event_raw_sys_exit* ctx) {
    u64 id = bpf_get_current_pid_tgid();
    u32 tid = (u32)id;
    u64 *ts_ptr;

    // 開始タイムスタンプを取得
    ts_ptr = bpf_map_lookup_elem(&start, &tid);
    if (ts_ptr == 0) {
        return 0;
    }

    u64 latency = bpf_ktime_get_ns() - *ts_ptr;
    bpf_map_delete_elem(&start, &tid);

    // 1マイクロ秒未満の極小イベントはフィルタリング
    if (latency < 1000) {
        return 0;
    }

    // リングバッファにスペースを確保
    struct event *e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
    if (!e) {
        return 0;
    }

    // イベントデータを格納
    u32 pid = id >> 32;
    e->pid = pid;
    e->latency_ns = latency;

    // コマンド名を取得
    bpf_get_current_comm(&e->comm, sizeof(e->comm));

    // コンテキスト引数からファイル名ポインタを取得
    // bpf_probe_read_user_str を使って安全にユーザ空間メモリから読み出す
    const char __user *filename_ptr = (const char __user *)ctx->args[1];
    bpf_probe_read_user_str(&e->filename, sizeof(e->filename), filename_ptr);

    // リングバッファにイベントをコミット
    bpf_ringbuf_submit(e, 0);
    return 0;
}

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

#!/usr/bin/python3
# ファイル: bcc_loader.py
from bcc import BPF
import ctypes as ct

bpf_text = """
#include <uapi/linux/ptrace.h>
#include <linux/fs.h>
#include <linux/sched.h>

#define MAX_FILENAME_LEN 256

struct event {
    u32 pid;
    u64 latency_ns;
    char comm[TASK_COMM_LEN];
    char filename[MAX_FILENAME_LEN];
};
BPF_RINGBUF_OUTPUT(events, 8);
BPF_HASH(start, u32);

int tracepoint__syscalls__sys_enter_openat(struct tracepoint__syscalls__sys_enter_openat *args) {
    u64 id = bpf_get_current_pid_tgid();
    u32 tid = (u32)id;
    u64 ts = bpf_ktime_get_ns();
    start.update(&tid, &ts);
    return 0;
}

int tracepoint__syscalls__sys_exit_openat(struct tracepoint__syscalls__sys_exit_openat *args) {
    u64 id = bpf_get_current_pid_tgid();
    u32 tid = (u32)id;
    u64 *ts_ptr = start.lookup(&tid);

    if (ts_ptr == 0) {
        return 0;
    }

    u64 latency = bpf_ktime_get_ns() - *ts_ptr;
    start.delete(&tid);

    if (latency < 1000) {
        return 0;
    }

    struct event *e = events.ringbuf_reserve(sizeof(struct event));
    if (!e) {
        return 0;
    }

    e->pid = id >> 32;
    e->latency_ns = latency;
    bpf_get_current_comm(&e->comm, sizeof(e->comm));
    
    const char __user* filename_ptr = (const char __user*)args->filename;
    bpf_probe_read_user_str(&e->filename, sizeof(e->filename), filename_ptr);

    events.ringbuf_submit(e, 0);
    return 0;
}
"""

class Event(ct.Structure):
    _fields_ = [
        ("pid", ct.c_uint),
        ("latency_ns", ct.c_ulonglong),
        ("comm", ct.c_char * 16),
        ("filename", ct.c_char * 256),
    ]

def print_event(cpu, data, size):
    event = ct.cast(data, ct.POINTER(Event)).contents
    print(f"{event.pid:<10} {event.comm.decode():<16} {event.latency_ns / 1000:<10.2f} us   '{event.filename.decode()}'")

b = BPF(text=bpf_text)
b["events"].open_ring_buffer(print_event)

print(f"{'PID':<10} {'COMM':<16} {'LATENCY':<13} {'FILENAME'}")

while True:
    try:
        b.ring_buffer_poll()
    except KeyboardInterrupt:
        exit()

// ファイル: go_loader.go
package main

import (
    "bytes"
    "encoding/binary"
    "errors"
    "log"
    "os"
    "os/signal"
    "syscall"

    "github.com/cilium/ebpf/link"
    "github.com/cilium/ebpf/ringbuf"
)

//go:generate go run github.com/cilium/ebpf/cmd/bpf2go syscall_bpf syscall_tracer.c -- -O2 -g -Wall

func main() {
    stopper := make(chan os.Signal, 1)
    signal.Notify(stopper, os.Interrupt, syscall.SIGTERM)

    objs := syscall_bpfObjects{}
    if err := loadSyscall_bpfObjects(&objs, nil); err != nil {
        log.Fatalf("オブジェクトロード失敗: %v", err)
    }
    defer objs.Close()

    enter_tp, err := link.Tracepoint("syscalls", "sys_enter_openat", objs.TracepointSyscallsSysEnterOpenat, nil)
    if err != nil {
        log.Fatalf("enterトレースポイントアタッチ失敗: %v", err)
    }
    defer enter_tp.Close()

    exit_tp, err := link.Tracepoint("syscalls", "sys_exit_openat", objs.TracepointSyscallsSysExitOpenat, nil)
    if err != nil {
        log.Fatalf("exitトレースポイントアタッチ失敗: %v", err)
    }
    defer exit_tp.Close()

    rd, err := ringbuf.NewReader(objs.Events)
    if err != nil {
        log.Fatalf("ringbufリーダー初期化失敗: %v", err)
    }
    defer rd.Close()

    go func() {
        <-stopper
        rd.Close()
    }()

    log.Println("イベント待機中...")
    log.Printf("%-10s %-16s %-13s %s\n", "PID", "COMM", "LATENCY (us)", "FILENAME")

    var event syscall_bpfEvent
    for {
        record, err := rd.Read()
        if err != nil {
            if errors.Is(err, ringbuf.ErrClosed) {
                log.Println("終了シグナルを受信しました")
                return
            }
            log.Printf("読み取りエラー: %v", err)
            continue
        }

        if err := binary.Read(bytes.NewBuffer(record.RawSample), binary.LittleEndian, &event); err != nil {
            log.Printf("パースエラー: %v", err)
            continue
        }
        
        comm := string(event.Comm[:bytes.IndexByte(event.Comm[:], 0)])
        filename := string(event.Filename[:bytes.IndexByte(event.Filename[:], 0)])

        log.Printf("%-10d %-16s %-13.2f %s\n", event.Pid, comm, float64(event.LatencyNs)/1000.0, filename)
    }
}