使用C和Golang构建XDP EBPF程序：逐步指南
#go #clang #xdp #ebpf

介绍

在当今高度连接和数据驱动的世界中，网络性能对于确保有效的沟通和最佳的用户体验至关重要。 XDP（Express Data Path）和EBPF（扩展的Berkeley数据包过滤器）已成为强大的技术，可实现高性能数据包处理和网络优化。在本分步指南中，我们将探讨使用C和Golang构建XDP EBPF程序的过程。 XDP允许在网络接口驱动程序级别上进行早期数据包拦截，而EBPF为自定义数据包处理逻辑提供了灵活，有效的执行环境。他们一起在网络应用程序中提供了前所未有的控制和性能水平。我们的项目名为“ Dilih”（像热一样丢弃），演示了如何构建一个简单的混乱工程工具，该工具任意将数据包放在给定的网络接口上，这可以使应用程序开发人员了解其产品的表现如何当网络不是时。通过本指南，您将获得对XDP，EBPF及其在网络操作中的实际应用的基本了解。

注意：您可以在此处找到本文的整个代码库：https://github.com/peter-mcconnell/dilih

项目概况

该项目旨在使用C和Golang构建XDP（Express Data Path）EBPF（扩展的Berkeley数据包滤波器）程序。名为“ dilih”（像热一样丢弃，因为它掉落了...它们很热吗？该项目展示了XDP和EBPF在高速控制数据包处理方面的功能和灵活性，使其成为理解这些技术的理想起点。

在C中实现的XDP EBPF程序在早期阶段将钩子钩到Linux内核的网络堆栈中，以拦截数据包并决定其命运。使用简单的随机机制，程序有选择地删除数据包，允许网络流量中的控制混乱。此外，该程序还利用EBPF的PERT事件机制来收集统计数据并测量掉落和通过数据包的处理时间。

随附的Golang应用程序与XDP EBPF程序进行交互，提供了一个用户友好的接口来监视数据包下降行为并可视化性能统计信息。它利用EBPF地图从内核空间提取和汇总了收集的数据，从而使用户可以深入了解掉落数据包的影响和数据包处理的效率。

建立开发环境

要开始使用C和Golang构建XDP EBPF程序，您需要设置开发环境。按照以下步骤确保您拥有所有必要的工具和依赖项：

  1. 安装开发工具

    首先，确保您在系统上安装了所需的开发工具。这包括Clang，LLVM和BPFTool等软件包。您可以使用Linux发行版中的软件包管理器安装这些工具，但是我建议您投入一些时间从源头构建这些工具，因为它可以使您更加控制这些工具中内置的标志和功能。

    如果您对我的 extcent llvm/clang设置感到好奇，我会使用以下可安置任务进行配置：

    https://github.com/peter-mcconnell/.dotfiles/blob/master/tasks/llvm.yaml
    https://github.com/peter-mcconnell/.dotfiles/blob/master/tasks/debugtools.yaml
    https://github.com/peter-mcconnell/.dotfiles/blob/master/tasks/docker.yaml

  2. 安装Golang

    接下来，您需要安装Golang，这是用于随附的Golang应用程序的编程语言。访问Golang官方网站的https://golang.org，并遵循特定于操作系统的安装说明。安装后，通过将适当的二进制目录添加到系统路径中，请确保从命令行访问GO命令。

    如果您对我的 extcent golang设置感到好奇，我使用以下可安装任务进行配置：

    https://github.com/peter-mcconnell/.dotfiles/blob/master/tasks/golang.yaml

  3. 安装项目依赖项

    PP神的上帝？

    导航到项目的根目录，并通过运行以下命令来安装所需的golang依赖项：

    go mod download

    此命令将获取并安装项目go.mod文件中定义的必要的Golang软件包。

    libbpf

    我们将在我们的C代码中使用libbpf。在DILIH存储库中，我们将其添加为Git subsodule，但是如果愿意，您可以选择在其他地方进行管理。稍后我们构建C程序时，我们将与-I../libbpf/src

    一起包含libbpf

  4. （可选）IDE配置

    无论您选择的编辑应该是什么，都要投入一些时间来确保为C和Golang设置它。特别是对于自动完成，伸长，符号检测等。这将使您的生活更加轻松。

    如果您对我的 Exact 设置感到好奇，我会使用以下存储库来安装NeoVim，配置我的LSP和设置我需要开发的其他所有内容：

    https://github.com/peter-mcconnell/.dotfiles/

