【Linux 网络子系统深度拆解】网络子系统内存管理：sk_buff 分配、page pool 与 NUMA

// include/linux/skbuff.h
// 1. 基础分配
struct sk_buff *__alloc_skb(unsigned int size, gfp_t priority,
                            int flags, int node);

// 2. 驱动收包分配（中断/softirq 上下文）
struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
                                    unsigned int length,
                                    gfp_t gfp_mask);

// 3. NAPI 轮询分配（最高效）
struct sk_buff *__napi_alloc_skb(struct napi_struct *napi,
                                  unsigned int length,
                                  gfp_t gfp_mask);

// 4. 便利宏
#define netdev_alloc_skb(dev, length) \
    __netdev_alloc_skb(dev, length, GFP_ATOMIC)

#define napi_alloc_skb(napi, length) \
    __napi_alloc_skb(napi, length, GFP_ATOMIC)

// 5. IP 对齐版本（预留 NET_IP_ALIGN 字节 headroom）
static inline struct sk_buff *
netdev_alloc_skb_ip_align(struct net_device *dev, unsigned int length)

// net/core/skbuff.c (概念性)
struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
                            int flags, int node)
{
    struct sk_buff *skb;
    u8 *data;

    // 步骤 1：从 slab 缓存分配 sk_buff 头部
    if (flags & SKB_ALLOC_FCLONE)
        skb = kmem_cache_alloc_node(skbuff_fclone_cache, gfp_mask, node);
    else
        skb = kmem_cache_alloc_node(skbuff_cache, gfp_mask, node);

    // 步骤 2：分配数据缓冲区
    size = SKB_DATA_ALIGN(size);      // 对齐到 cache line
    size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));  // 尾部 shinfo
    data = kmalloc_reserve(&size, gfp_mask, node, &pfmemalloc);

    // 步骤 3：初始化指针
    skb->head = data;
    skb->data = data;
    skb_reset_tail_pointer(skb);
    skb->end = skb->tail + size - SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
    skb->truesize = SKB_TRUESIZE(size);  // 记账大小

    return skb;
}

// net/core/skbuff.c (概念性)
struct sk_buff *__napi_alloc_skb(struct napi_struct *napi,
                                  unsigned int len, gfp_t gfp_mask)
{
    // 对于小包（< PAGE_SIZE）
    // 从 per-CPU 的 napi_alloc_cache 分配 page fragment
    // 多个小 skb 共享同一个物理页

    struct page_frag_cache *nc = this_cpu_ptr(&napi_alloc_cache);
    void *data = page_frag_alloc(nc, len, gfp_mask);

    // 构建 sk_buff 并指向 fragment 数据
    skb->head = data;
    skb->head_frag = 1;  // 标记使用 page fragment

    return skb;
}

// 三种 skb 复制方式

// clone：共享数据缓冲区，独立 sk_buff 头
struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t priority);
// 用途：TCP 重传（保留原始 skb 直到 ACK）
// 开销：仅分配 sk_buff 头（~256 字节）

// pskb_copy：复制头部区域数据，共享 page fragment
struct sk_buff *pskb_copy(struct sk_buff *skb, gfp_t gfp_mask);
// 用途：需要修改 L3/L4 头但不改载荷
// 开销：分配 sk_buff 头 + linear 区域

// skb_copy：完全深拷贝
struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t priority);
// 用途：需要修改所有数据
// 开销：分配 sk_buff 头 + 全部数据

// include/net/page_pool/types.h
struct page_pool_params {
    /* 快路径字段（常在栈上） */
    unsigned int    flags;     // PP_FLAG_DMA_MAP | PP_FLAG_DMA_SYNC_DEV
    unsigned int    order;     // 页阶数（2^order 页/次）
    unsigned int    pool_size; // ptr_ring 大小
    int             nid;       // NUMA 节点
    struct device   *dev;      // DMA 设备
    struct napi_struct *napi;  // 关联 NAPI（单消费者优化）
    enum dma_data_direction dma_dir;
    unsigned int    max_len;   // DMA 同步最大长度
    unsigned int    offset;    // DMA 同步起始偏移

    /* 慢路径字段 */
    struct net_device *netdev;
    void (*init_callback)(struct page *page, void *arg);
    void *init_arg;
};

