内核开发者实战：如何用 eBPF 调试和优化你的网络协议？

作为一名内核开发者，我们经常需要面对各种复杂的网络协议，确保它们在内核中高效稳定地运行。开发新协议或者优化现有协议时，调试和性能分析是必不可少的环节。传统的调试方法，例如printk，gdb等，可能会对系统性能产生较大影响，而且不够灵活。这时，eBPF (extended Berkeley Packet Filter) 就成为了我们的利器。

什么是 eBPF？

eBPF 最初是作为 BSD 数据包过滤器 (BPF) 的扩展而设计的，用于网络数据包的捕获和过滤。但随着发展，eBPF 已经远远超出了最初的范围，成为一个功能强大的内核态虚拟机，可以在内核中安全地运行用户提供的代码，而无需修改内核源代码或者加载内核模块。这意味着我们可以利用 eBPF 在内核中动态地插入探针，收集各种性能数据，跟踪函数调用，甚至修改内核行为。

eBPF 的优势

• 安全性：eBPF 程序在加载到内核之前，会经过严格的验证器 (verifier) 的检查，确保程序不会导致内核崩溃或者泄露敏感信息。
• 高性能：eBPF 程序运行在内核态，可以高效地访问内核数据结构，而且 eBPF JIT (Just-In-Time) 编译器可以将 eBPF 指令翻译成机器码，进一步提高性能。
• 灵活性：eBPF 程序可以动态地加载和卸载，无需重启系统或者重新编译内核。这使得我们可以快速地迭代和调试代码。
• 可观测性：eBPF 提供了丰富的 tracing 功能，可以跟踪内核函数的调用，收集性能指标，甚至可以观察用户态程序的行为。

eBPF 如何帮助调试网络协议？

现在，让我们来看看 eBPF 如何帮助我们调试和优化网络协议。假设我们正在开发一个名为“Foobar”的新网络协议，我们需要确保它在内核中正确地实现，并且具有良好的性能。

1. 跟踪数据包的传输过程

使用 eBPF，我们可以跟踪数据包在内核中的传输过程，了解数据包经过了哪些函数，以及在每个函数中花费的时间。这对于定位协议实现中的瓶颈非常有帮助。

例如，我们可以使用 kprobes 在协议的关键函数入口和出口处插入探针，记录时间戳。然后，我们可以将这些时间戳发送到用户态程序，进行分析和可视化。

// eBPF C 代码
#include <linux/kconfig.h>
#include <linux/version.h>
#include <linux/bpf.h>
#include <bpf_helpers.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/skbuff.h>
 
SEC("kprobe/foobar_protocol_recv")
int BPF_KPROBE(foobar_recv, struct sk_buff *skb)
{
    u64 ts = bpf_ktime_get_ns();
    // 将时间戳和数据包信息存储到 eBPF map 中
    return 0;
}
 
SEC("kretprobe/foobar_protocol_recv")
int BPF_KRETPROBE(foobar_recv_ret, int ret)
{
    u64 ts = bpf_ktime_get_ns();
    // 将时间戳和返回值存储到 eBPF map 中
    return 0;
}
 
char LICENSE[] SEC("license") = "GPL";

这段代码使用了 kprobes 和 kretprobes，分别在 foobar_protocol_recv 函数的入口和出口处插入了探针。bpf_ktime_get_ns() 函数可以获取当前时间戳，然后我们可以将时间戳和数据包信息存储到 eBPF map 中。eBPF map 是一种内核态的 key-value 存储，可以被用户态程序访问。

2. 分析协议的性能指标

除了跟踪数据包的传输过程，我们还可以使用 eBPF 来分析协议的性能指标，例如：

• 数据包的延迟：通过记录数据包进入和离开协议栈的时间戳，我们可以计算出数据包的延迟。
• 数据包的吞吐量：通过统计单位时间内处理的数据包数量，我们可以计算出协议的吞吐量。
• 数据包的丢包率：通过比较发送和接收的数据包数量，我们可以计算出协议的丢包率。

这些性能指标可以帮助我们了解协议的性能瓶颈，并进行针对性的优化。

例如，我们可以使用 tracepoints 来收集这些性能指标。Tracepoints 是内核中预定义的 hook 点，可以让我们在不修改内核代码的情况下，收集各种性能数据。

// eBPF C 代码
#include <linux/kconfig.h>
#include <linux/version.h>
#include <linux/bpf.h>
#include <bpf_helpers.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/skbuff.h>
 
SEC("tracepoint/net/net_dev_queue")
int BPF_TRACE(net_dev_queue, struct sk_buff *skb)
{
    u32 len = skb->len;
    // 统计数据包的大小
    bpf_map_update_elem(&packet_size_histogram, &len, &one, BPF_ANY);
    return 0;
}
 
char LICENSE[] SEC("license") = "GPL";

这段代码使用了 tracepoint net_dev_queue，该 tracepoint 在数据包被添加到网络设备队列时触发。我们可以在这个 tracepoint 中统计数据包的大小，并将其存储到 eBPF map 中，用于后续的分析。

3. 动态修改协议的行为

更高级的用法是，我们可以使用 eBPF 动态地修改协议的行为。例如，我们可以使用 tc (traffic control) 和 XDP (eXpress Data Path) 来修改数据包的转发策略，或者实现自定义的拥塞控制算法。

tc 允许我们在内核的网络协议栈中插入 eBPF 程序，对数据包进行过滤、修改和重定向。XDP 则允许我们在网络驱动程序中直接处理数据包，绕过内核的网络协议栈，从而实现更高的性能。