在C中编写XDP EBPF程序

在C中使用LIBBPF的一些帮助，使用C中的EBPF（EBPF（扩展伯克利数据包过滤器）框架实现了XDP（Express Data Path）程序。它使我们能够在Linux内核网络堆栈的早期阶段拦截数据包，并执行自定义数据包处理逻辑。在本节中，我们将浏览c。

中编写XDP EBPF程序的步骤

  1. 了解程序逻辑

    潜入代码之前，让我们了解XDP程序的逻辑。目标是在给定的网络接口上随机删除约50％的数据包。我们将使用随机机制来决定是掉落还是传递每个数据包（“甚至是随机数？”）。该程序还将收集统计数据，并使用EBPF的PERT事件机制来衡量掉落和传递数据包的处理时间。我们的BPF程序在内核空间中运行，但我们希望将数据暴露到用户空间，因此我们将使用BPF地图将数据暴露到我们的GO程序中。

  2. 创建程序源文件

    首先在项目中的a ./bpf/目录中创建一个名为dilih_kern.c的新文件。该文件将包含我们的XDP EBPF程序逻辑。打开您喜欢的文本编辑器中的文件。

  3. 定义所需的标题和结构

    要开始，包括必要的标题并为我们的XDP程序定义所需的结构。我们需要bpf.h和bpf_helpers.h，它提供有用的结构和辅助功能。

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

  4. 定义数据结构和地图

    接下来，定义我们XDP程序将使用的必要数据结构和地图。我们将使用struct表示Perf事件数据，而BPF_MAP_TYPE_PERF_EVENT_ARRAY MAP来存储PERF Events。定义以下结构和地图：

    struct perf_trace_event {
    __u64 timestamp;
    __u32 processing_time_ns;
    __u8 type;
};

#define TYPE_ENTER 1
#define TYPE_DROP 2
#define TYPE_PASS 3

struct {
    __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
    __uint(key_size, sizeof(int));
    __uint(value_size, sizeof(struct perf_trace_event));
    __uint(max_entries, 1024);
} output_map SEC(".maps");

    output_map映射将用于存储我们XDP程序生成的PERT事件。 type_*定义将使我们的代码稍后更可读。

  5. 实现XDP程序函数

    现在是时候实现XDP程序函数本身了。首先用适当的签名声明XDP函数：

    SEC("xdp")
int xdp_dilih(struct xdp_md *ctx)
{
    // Add program logic here ... detailed in the next step
}

    XDP_DILIH功能将用作我们的XDP EBPF程序入口点。它将用于每个传入的数据包。

  6. 处理完美事件并收集数据

    在XDP_DILIH功能中，我们可以处理PERF事件以收集数据并测量处理时间。我们已经定义了output_map来存储这些事件。使用bpf_perf_event_output助手功能将perf Evertive发射到地图上。

    struct perf_trace_event e = {};

// Perf event for entering xdp program
e.timestamp = bpf_ktime_get_ns();
e.type = TYPE_ENTER;
e.processing_time_ns = 0;
bpf_perf_event_output(ctx, &output_map, BPF_F_CURRENT_CPU, &e, sizeof(e));

// Packet dropping logic
if (bpf_get_prandom_u32() % 2 == 0) {
    // Perf event for dropping packet
    e.type = TYPE_DROP;
    __u64 ts = bpf_ktime_get_ns();
    e.processing_time_ns = ts - e.timestamp;
    e.timestamp = ts;
    bpf_perf_event_output(ctx, &output_map, BPF_F_CURRENT_CPU, &e, sizeof(e));
    return XDP_DROP;
}