// include/net/page_pool/types.h
#define PP_ALLOC_CACHE_SIZE   128  // per-CPU 快缓存容量
#define PP_ALLOC_CACHE_REFILL  64  // 补充水位（= NAPI budget）

struct pp_alloc_cache {
    u32 count;
    struct page *cache[PP_ALLOC_CACHE_SIZE];
};

struct page_pool {
    struct page_pool_params_fast p;

    long frag_users;               // 当前 fragment 用户数
    struct page *frag_page;        // 当前切分中的页
    unsigned int frag_offset;      // 切分偏移

    struct pp_alloc_cache alloc;   // per-CPU 快缓存
    struct ptr_ring ring;          // 无锁回收队列
    // ...
};

// include/net/page_pool/helpers.h

// 分配整页
static inline struct page *
page_pool_dev_alloc_pages(struct page_pool *pool);

// 分配页 fragment（从一个大页切分多个小块）
static inline struct page *
page_pool_dev_alloc_frag(struct page_pool *pool,
                         unsigned int *offset,
                         unsigned int size);

// 智能分配（根据大小自动选择整页或 fragment）
static inline struct page *
page_pool_dev_alloc(struct page_pool *pool,
                    unsigned int *offset,
                    unsigned int *size);

// 驱动在分配时标记页属于 page pool
skb_mark_for_recycle(skb);
// 设置 skb->pp_recycle = 1

// 释放时检查标记
// net/core/skbuff.c
void __kfree_skb(struct sk_buff *skb)
{
    // ...
    if (skb->pp_recycle)
        // 页回到 page pool 而非 free_pages()
        page_pool_return_skb_page(page);
}

// include/net/page_pool/types.h
struct page_pool_alloc_stats {
    u64 fast;            // 快缓存命中
    u64 slow;            // 走 page allocator（order-0）
    u64 slow_high_order; // 走 page allocator（高阶）
    u64 empty;           // ring 空，被迫分配
    u64 refill;          // 缓存补充次数
    u64 waive;           // NUMA 不匹配页被拒绝
};

struct page_pool_recycle_stats {
    u64 cached;          // 回到 per-CPU 缓存
    u64 cache_full;      // 缓存满，走 ring
    u64 ring;            // 放入 ptr_ring
    u64 ring_full;       // ring 满，真正释放
    u64 released_refcnt; // refcnt>1，无法回收
};

# 查看 page pool 统计
cat /sys/kernel/debug/page_pool/page_pool-*
# 或使用 ethtool
ethtool -S eth0 | grep page_pool

// page pool 分配时（概念性）
struct page *page_pool_alloc_pages(struct page_pool *pool, gfp_t gfp)
{
    struct page *page;

    // 从 ring 取出页
    page = ptr_ring_consume(&pool->ring);
    if (page) {
        // 检查 NUMA 节点
        if (page_to_nid(page) != pool->p.nid) {
            // NUMA 不匹配 → 拒绝，统计 waive++
            page_pool_return_page(pool, page);
            goto alloc_new;
        }
        return page;
    }
alloc_new:
    // 从指定 NUMA 节点分配新页
    return __page_pool_alloc_page_order(pool, gfp);
}

# 确保网卡中断绑定到正确的 NUMA 节点
# 查看网卡的 NUMA 节点
cat /sys/class/net/eth0/device/numa_node

# 查看 CPU 的 NUMA 分布
lscpu | grep NUMA

# 绑定中断到同一 NUMA 节点的 CPU
# 例如 NUMA node 0 = CPU 0-15
echo 0000ffff > /proc/irq/XX/smp_affinity

# 绑定 NAPI 到指定 CPU（通过 RSS）
ethtool -X eth0 equal 16

// include/net/sock.h
struct sock {
    int             sk_rcvbuf;      // 接收缓冲区上限
    int             sk_sndbuf;      // 发送缓冲区上限
    refcount_t      sk_wmem_alloc;  // 发送路径已分配字节
    int             sk_wmem_queued; // 发送队列排队字节
    int             sk_forward_alloc; // 预分配额度
    u32             sk_reserved_mem;  // 保留不可回收内存

    struct {
        atomic_t    rmem_alloc;     // 接收路径已分配字节
        int         len;
        struct sk_buff *head;
        struct sk_buff *tail;
    } sk_backlog;
};

#define sk_rmem_alloc  sk_backlog.rmem_alloc

