通过 bpf 系统调用加载 eBPF 程序时参数列表太长

Question

我正在尝试通过 Go 中的 bpf 系统调用加载 eBPF 程序，但我看到系统调用返回了一个错误。为了限制问题，我使用了以下最小的 eBPF 程序，它什么都不做：

struct task_group {};

围棋程序的重要部分如下：

b, err := ioutil.ReadFile("bpf/bbf_tty.o")
if err != nil {
    fmt.Print(err)
}

progType := BPF_PROG_TYPE_KPROBE
insns := unsafe.Pointer(&b)
insnCnt := len(b)

lba := struct {
    progType    uint32
    pad0        [4]byte
    insnCnt     uint32
    pad1        [4]byte
    insns       uint64
    license     uint64
    logLevel    uint32
    pad2        [4]byte
    logSize     uint32
    pad3        [4]byte
    logBuf      uint64
    kernVersion uint32
    pad4        [4]byte
}{
    progType:    uint32(progType),
    insns:       uint64(uintptr(insns)),
    insnCnt:     uint32(insnCnt),
    license:     uint64(uintptr(0)),
    logBuf:      uint64(uintptr(0)),
    logSize:     uint32(0),
    logLevel:    uint32(0),
    kernVersion: uint32(4),
}

ret, _, err := unix.Syscall(
    unix.SYS_BPF,
    bpf.BPF_PROG_LOAD,
    uintptr(unsafe.Pointer(&lba)),
    unsafe.Sizeof(lba),
)

if ret != 0 || err != 0 {
    return fmt.Errorf("Unable to load program: %s", err)
}

但是返回的错误是 Unable to load program: argument list too long。为什么是这样？或者更好的是，如何获得更详细的输出以找出问题的根本原因？

从 here 开始，只有三个地方 E2BIG（参数列表太长）从 bpf 系统调用返回，但其中 none 似乎适合.

如果需要，我可以提供更完整的代码版本，为了简洁起见，我只是试图删除不相关的部分。

为了帮助重现这个问题，我在下面包含了完整的 BPF 程序。完整的回购是 here:

#include <node_config.h>
#include <netdev_config.h>
#include <filter_config.h>

#include <bpf/api.h>

#include <stdint.h>
#include <stdio.h>

#include <linux/bpf.h>
#include <linux/if_ether.h>

#include "lib/utils.h"
#include "lib/common.h"
#include "lib/maps.h"
#include "lib/xdp.h"
#include "lib/eps.h"
#include "lib/events.h"

// define structures
enum pid_type
{
    PIDTYPE_PID,
    PIDTYPE_PGID,
    PIDTYPE_SID,
    PIDTYPE_MAX,
    // only valid to __task_pid_nr_ns() 
    __PIDTYPE_TGID
};
struct upid {
  int nr;
};
struct pid
{
  struct upid numbers[1];
};
struct pid_link
{
  struct pid *pid;
};
struct task_group {
};
struct task_struct {
  struct task_struct *group_leader;
  struct pid_link           pids[PIDTYPE_MAX];
};
struct sid_t {
    int sid;
};

#define BUFSIZE 256
struct tty_write_t {
    int count;
    char buf[BUFSIZE];
    unsigned int sessionid;
};

// define maps
struct bpf_elf_map __section_maps active_sids = {
    .type       = BPF_MAP_TYPE_HASH,
    .size_key   = sizeof(struct sid_t),
    .size_value = sizeof(uint64_t),
};

struct bpf_elf_map __section_maps tty_writes = {
    .type       = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
};

// save_sid saves a sessionid generated from a call
// to setsid to the active_sids map
int save_sid(struct pt_regs *ctx) {

    struct sid_t sid_struct = {};
    int sid = PT_REGS_RC(ctx);
    uint64_t time_ns = bpf_ktime_get_ns();

    sid_struct.sid = sid;

    bpf_map_update(&sid_struct, &time_ns);

    return 0;

}

