4. sk_buff 结构体详解（下）：链表管理与克隆机制

在 Linux 内核协议栈中，sk_buff 并非孤立存在。网络数据包在协议层之间传递、在队列中等待调度、被多个消费者共享时，必须依赖高效的链表管理和引用计数机制。本章深入剖析 sk_buff 的链表组织方式、sk_buff_head 结构的设计意图，以及克隆（clone）与拷贝（copy）的底层实现差异。

4.1 sk_buff 链表结构：next/prev 与 sk_buff_head

每个 sk_buff 结构体内部包含两个链表指针：

struct sk_buff {
    /* 链表指针 */
    struct sk_buff    *next;    /* 指向链表中的下一个 sk_buff */
    struct sk_buff    *prev;    /* 指向链表中的上一个 sk_buff */

    /* 所属链表头 */
    struct sk_buff_head *list;  /* 指向该 sk_buff 所属的链表头 */

    /* ... 其他字段 ... */
};

然而，内核并不直接使用 sk_buff 的 next/prev 作为链表头，而是定义了一个专用的 sk_buff_head 结构：

struct sk_buff_head {
    /* 链表节点，必须放在头部，用于类型转换 */
    struct sk_buff    *next;
    struct sk_buff    *prev;

    __u32             qlen;     /* 队列中 sk_buff 的数量 */
    spinlock_t        lock;     /* 保护链表的自旋锁 */
};

下图展示了 sk_buff_head 与 sk_buff 节点之间的双向链表关系：

4.2 链表操作 API

内核提供了一套标准的 sk_buff_head 操作函数，驱动和协议栈代码通过它们管理数据包队列：

4.3 引用计数与克隆机制

网络数据包在协议栈中经常需要被多个消费者同时处理。例如，一个接收到的数据包既要递交给原始套接字（raw socket），又要进入正常的 TCP/IP 协议栈。如果直接拷贝整个 sk_buff 及其数据缓冲区，开销极大。Linux 内核通过引用计数和克隆机制实现高效的共享。

4.3.1 引用计数：dataref

每个 sk_buff 的数据缓冲区（skb_shared_info 区域）维护一个引用计数字段 dataref：

struct skb_shared_info {
    atomic_t    dataref;        /* 引用计数 */
    /* ... 其他字段（frags, frag_list 等） ... */
};

当多个 sk_buff 结构共享同一个数据缓冲区时，dataref 记录共享该缓冲区的 sk_buff 数量。初始值为 1，每克隆一次增加 1，每释放一个引用减少 1。当 dataref 降为 0 时，数据缓冲区才被真正释放。

4.3.2 克隆（Clone） vs 拷贝（Copy）

内核提供了两种共享数据的方式：

下图展示了克隆与拷贝在内存布局上的本质区别：

4.4 克隆的深层机制：skb_shared_info 与 destructor_arg

当调用 skb_clone() 时，内核执行以下关键步骤：

1. 分配新的 sk_buff 结构：从 slab 缓存中分配一个新的 sk_buff 实例。
2. 复制元数据：将原始 sk_buff 中的指针（如 head、data、tail、end）和标志位复制到新结构中。
3. 增加引用计数：通过 atomic_inc(&skb_shinfo(skb)->dataref) 将 dataref 加 1。
4. 设置克隆标志：在新 sk_buff 的 cloned 字段置 1，表示这是一个克隆副本。
5. 设置 destructor_arg：克隆的 sk_buff 的 destructor_arg 指向原始 sk_buff，用于在释放时回调通知。

/* skb_clone 核心逻辑（简化版） */
struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
{
    struct sk_buff *n;

    n = alloc_skb(0, gfp_mask);  /* 只分配 sk_buff 结构，不分配数据缓冲区 */
    if (!n)
        return NULL;

    /* 复制 sk_buff 元数据 */
    memcpy(n, skb, sizeof(*n));

    /* 增加数据缓冲区引用计数 */
    atomic_inc(&(skb_shinfo(skb)->dataref));

    /* 标记为克隆 */
    n->cloned = 1;

    /* 设置 destructor_arg 指向原始 skb */
    n->destructor_arg = skb;

    /* 初始化链表指针 */
    n->next = n->prev = NULL;
    n->list = NULL;

    return n;
}

4.5 引用计数与释放流程

当 sk_buff 被释放时（通过 kfree_skb() 或 dev_kfree_skb()），内核执行以下逻辑：

1. 检查克隆标志：如果 cloned 为 1，则调用 skb_release_data()。
2. 减少引用计数：atomic_dec(&skb_shinfo(skb)->dataref)。
3. 判断是否释放数据缓冲区：如果 dataref 降为 0，则释放 skb->head 指向的数据缓冲区。
4. 释放 sk_buff 结构：将 sk_buff 结构归还 slab 缓存。

void kfree_skb(struct sk_buff *skb)
{
    if (!skb)
        return;

    /* 如果 skb 是克隆的，减少数据缓冲区引用计数 */
    if (skb->cloned)
        skb_release_data(skb);

    /* 释放 sk_buff 结构本身 */
    kmem_cache_free(skbuff_cache, skb);
}

static void skb_release_data(struct sk_buff *skb)
{
    struct skb_shared_info *shinfo = skb_shinfo(skb);

    /* 减少引用计数，如果降为 0 则释放数据缓冲区 */
    if (atomic_dec_and_test(&shinfo->dataref))
        skb_free_head(skb);  /* 释放 skb->head 指向的内存 */
}

4.6 本章小结