// 收包路径记账
void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
{
    skb->sk = sk;
    skb->destructor = sock_rfree;  // 释放时回调
    atomic_add(skb->truesize, &sk->sk_rmem_alloc);
    // 充值到 sk->sk_forward_alloc
    sk_mem_charge(sk, skb->truesize);
}

// 释放时回调
void sock_rfree(struct sk_buff *skb)
{
    struct sock *sk = skb->sk;
    atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
    sk_mem_uncharge(sk, skb->truesize);
    // 如果有等待的写者/读者，唤醒
}

// TCP 收包路径
int tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
{
    // ...
    if (!sk_rmem_schedule(sk, skb, skb->truesize)) {
        // 内存不足 → 丢弃该包
        // TCP 发送端会重传
        goto drop;
    }
    // ...
}

// 内存检查
static inline bool sk_rmem_schedule(struct sock *sk,
                                     struct sk_buff *skb,
                                     int size)
{
    // 检查 sk_rmem_alloc + size <= sk_rcvbuf
    // 加上全局 TCP 内存压力检查
    return __sk_rmem_schedule(sk, size, skb_pfmemalloc(skb));
}

// include/net/tcp.h
extern long sysctl_tcp_mem[3];  // [low, pressure, high]
extern atomic_long_t tcp_memory_allocated;
extern unsigned long tcp_memory_pressure;

# 查看 TCP 内存水位（单位：页）
cat /proc/sys/net/ipv4/tcp_mem
# 例如：94389 125852 188778
# low=369MB  pressure=491MB  high=738MB（4KB 页）

# 查看当前 TCP 内存使用
cat /proc/net/sockstat | grep TCP
# TCP: inuse 1234 orphan 12 tw 567 alloc 1500 mem 8901
# mem 字段单位是页

# socket 默认/最大缓冲区
net.core.rmem_default = 212992   # 接收默认（208KB）
net.core.rmem_max = 212992       # 接收最大
net.core.wmem_default = 212992   # 发送默认
net.core.wmem_max = 212992       # 发送最大

# TCP 自动调优范围 [min default max]
net.ipv4.tcp_rmem = 4096 131072 6291456  # 4KB 128KB 6MB
net.ipv4.tcp_wmem = 4096 16384 4194304   # 4KB 16KB 4MB

# TCP 全局内存限制（页数）
net.ipv4.tcp_mem = 94389 125852 188778

# 应用层设置
# setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
# setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));

// 概念性
void sk_mem_charge(struct sock *sk, int size)
{
    // 从 forward_alloc 中扣除
    sk->sk_forward_alloc -= size;

    if (sk->sk_forward_alloc < 0) {
        // forward_alloc 耗尽 → 从全局池批量补充
        int amt = sk_mem_pages(size);
        sk->sk_forward_alloc += amt * PAGE_SIZE;
        atomic_long_add(amt, &tcp_memory_allocated);
        // 检查是否触发压力模式
    }
}

// include/linux/skbuff.h

// NAPI 上下文释放（可批量延迟）
void napi_consume_skb(struct sk_buff *skb, int budget);

// 通用释放
void consume_skb(struct sk_buff *skb);    // 正常消费
void kfree_skb(struct sk_buff *skb);      // 丢包释放（触发 drop 统计）

// 驱动上下文宏
#define dev_kfree_skb(a)    consume_skb(a)
#define dev_consume_skb_any(a)  consume_skb(a)

// net/core/skbuff.c (概念性)
void napi_consume_skb(struct sk_buff *skb, int budget)
{
    if (budget == 0) {
        // budget=0 意味着非 NAPI 上下文
        // 走普通释放路径
        dev_consume_skb_any(skb);
        return;
    }

    // NAPI 上下文：延迟释放
    // 利用 softirq 的 per-CPU 特性
    // 批量释放减少锁竞争和 cache 失效

    if (skb->pp_recycle) {
        // page pool 回收路径
        // 页回到 page pool 而非 free_pages()
    }

    // 释放 sk_buff 头部到 slab
    // 释放 frag 页面到 page pool 或伙伴系统
}

// include/linux/skbuff.h
static inline void skb_mark_for_recycle(struct sk_buff *skb)
{
#ifdef CONFIG_PAGE_POOL
    skb->pp_recycle = 1;
#endif
}