// Perf event for passing packet
e.type = TYPE_PASS;
__u64 ts = bpf_ktime_get_ns();
e.processing_time_ns = ts - e.timestamp;
e.timestamp = ts;
bpf_perf_event_output(ctx, &output_map, BPF_F_CURRENT_CPU, &e, sizeof(e));

return XDP_PASS;

    在代码的这一部分中，我们处理完善事件以收集数据并测量删除和传递数据包的处理时间。输入XDP程序（类型1）时，我们首先发出完善事件。然后，我们使用随机机制来决定是掉落还是传递数据包。如果删除数据包，我们将发出一个带有2型的PERF事件，并返回XDP_Drop。如果数据包通过了，我们会发出一个带有3型的完美事件，并返回XDP_Pass。

    bpf_ktime_get_ns（）函数用于测量时间戳（自系统启动以来的纳秒，不包括暂停时间）和数据包的处理时间。 BPF_GET_PRANDOM_U32（）函数生成一个随机值，有助于确定掉落还是传递数据包 - “这个随机数是否是吗？”部分。

    此外，我们使用bpf_printk（）来打印可以通过内核跟踪缓冲区访问的调试消息。

得出结论在C中实施XDP EBPF程序的实施。该程序将根据随机机制选择性删除数据包，并发出用于收集数据和测量处理时间的PERF事件。

编译和加载XDP EBPF程序

我们在C中编写了XDP EBPF程序后，下一步就是将其编译并加载到内核中。在本节中，我们将浏览汇编和加载XDP EBPF程序的步骤。

编译XDP程序

要编译XDP程序，我们将使用具有适当标志的LLVM Clang编译器。打开一个终端并导航到dilih_kern.c文件所在的BPF目录。然后，运行以下命令：

clang -S \
    -g \
    -target bpf \
    -I../libbpf/src\
    -Wall \
    -Werror \
    -O2 -emit-llvm -c -o dilih_kern.ll dilih_kern.c

