eBPF，跟踪值比堆栈大小长？

Question

我正在扩展一个程序，它接受跟踪函数的参数并打印它。一切都适用于数字参数和短字符串。但不清楚如何处理长于 eBPF 堆栈大小的长字符串（限制为 512 字节）。

在下面的例子中，字符串被限制为80字节，当然可以增加到512，但是如何跟踪更长的字符串？

具有调用 "ameba"

的跟踪函数的 C 程序示例

#include <stdio.h>
#include <strings.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

char * ameba(char * s1);

int main(void) {
    printf("%s\n", ameba("verylonglongstring...1111111111111111111111111111111111111111111111111111111111111111111111111111"));
}

char * ameba(char * s1) {
    char *s;
    s = (char *) malloc(128);
    sleep(1);
    snprintf(s, 128, "ameba: %s", s1);
    return s;
}

Go 代码示例

package main

import "C"
import (
    "bytes"
    "encoding/binary"
    "fmt"
    "os"
    "os/signal"
    "unsafe"

    bpf "github.com/iovisor/gobpf/bcc"
)

const source string = `
#include <uapi/linux/ptrace.h>
#include <linux/sched.h>

struct ameba_event_t {
        u32 pid;
        char comm[TASK_COMM_LEN];
        char arg1[80];
} __attribute__((packed));

BPF_PERF_OUTPUT(ameba_events);

int get_input_args(struct pt_regs *ctx) {
        struct ameba_event_t event = {};
        if (!PT_REGS_PARM1(ctx))
                return 0;
        event.pid = bpf_get_current_pid_tgid();
        bpf_get_current_comm(&event.comm, sizeof(event.comm));
        bpf_probe_read(&event.arg1, sizeof(event.arg1), (void *)PT_REGS_PARM1(ctx));
        ameba_events.perf_submit(ctx, &event, sizeof(event));

        return 0;
}
`

type amebaEvent struct {
    Pid uint32
    Comm [16]byte
    Arg1 [80]byte
}

func main() {
    m := bpf.NewModule(source, []string{})
    defer m.Close()

    amebaUprobe, err := m.LoadUprobe("get_input_args")
    if err != nil {
        fmt.Fprintf(os.Stderr, "Failed to load get_input_args: %s\n", err)
        os.Exit(1)
    }

    err = m.AttachUprobe("/home/lesovsky/Git/sandbox/ameba", "ameba", amebaUprobe, -1)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Failed to attach input_args: %s\n", err)
        os.Exit(1)
    }

    table := bpf.NewTable(m.TableId("ameba_events"), m)

    channel := make(chan []byte)

    perfMap, err := bpf.InitPerfMap(table, channel)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Failed to init perf map: %s\n", err)
        os.Exit(1)
    }

    sig := make(chan os.Signal, 1)
    signal.Notify(sig, os.Interrupt, os.Kill)

    fmt.Printf("%10s\t%s\t%s\n", "PID", "COMMAND", "ARG1")
    go func() {
        var event amebaEvent
        for {
            data := <-channel
            err := binary.Read(bytes.NewBuffer(data), binary.LittleEndian, &event)
            if err != nil {
                fmt.Printf("failed to decode received data: %s\n", err)
                continue
            }

            comm := (*C.char)(unsafe.Pointer(&event.Comm))
            query := (*C.char)(unsafe.Pointer(&event.Query))
            fmt.Printf("%10d\t%s\t%s\n", event.Pid, C.GoString(comm), C.GoString(query))
        }
    }()

    perfMap.Start()
    <-sig
    perfMap.Stop()
}

我读到 BPF_MAP_TYPE_PERCPU_ARRAY 在这种情况下会有所帮助，但我不清楚如何使用它。

编辑：Go 程序已修改为使用 "C" 和 "unsafe"。

Answer 1

I read about BPF_MAP_TYPE_PERCPU_ARRAY could help in such case, but it's not clear for me how to use it.

你是对的。 Peeps 通常依靠每个 cpu 数组来克服堆栈大小限制。下面实现了这种解决方案，我使用每个 cpu 数组来存储 struct ameba_event_t 而不是将其存储在堆栈中。

我认为您需要 Linux v4.18 才能执行此操作（您需要提交 d71962f）。我没有测试代码，因为我手头没有正确的设置，但如果您运行遇到任何问题，稍后可以。

#include <uapi/linux/ptrace.h>
#include <linux/sched.h>

struct ameba_event_t {
    u32 pid;
    char comm[TASK_COMM_LEN];
    char arg1[512];
} __attribute__((packed));

BPF_PERF_OUTPUT(ameba_events);
BPF_PERCPU_ARRAY(ameba_struct, struct ameba_event_t, 1);

int get_input_args(struct pt_regs *ctx) {
    int zero = 0;
    if (!PT_REGS_PARM1(ctx))
        return 0;
    struct ameba_event_t* event = ameba_struct.lookup(&zero);
    if (!event)
        return 0;
    event->pid = bpf_get_current_pid_tgid();
    bpf_get_current_comm(&event->comm, sizeof(event->comm));
    bpf_probe_read(&event->arg1, sizeof(event->arg1), (void *)PT_REGS_PARM1(ctx));
    ameba_events.perf_submit(ctx, event, sizeof(*event));
    return 0;
}

eBPF，跟踪值比堆栈大小长？

eBPF, track values longer than stack size?

c

bpf

ebpf