//int kprobe__tty_write(struct pt_regs *ctx, struct file *file, const char __user *buf, size_t count)
int kprobe__tty_write(struct pt_regs *ctx, struct file *file, const char *buf, size_t count)
{
    struct task_struct *task;
    struct pid_link pid_link;
    struct pid pid;
    int sessionid;

    // get current sessionid
    task = (struct task_struct *)bpf_get_current_task();
    bpf_probe_read(&pid_link, sizeof(pid_link), (void *)&task->group_leader->pids[PIDTYPE_SID]);
    bpf_probe_read(&pid, sizeof(pid), (void *)pid_link.pid);
    sessionid = pid.numbers[0].nr;

    // build session struct key
    struct sid_t sid_key;
    sid_key.sid = sessionid;

    // if sid does not exist in our map then return
    //u64 *time_ns = active_sids.lookup(&sid_key);
    //if (!time_ns) {
    //    return 0;
    //}

    // bpf_probe_read() can only use a fixed size, so truncate to count
    // in user space:
    struct tty_write_t tty_write = {};
    bpf_probe_read(&tty_write.buf, BUFSIZE, (void *)buf);
    if (count > BUFSIZE) {
        tty_write.count = BUFSIZE;
    } else {
        tty_write.count = count;
    }

    // add sessionid to tty_write structure and submit
    tty_write.sessionid = sessionid;
    bpf_perf_event_output(ctx, &tty_write, sizeof(tty_write));

    return 0;
}

Answer 1

See @Qeole's answer for the actual cause of this error message.

您需要一个非空的 BPF 程序。否则，您将无法满足 bpf_prog_load 中的以下先决条件：

if (attr->insn_cnt == 0 || attr->insn_cnt > BPF_MAXINSNS)
    return -E2BIG;

您当前编译的 BPF 程序似乎是空的，因为它不包含任何函数。因此，attr->insn_cnt 为空。

详情我检查过 attr->insn_cnt 实际上是空的：

$ cat tmp.c 
struct task_group {};
$ clang -O2 -target bpf -c tmp.c -o tmp.o
$ ls -lh tmp.o 
-rw-rw-r-- 1 paul paul 368 févr.  7 11:21 tmp.o
$ readelf -x .text tmp.o

Section '.text' has no data to dump.

目标文件不是空的，但它的 .text 部分应该包含 BPF 指令。如果我运行 readelf -x .text tmp.o 在我自己的一个程序上，我会得到一个 hexdump，正如预期的那样。

Answer 2

这里的问题是您尝试加载 BPF 字节码的方式。

b, err := ioutil.ReadFile("bpf/bbf_tty.o")

我从未使用过 Go，但据我了解，它会从 ELF object 文件中读取所有字节，无需任何特定处理，然后将它们提供给 bpf() 系统调用代码。

问题是，事情不是这样的：当它编译成 eBPF 时，clang 将您的程序放入 one 特定部分（默认情况下，.text，但您可以指定另一个名称）。此外，如果你使用 eBPF 映射，一些魔法会发生（“映射重定位”），这样你的 ELF 文件可以嵌入映射信息，你的用户空间程序调用 bpf() 可以检索它并将它发送到内核。

因此，当您加载整个文件以将其发送到 bpf() 时，您加载了实际的字节码，加上所有 ELF 部分和 header。内核可能不太喜欢它。我不知道如何在 Go 中修复它，但这里有一些可能有用的提示：

libbpf，一个可以从 ELF 文件加载 eBPF 程序的 C 库：位于 in the kernel tree.
Gobpf，一些将 eBPF 程序与 Go 结合使用的框架 (link)。我从未使用过它，但他们肯定会有一些代码从 object 文件加载程序？

通过 bpf 系统调用加载 eBPF 程序时参数列表太长

Argument list too long to when loading an eBPF program via the bpf syscall

c

go

bpf

ebpf