让我解释一下标志：

  • -S发出了中间表示（IR）汇编代码文件，而不是生成对象代码。此步骤用于生成LLVM IR代码。
  • -g包括BTF信息
  • -target bpf将目标体系结构指定为“ BPF”（伯克利数据包滤波器），表明要编译的代码旨在在EBPF上运行。
  • -I../libbpf/src将路径../libbpf/src添加到包含搜索路径。这允许编译器从libbpf库中查找必要的标头文件（BPF助手文件）。`Wall启用所有编译器警告消息。
  • -Werror将所有警告视为错误，如果遇到任何警告，会导致汇编过程失败。
  • -O2将优化级别2应用于生成的代码。这种优化的水平着重于提高性能而不牺牲代码大小。这实际上是某些BPF用途的要求，尽管我现在正在努力回忆起它们是什么。 todo
  • -emit-llvm指示编译器将LLVM IR代码作为输出。
  • -c编译输入源文件而不链接，生成对象文件。
  • -o dilih_kern.ll：指定生成的llvm ir代码的输出文件名为dilih_kern.ll。

现在，我们使用LLC命令用于进一步处理LLVM IR代码并生成最终对象文件：

llc -march=bpf -filetype=obj -O2 -o dilih_kern.o dilih_kern.ll

让我解释一下标志：

  • -march=bpf将目标体系结构指定为代码生成阶段的“ BPF”。
  • -filetype=obj将所需的输出文件类型指定为对象文件。
  • -O2在代码生成阶段将优化级别2应用于生成的代码。
  • -o指定生成对象代码的输出文件名为dilih_kern.o。

此命令将dilih_kern.c文件编译到名为dilih_kern.o的BPF对象文件中。 -target BPF标志将目标体系结构指定为BPF，-O2标志启用了优化。

加载XDP程序

要将XDP程序加载到内核中，我们将使用bpftool命令行实用程序。确保系统上安装了BPFTool实用程序。如果尚未安装，您通常可以使用Distraction的软件包管理器安装它。

在终端中，运行以下命令加载XDP程序：

sudo bpftool prog load dilih\_kern.o /sys/fs/bpf/dilih

此命令将dilih_kern.o对象文件加载，然后将其固定到/sys/fs/bpf/dilih位置。根据您的系统配置，根据需要调整路径。 BPFTool实用程序将处理加载过程并验证程序的有效性。

附加XDP程序

加载XDP程序后，我们需要将其连接到网络接口上以开始拦截数据包。要连接XDP程序，请运行以下命令：

sudo bpftool net attach xdp pinned /sys/fs/bpf/dilih dev <interface>

您可以通过运行“ IP链接”来获得

替换为要将XDP程序的网络接口的名称替换。例如，eth0。此命令将XDP程序连接到指定的接口，使其能够拦截传入的数据包。

makefile

为方便起见，让我们将一些我们上面学到的东西扔进./bpf/Makefile的Makefile。我不会深入了解本文中的makefiles的工作方式，而是总结了代码段之后的功能：
``

TARGET = dilih
BPF_TARGET = ${TARGET:=_kern}
BPF_C = ${BPF_TARGET:=.c}
BPF_OBJ = ${BPF_C:.c=.o}

BPF_PINNED_PATH := /sys/fs/bpf/$(TARGET)
XDP_NAME := dilih
DEV := ens160

xdp: $(BPF_OBJ)
        -bpftool net detach xdpgeneric dev $(DEV)
        rm -f $(BPF_PINNED_PATH)
        bpftool prog load $(BPF_OBJ) $(BPF_PINNED_PATH)
        bpftool net attach xdpgeneric pinned $(BPF_PINNED_PATH) dev $(DEV)

$(BPF_OBJ): %.o: %.c
        clang -S \
                -g \
                -target bpf \
          -I../libbpf/src\
                -Wall \
                -Werror \
                -O2 -emit-llvm -c -o ${@:.o=.ll} $<
        llc -march=bpf -filetype=obj -O2 -o $@ ${@:.o=.ll}

clean:
        -bpftool net detach xdpgeneric dev $(DEV)
        sudo rm -f $(BPF_PINNED_PATH)
        rm -f $(BPF_OBJ)
        rm -f ${BPF_OBJ:.o=.ll}

使用此文件并安装了make，您可以运行像DEV=eth0 make之类的内容来编译和加载EBPF程序和DEV=eth0 make clean以删除文件并卸载EBPF程序。

恭喜！您已成功地编译并将XDP EBPF程序加载到内核中，并将其连接到网络接口。该程序现在准备根据您定义的逻辑拦截和处理数据包。

请注意，汇编和加载过程可能会根据您的系统配置和特定要求而略有不同。确保相应地调整命令并参考所使用的​​工具和实用程序的文档。

编写Golang应用程序

在本节中，我们将编写一个与XDP EBPF程序交互并收集指标的Golang应用程序。 Golang应用程序将与已加载的XDP程序进行通信，读取PERT事件，并根据收集的数据显示统计信息。

编写Golang应用程序代码

让我们创建一个名为main.go的新文件，然后在文本编辑器中打开它。该文件将包含我们Golang应用程序的代码。复制并将以下代码粘贴到主。GO：

package main

import (
        "encoding/binary"
        "fmt"
        "net"
        "os"
        "os/signal"
        "syscall"

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

const (
        TYPE_ENTER = 1
        TYPE_DROP  = 2
        TYPE_PASS  = 3
)

type event struct {
        TimeSinceBoot  uint64
        ProcessingTime uint32
        Type           uint8
}

const ringBufferSize = 128 // size of ring buffer used to calculate average processing times
type ringBuffer struct {
        data   [ringBufferSize]uint32
        start  int
        pointer int
        filled bool
}

func (rb *ringBuffer) add(val uint32) {
        if rb.pointer < ringBufferSize {
                rb.pointer++
        } else {
                rb.filled = true
                rb.pointer= 1
        }
        rb.data[rb.pointer-1] = val
}

func (rb *ringBuffer) avg() float32 {
        if rb.pointer == 0 {
                return 0
        }
        sum := uint32(0)
        for _, val := range rb.data {
                sum += uint32(val)
        }
        if rb.filled {
                return float32(sum) / float32(ringBufferSize)
        }
        return float32(sum) / float32(rb.pointer)
}

func main() {
        spec, err := ebpf.LoadCollectionSpec("bpf/dilih_kern.o")
        if err != nil {
                panic(err)
        }

        coll, err := ebpf.NewCollection(spec)
        if err != nil {
                panic(fmt.Sprintf("Failed to create new collection: %v\n", err))
        }
        defer coll.Close()

        prog := coll.Programs["xdp_dilih"]
        if prog == nil {
                panic("No program named 'xdp_dilih' found in collection")
        }

        iface := os.Getenv("INTERFACE")
        if iface == "" {
                panic("No interface specified. Please set the INTERFACE environment variable to the name of the interface to be use")
        }
        iface_idx, err := net.InterfaceByName(iface)
        if err != nil {
                panic(fmt.Sprintf("Failed to get interface %s: %v\n", iface, err))
        }
        opts := link.XDPOptions{
                Program:   prog,
                Interface: iface_idx.Index,
                // Flags is one of XDPAttachFlags (optional).
        }
        lnk, err := link.AttachXDP(opts)
        if err != nil {
                panic(err)
        }
        defer lnk.Close()

        fmt.Println("Successfully loaded and attached BPF program.")

        // handle perf events
        outputMap, ok := coll.Maps["output_map"]
        if !ok {
                panic("No map named 'output_map' found in collection")
        }
        perfEvent, err := perf.NewReader(outputMap, 4096)
        if err != nil {
                panic(fmt.Sprintf("Failed to create perf event reader: %v\n", err))
        }
        defer perfEvent.Close()
        buckets := map[uint8]uint32{
                TYPE_ENTER: 0, // bpf program entered
                TYPE_DROP: 0, // bpf program dropped
                TYPE_PASS: 0, // bpf program passed
        }

        processingTimePassed := &ringBuffer{}
        processingTimeDropped := &ringBuffer{}

        go func() {
                // var event event
                for {
                        record, err := perfEvent.Read()
                        if err != nil {
                                fmt.Println(err)
                                continue
                        }

                        var e event
                        if len(record.RawSample) < 12 {
                                fmt.Println("Invalid sample size")
                                continue
                        }
                        // time since boot in the first 8 bytes
                        e.TimeSinceBoot = binary.LittleEndian.Uint64(record.RawSample[:8])
                        // processing time in the next 4 bytes
                        e.ProcessingTime = binary.LittleEndian.Uint32(record.RawSample[8:12])
                        // type in the last byte
                        e.Type = uint8(record.RawSample[12])
                        buckets[e.Type]++

                        if e.Type == TYPE_ENTER {
                                continue
                        }
                        if e.Type == TYPE_DROP {
                                processingTimeDropped.add(e.ProcessingTime)
                        } else if e.Type == TYPE_PASS {
                                processingTimePassed.add(e.ProcessingTime)
                        }

                        fmt.Print("\033[H\033[2J")
                        fmt.Printf("total: %d. passed: %d. dropped: %d. passed processing time avg (ns): %f. dropped processing time avg (ns): %f\n", buckets[TYPE_ENTER], buckets[TYPE_PASS], buckets[TYPE_DROP], processingTimePassed.avg(), processingTimeDropped.avg())
                }
        }()

        c := make(chan os.Signal, 1)
        signal.Notify(c, os.Interrupt, syscall.SIGTERM)
        <-c
}

如果您还没有这样做，则可能需要运行go mod init && go mod tidy。

代码为Golang应用程序设置了必要的组件。它加载BPF程序，将其连接到指定的网络接口，并初始化PERF Event Reader。但是，读取和处理PERF事件的代码尚未实现。

总结了“编写Golang应用程序”部分的内容。随时根据您的需要修改和自定义内容。

构建和运行该项目

现在我们已经在C和Golang应用程序中实现了XDP EBPF程序，让我们构建并运行该项目。

构建XDP EBPF程序

，如果您已经从上面的步骤编制了dilih_kern.o，则可以跳过此步骤。

在构建XDP EBPF程序之前，请确保您在系统上安装了必要的构建工具和依赖项。您可以根据特定要求参考项目的读数或文档。

要构建XDP EBPF程序，请导航到BPF目录并运行以下命令：

make

此命令将编译C代码并生成dilih_kern.o对象文件。

构建Golang应用程序

要构建Golang应用程序，请确保您位于项目的根目录中。运行以下命令：

CGO_ENABLED=0 go build

此命令将编译Golang代码并生成可执行的二进制文件。注意：我们的应用不需要CGO。如果愿意，我们可以启用它，但是我喜欢在可以使用cgo_enabled = 0的情况下使用静态编译的二进制文件，我可以轻松地加载到容器中。

运行GO项目 

sudo ./dilih

您应该开始查看给定接口上处理的数据包的摘要：

sample output

确保使用高架特权（sudo）运行该应用程序以访问必要的资源。

Golang应用程序将开始从XDP程序中收集数据，并根据收到的Perf Events显示统计信息。

清理
要清理项目并从网络接口中删除XDP程序，请运行以下命令：

sudo make clean

此命令将从网络接口分离XDP程序并删除任何关联的工件。

就是这样！您已经成功构建并运行了该项目。实验不同的网络接口，并观察Golang应用程序显示的数据包下降统计信息。

随时探索其他功能和修改以进一步增强项目。

测试和验证XDP EBPF程序

测试和验证XDP EBPF程序的功能是确保其正确性和有效性的重要步骤。在本节中，我们将介绍XDP程序的一些测试技术和验证方法。

测试环境设置

为了创建合适的测试环境，我们将使用虚拟网络接口（VETH设备）模拟网络流量并观察XDP程序的行为。

如果系统尚未安装在系统上，请安装IPROUTE2软件包。该软件包提供了管理网络接口的必要工具。

使用以下命令创建一对VETH设备：

sudo ip link add veth0 type veth peer name veth1

此命令将创建两个相互连接的虚拟网络接口（veth0和veth1）。

设置接口并将IP地址分配给它们：

sudo ip link set veth0 up
sudo ip link set veth1 up
sudo ip addr add 10.0.0.1/24 dev veth0
sudo ip addr add 10.0.0.2/24 dev veth1

这将提出界面并将IP地址（10.0.0.1和10.0.0.2）分配给它们。

使用VETH设备设置，我们可以继续测试和验证XDP EBPF程序的功能。

数据包下降验证

XDP程序的主要功能之一是放弃一定比例的数据包。我们可以通过在VETH设备之间发送数据包并观察数据包下降率来验证此行为。

打开两个终端窗口并导航到两个端子目录。

在第一个终端中，运行以下命令以侦听ICMP回波请求（ping）：

sudo tcpdump -i veth1 icmp

在第二端子中，使用以下命令将ICMP回声请求（ping）从veth0发送到veth1：

sudo ip netns exec veth0 ping 10.0.0.2

观察第一个端子中的输出。您应该看到捕获的ICMP回声请求。

分析数据包捕获以验证数据包下降速率。如果XDP程序正常工作，则应删除ICMP回波请求的50％，从而减少捕获的数据包。

通过执行数据包删除验证测试，您可以确保XDP程序按预期运行，并根据指定百分比删除数据包。

绩效分析

除了功能验证外，要分析XDP EBPF计划的性能影响至关重要。该分析有助于评估程序引入的效率和间接费用。

  1. 使用提供的Golang应用程序从XDP程序中收集性能指标和统计信息。有关如何运行Golang应用程序的说明，请参阅“构建和运行项目”部分。

  2. 监视并观察通过和丢弃数据包的平均处理时间。 Golang应用程序显示每种数据包类型的纳秒（NS）中的平均处理时间。

    如果平均处理时间持续较低，则表明XDP程序正在有效执行并导致最小的处理开销。

    如果平均处理时间明显很高，则可能表明XDP程序正在引入相当大的处理开销，这可能需要优化或进一步研究。

  3. 收集数据并分析网络流量的长时间的性能指标，以确定任何模式或趋势。在处理时间内寻找可能表明潜在瓶颈或效率低下的异常或偏差。

  4. 实验不同的数据包下降百分比，并观察它们对平均处理时间的影响。通过改变下降速率，您可以评估数据包丢失和处理效率之间的权衡。

  5. 执行性能分析使您可以深入了解XDP EBPF计划对网络性能的影响，并就其优化和调整做出明智的决定。

集成和系统测试
为了确保将XDP EBPF程序正确集成到整个系统中，进行集成和系统测试至关重要。这涉及测试XDP程序，网络堆栈和系统其他组件之间的相互作用。

构建一个与XDP程序将在其中运行的生产环境相似的测试方案。考虑网络流量模式，系统负载和其他网络组件的存在等因素。

使用数据包生成器，流量模拟器或实际生产流量等工具生成现实的网络流量。

监视系统的行为，包括数据包处理，性能指标和系统资源利用率。确保XDP程序按预期运行，并且不会对系统引入任何不利影响。

测试角案例和边缘条件，以验证XDP程序的鲁棒性和弹性。这包括诸如高网络流量量，不寻常的数据包结构或意外的网络事件等方案。

通过进行集成和系统测试，您可以确保XDP EBPF程序无缝集成到更广泛的系统中，并在各种条件下可靠地运行。

结论

在本文中，我们探讨了使用C和Golang构建XDP EBPF程序的过程。我们首先了解XDP和EBPF的基础知识，然后在C中设置开发环境并编写XDP EBPF程序。然后，我们将该程序与Golang应用程序集成在一起，以收集和分析性能指标。

。

。

在整个旅程中，我们学习了如何编译和加载XDP程序，构建Golang应用程序，并利用EBPF和XDP的功能来操纵网络数据包并引入受控的混乱。我们还讨论了测试方法，以确保XDP程序在系统中的正确性，效率和集成。

利用EBPF和XDP的能力为网络可编程性，性能优化和安全性增强的可能性开辟了一个世界。通过利用EBPF的灵活性和可编程性，开发人员可以创建强大而有效的网络应用程序。

我们鼓励您使用XDP和EBPF探索进一步的可能性，尝试不同的方案，并更深入地深入了解EBPF工具和库的丰富生态系统。拥抱XDP和EBPF的功能，以在网络编程和性能优化中解锁新的视野。

快乐编码！

其他资源

为了进一步扩展您的知识并探索XDP，EBPF和网络编程的世界，这里有一些宝贵的资源：

  • Cilium Project：Cilium是一个开源项目，可提供由EBPF提供支持的网络和安全功能。他们的文档和代码库提供了对EBPF及其应用程序的深入见解。有关更多信息，请访问他们的网站Cilium.io。

  • IOVISOR项目：Iovisor是一个开源项目，重点介绍基于EBPF的跟踪，监视和网络的构建工具，库和基础架构。他们在iovisor.org上的网站拥有大量资源，包括教程，文档和示例代码。

  • BCC（BPF编译器集合）：BCC是功能强大的命令行工具和库的集合，可利用EBPF用于各种跟踪和性能分析任务。 github.com/iovisor/bcc的官方GitHub存储库提供了广泛的文档和示例，以帮助您深入EBPF。

  • ebpf.io：EBPF.IO是一个由社区驱动的网站，致力于提供有关EBPF的资源，教程和新闻。它具有文章，案例研究以及与EBPF相关的工具和库的精选清单。在EBPF.IO上浏览该网站，以了解EBPF生态系统中最新发展的最新信息。

  • Linux内核文档：Linux内核文档包括有关EBPF和XDP的全面部分，涵盖了各个方面，包括API参考，使用示例和实现详细信息。访问www.kernel.org/doc/html/latest/bpf的文档，以深入了解基本机制。

这些资源是有价值的参考，并为进一步的学习和探索提供了机会。深入研究XDP，EBPF和网络编程的世界，并在您的网络项目中解锁这些技术的全部潜力。

您还可以在此处找到本文的整个代码库：https://github.com/peter-mcconnell/dilih