C eBPF，轨迹值是否大于堆栈大小？

我正在扩展一个程序，它接受跟踪函数的参数并打印它。对于数值参数和短字符串，一切都可以正常工作。但目前还不清楚如何处理eBPF中比堆栈大小长的长字符串（限制为512字节）

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

带有跟踪函数的C程序示例，该函数称为“ameba”

#包括
#包括
#包括
#包括
#包括
char*ameba（char*s1）；
内部主（空）{
printf（“%s\n”，ameba（“verylonglongstring…1111111111111111111111111111111111111111111111111”）；
}
char*ameba（char*s1）{
char*s；
s=（char*）malloc（128）；
睡眠（1）；
snprintf（s，128，“阿米巴：%s”，s1）；
返回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()
}

主程序包
输入“C”
进口(
“字节”
“编码/二进制”
“fmt”
“操作系统”
“操作系统/信号”
“不安全”
bpf“github.com/iovisor/gobpf/bcc”
)
常量源字符串=`
#包括
#包括
结构ameba\u事件\u t{
u32-pid；
字符通信[任务通信]；
chararg1[80]；
}_uuu属性_uuu（（压缩））；
BPF_性能输出（ameba_事件）；
int get_input_args（结构pt_regs*ctx）{
结构ameba_event_t event={}；
如果（！PT_REGS_PARM1（ctx））
返回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））；
返回0；
}
`
类型amebaEvent结构{
Pid uint32
Comm[16]字节
Arg1[80]字节
}
func main（）{
m:=bpf.NewModule（源代码，[]字符串{}）
延迟m.关闭（）
amebaUprobe，err:=m.LoadUprobe（“获取输入参数”）
如果错误！=零{
fmt.Fprintf（os.Stderr，“未能加载获取输入参数：%s\n”，错误）
操作系统退出（1）
}
err=m.AttachUprobe（“/home/lesovsky/Git/sandbox/ameba”，“ameba”，amebaUprobe，-1）
如果错误！=零{
fmt.Fprintf（os.Stderr，“未能附加输入参数：%s\n”，错误）
操作系统退出（1）
}
表：=bpf.NewTable（m.TableId（“ameba_事件”），m）
通道：=make（通道[]字节）
perfMap，err:=bpf.InitPerfMap（表，通道）
如果错误！=零{
fmt.Fprintf（os.Stderr，“初始化性能映射失败：%s\n”，错误）
操作系统退出（1）
}
信号：=接通（切换操作信号，1）
信号通知（信号、操作系统中断、操作系统终止）
fmt.Printf（“%10s\t%s\t%s\n”、“PID”、“命令”、“ARG1”）
go func（）{
变量事件
为了{
数据：=
我读过关于BPF_MAP_TYPE_PERCPU_数组在这种情况下可能会有所帮助的文章，但我不清楚如何使用它

你说得对。PEEP通常依靠每cpu阵列来克服堆栈大小限制。下面实现了这种解决方案，我使用每cpu阵列来存储
struct ameba\u event\t
，而不是将其存储在堆栈上

我认为您需要Linux v4.18才能做到这一点（您需要提交）。我还没有测试代码，因为我手头没有正确的设置，但如果您遇到任何问题，可以稍后测试

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

#包括
#包括
结构ameba\u事件\u t{
u32-pid；
字符通信[任务通信]；
chararg1[512]；
}_uuu属性_uuu（（压缩））；
BPF_性能输出（ameba_事件）；
BPF_perpu_数组（ameba_struct，struct ameba_event_t，1）；
int get_input_args（结构pt_regs*ctx）{
int零=0；
如果（！PT_REGS_PARM1（ctx））
返回0；
struct ameba_event_t*event=ameba_struct.lookup（&zero）；
如果（！事件）
返回0；
事件->pid=bpf\U get\U current\U pid\U tgid（）；
bpf_获取_当前_通信（&event->comm，sizeof（event->comm））；
bpf_探测_读取（&event->arg1，sizeof（event->arg1），（void*）PT_REGS_PARM1（ctx））；
ameba_events.perf_submit（ctx、event、sizeof（*event））；
返回0；
}
文本字符串不会传递或存储在堆栈上。传递给
ameba
函数的是指向长字符串的第一个字符的指针。然后它返回指向堆上分配的第一个数据元素的指针。堆栈上存储的唯一内容（传统上）是指针变量本身，而不是它们指向的数据。不过您有内存泄漏。
s=（char*）malloc（128）；
只需分配更多内存…
s=malloc（strlen（s1）+1）
也许我解释错了，一般来说，我试图将指针保存到BPF程序中的ameba_event_t struct中，并在go程序中取消对它的引用。目前，它是通过限制为80字节的Arg1变量完成的。（内存泄漏和过度分配不是我现在担心的事情）我启动到4.18内核并实现了您的解决方案，但长arg仍然被截断为arg1限制为80字节。我想我需要一种方法来将arg1[80]替换为没有此类限制的内容。但我检查了很多“bcc”工具和所有地方都使用固定长度的变量。无论如何，不可能猜测跟踪函数将传递的字符串长度。所以设置适当的限制并丢弃过长的字符串是合理的。谢谢。没错，您必须为
struct ameba\u event\t
设置固定长度。您可以将
arg1
设置为但大小非常大。不确定使用非常大的
arg1
对性能的影响。正常大小是多少？8Kb可以吗？这不是我可以回答的问题。如果您知道要捕获的大多数字符串都小于8Kb，并且您已经检查过它所产生的任何开销对您来说都是可以接受的，那么请确定！
#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;
}