// 典型驱动用法：
struct page *page = page_pool_dev_alloc_pages(pool);
// ... 设置 DMA，网卡写入数据 ...
skb = napi_alloc_skb(napi, headlen);
skb_add_rx_frag(skb, 0, page, offset, len, truesize);
skb_mark_for_recycle(skb);
napi_gro_receive(napi, skb);

// net/core/dev.c (概念性)
static void net_rx_action(struct softirq_action *h)
{
    unsigned long budget = netdev_budget;       // 默认 300
    unsigned long time_limit = jiffies +
        usecs_to_jiffies(netdev_budget_usecs);  // 默认 2ms

    while (budget > 0 && time_before(jiffies, time_limit)) {
        // 遍历 poll_list 中的 NAPI 实例
        struct napi_struct *n = list_first_entry(...);
        int work = napi_poll(n, min(budget, n->weight));
        budget -= work;
    }
}

// net/core/dev.c
// 全局参数
int netdev_max_backlog = 1000;  // 每 CPU backlog 上限

// 入队时检查
int enqueue_to_backlog(struct sk_buff *skb, int cpu, ...)
{
    struct softnet_data *sd = &per_cpu(softnet_data, cpu);

    if (skb_queue_len(&sd->input_pkt_queue) > netdev_max_backlog) {
        // 队列满 → 丢包
        // 计入 /proc/net/softnet_stat 第二列
        sd->dropped++;
        kfree_skb(skb);
        return NET_RX_DROP;
    }
    // 入队成功
}

# 监控 backlog 丢包
cat /proc/net/softnet_stat
# 每行对应一个 CPU
# 第一列：已处理包数
# 第二列：backlog 丢包数（应为 0）
# 第三列：softirq 时间超限次数

# 统计 sk_buff 分配来源
bpftrace -e '
kprobe:__alloc_skb {
    @alloc_skb = count();
}
kprobe:__napi_alloc_skb {
    @napi_alloc = count();
}
kprobe:__netdev_alloc_skb {
    @netdev_alloc = count();
}
interval:s:5 {
    print(@alloc_skb);
    print(@napi_alloc);
    print(@netdev_alloc);
    clear(@alloc_skb);
    clear(@napi_alloc);
    clear(@netdev_alloc);
}
'

# 统计 page pool 的回收路径
bpftrace -e '
kprobe:page_pool_return_skb_page {
    @pp_recycle = count();
}
kprobe:__page_pool_alloc_pages_slow {
    @pp_slow_alloc = count();
}
interval:s:5 {
    printf("page_pool recycle: %lld, slow_alloc: %lld\n",
           @pp_recycle, @pp_slow_alloc);
    clear(@pp_recycle);
    clear(@pp_slow_alloc);
}
'

# 追踪 TCP 内存压力事件
bpftrace -e '
kprobe:tcp_enter_memory_pressure {
    printf("TCP memory pressure entered! allocated: %ld pages\n",
           *kaddr("tcp_memory_allocated"));
    @pressure_events = count();
}
kprobe:tcp_leave_memory_pressure {
    printf("TCP memory pressure left\n");
}
'

# 持续监控 TCP 内存使用
watch -n 1 'cat /proc/net/sockstat | grep TCP'

# 检测 truesize 异常大的 skb（可能是内存泄漏）
bpftrace -e '
kprobe:skb_set_owner_r {
    $skb = (struct sk_buff *)arg0;
    if ($skb->truesize > 65536) {
        printf("Large truesize: %d bytes, dev=%s\n",
               $skb->truesize, str($skb->dev->name));
        @large_truesize = hist($skb->truesize);
    }
}
interval:s:30 { print(@large_truesize); clear(@large_truesize); }
'

# 分析网络内存分配在总 CPU 中的占比
perf record -g -a -e cycles -- sleep 10
perf report --no-children | grep -E '(alloc_skb|page_pool|kmem_cache)'

# 追踪 DMA 映射开销
perf stat -e 'dma:*' -a -- sleep 10

# 1. 确认 NUMA 对齐
cat /sys/class/net/eth0/device/numa_node
cat /proc/interrupts | grep eth0

# 2. 检查 page pool 是否启用
ethtool -S eth0 | grep -i page_pool

# 3. 检查内存压力
cat /proc/net/sockstat
# TCP: mem 字段不应接近 tcp_mem[1]

# 4. 检查 backlog 丢包
cat /proc/net/softnet_stat
# 第二列应为 0

# 5. 检查 socket 缓冲区使用
ss -tm  # 查看每连接的内存使用