例如，我们可以使用 tc 来实现一个简单的防火墙，阻止来自特定 IP 地址的数据包。

// eBPF C 代码
#include <linux/bpf.h>
#include <bpf_helpers.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
 
SEC("filter")
int block_ip(struct __sk_buff *skb)
{
    void *data = (void *)(long)skb->data;
    void *data_end = (void *)(long)skb->data_end;
 
    struct ethhdr *eth = data;
    if (data + sizeof(struct ethhdr) > data_end)
        return BPF_PASS;
 
    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return BPF_PASS;
 
    struct iphdr *iph = data + sizeof(struct ethhdr);
    if (data + sizeof(struct ethhdr) + sizeof(struct iphdr) > data_end)
        return BPF_PASS;
 
    u32 src_ip = iph->saddr;
 
    // 阻止来自 192.168.1.100 的数据包
    if (src_ip == 0x6401a8c0) // 192.168.1.100 的网络字节序表示
        return BPF_DROP;
 
    return BPF_PASS;
}
 
char LICENSE[] SEC("license") = "GPL";

这段代码使用 tc 提供的 filter 功能，对数据包进行过滤。如果数据包的源 IP 地址是 192.168.1.100，则丢弃该数据包。

eBPF 工具链

为了方便开发和调试 eBPF 程序，社区开发了许多有用的工具，例如：

• bcc (BPF Compiler Collection)：bcc 是一个 Python 库，提供了一系列用于编写和调试 eBPF 程序的工具。它包括一个 eBPF 编译器，可以将 C 代码编译成 eBPF 指令，以及一些用于跟踪和分析系统性能的工具。
• bpftrace：bpftrace 是一种高级的 eBPF tracing 语言，类似于 awk。它允许我们使用简单的脚本来跟踪内核和用户态程序的行为。
• cilium：cilium 是一个基于 eBPF 的云原生网络解决方案，提供了高性能的网络策略、负载均衡和服务网格功能。

实际案例：使用 eBPF 优化 TCP 拥塞控制

让我们看一个实际的案例，了解如何使用 eBPF 优化 TCP 拥塞控制。TCP 拥塞控制算法的目标是根据网络拥塞情况，动态地调整发送速率，以避免网络拥塞和丢包。传统的 TCP 拥塞控制算法，例如 CUBIC 和 BBR，都是在内核中实现的，修改和调试非常困难。

使用 eBPF，我们可以轻松地实现自定义的拥塞控制算法，并在不修改内核代码的情况下，对其进行调试和优化。

例如，我们可以使用 eBPF 监控 TCP 连接的 RTT (Round-Trip Time) 和丢包率，并根据这些指标动态地调整拥塞窗口 (congestion window)。

// eBPF C 代码
#include <linux/bpf.h>
#include <bpf_helpers.h>
#include <linux/tcp.h>
 
SEC("kprobe/tcp_ Reno_cong_avoid")
int BPF_KPROBE(tcp_reno_cong_avoid, struct sock *sk, u32 ack, u32 acked_round)
{
    struct tcp_sock *tp = tcp_sk(sk);
    u32 cwnd = tp->snd_cwnd;
    u32 ssthresh = tp->snd_ssthresh;
 
    // 获取 RTT 和丢包率
    u64 rtt = bpf_ktime_get_ns() - tp->srtt_us * 1000;
    u32 loss_cnt = tp->lost_out;
 
    // 根据 RTT 和丢包率调整拥塞窗口
    if (rtt > threshold || loss_cnt > 0)
    {
        tp->snd_cwnd = cwnd / 2;
        tp->snd_ssthresh = cwnd / 2;
    }
    else
    {
        tp->snd_cwnd = cwnd + 1;
    }
 
    return 0;
}
 
char LICENSE[] SEC("license") = "GPL";

这段代码使用 kprobe 在 tcp_reno_cong_avoid 函数中插入探针，该函数是 TCP Reno 拥塞控制算法的核心函数。我们可以在这个函数中获取 TCP 连接的 RTT 和丢包率，并根据这些指标动态地调整拥塞窗口。

eBPF 的局限性

尽管 eBPF 功能强大，但也存在一些局限性：

• 内核版本依赖：eBPF 的功能和 API 会随着内核版本的变化而变化。因此，我们需要根据不同的内核版本编写不同的 eBPF 程序。
• 安全风险：尽管 eBPF 程序会经过验证器的检查，但仍然存在安全风险。如果验证器存在漏洞，恶意用户可能会利用 eBPF 程序攻击内核。
• 学习曲线：eBPF 的学习曲线比较陡峭。我们需要了解内核的内部结构，以及 eBPF 的编程模型。

总结

eBPF 是一种强大的内核调试和优化工具，可以帮助我们更好地理解和改进网络协议的实现。通过跟踪数据包的传输过程，分析协议的性能指标，以及动态修改协议的行为，我们可以发现协议中的瓶颈，并进行针对性的优化。虽然 eBPF 存在一些局限性，但随着 eBPF 技术的不断发展，相信它将在未来的内核开发中发挥越来越重要的作用。希望这篇文章能够帮助你入门 eBPF，并在实际工作中应用 eBPF 技术，解决实际问题。

作为内核开发者，掌握 eBPF 是一项非常有价值的技能。 熟练使用 eBPF 工具，可以极大地提高我们的工作效率，并为我们带来更多的创新机会。 让我们一起探索 eBPF 的无限可能吧！