网络数据包收发流程：从驱动到协议栈

╰+哭是因爲堅強的太久メ 2023-07-17 06:49 12阅读 0赞

**一、硬件环境**  
[![format_png][]][format_png 1]  
intel82546：PHY与MAC集成在一起的PCI网卡芯片，很强大  
bcm5461：   PHY芯片，与之对应的MAC是TSEC  
TSEC：      Three Speed Ethernet Controller，三速以太网控制器，PowerPc 架构CPU里面的MAC模块  
            注意,TSEC内部有DMA子模块    
  
话说现在的CPU越来越牛叉了，什么功能都往里面加，最常见的如MAC功能。  
TSEC只是MAC功能模块的一种，其他架构的cpu也有和TSEC类似的MAC功能模块。  
这些集成到CPU芯片上的功能模块有个学名，叫平台设备，即 platform device。  
  
**二、网络收包原理**  
  
网络驱动收包大致有3种情况：  
  
**no NAPI**：mac每收到一个以太网包，都会产生一个接收中断给cpu，即完全靠中断方式来收包  
          缺点是当网络流量很大时，cpu大部分时间都耗在了处理mac的中断。  
  
**netpoll**：在网络和I/O子系统尚不能完整可用时，模拟了来自指定设备的中断，即轮询收包。  
         缺点是实时性差  
  
**NAPI**： 采用 中断 + 轮询 的方式：mac收到一个包来后会产生接收中断，但是马上关闭。  
       直到收够了netdev\_max\_backlog个包（默认300），或者收完mac上所有包后，才再打开接收中断  
       通过sysctl来修改 net.core.netdev\_max\_backlog  
       或者通过proc修改 /proc/sys/net/core/netdev\_max\_backlog  
  
  
下面只写内核配置成使用NAPI的情况，只写TSEC驱动。（非NAPI的情况和PCI网卡驱动 以后再说）  
内核版本 linux 2.6.24  
  
**三、NAPI 相关数据结构**  
[![format_png 2][]][format_png 2 1]  
每个网络设备（MAC层）都有自己的net\_device数据结构，这个结构上有napi\_struct。  
每当收到数据包时，网络设备驱动会把自己的napi\_struct挂到CPU私有变量上。  
这样在软中断时，net\_rx\_action会遍历cpu私有变量的poll\_list，  
执行上面所挂的napi\_struct结构的poll钩子函数,将数据包从驱动传到网络协议栈。  
  
**四、内核启动时的准备工作**  
  
**4.1 初始化网络相关的全局数据结构，并挂载处理网络相关软中断的钩子函数**  
start\_kernel()  
    --> rest\_init()  
        --> do\_basic\_setup()  
            --> do\_initcall  
               -->**net\_dev\_init**  
  
\_\_init **net\_dev\_init**()  
\{  
    //每个CPU都有一个CPU私有变量 \_get\_cpu\_var(softnet\_data)  
    //**\_get\_cpu\_var(softnet\_data).poll\_list**很重要，软中断中需要遍历它的  
    for\_each\_possible\_cpu(i) \{  
        struct softnet\_data \*queue;  
        queue = &per\_cpu(softnet\_data, i);  
        skb\_queue\_head\_init(&queue->input\_pkt\_queue);  
        queue->completion\_queue = NULL;  
        INIT\_LIST\_HEAD(**&queue->poll\_list**);  
        queue->backlog.poll = process\_backlog;  
        queue->backlog.weight = weight\_p;  
    \}  
    open\_softirq(NET\_TX\_SOFTIRQ, **net\_tx\_action**, NULL); //在软中断上挂网络发送handler  
    open\_softirq(NET\_RX\_SOFTIRQ, **net\_rx\_action**, NULL); //在软中断上挂网络接收handler  
\}  
     
**4.2 加载网络设备的驱动**  
NOTE：这里的网络设备是指MAC层的网络设备，即TSEC和PCI网卡（bcm5461是phy）  
在网络设备驱动中创建net\_device数据结构，并初始化其钩子函数 open(),close() 等  
挂载TSEC的驱动的入口函数是 **gfar\_probe**  
  
// 平台设备 TSEC 的数据结构  
static struct platform\_driver gfar\_driver = \{  
    .probe = **gfar\_probe**,  
    .remove = gfar\_remove,  
    .driver = \{  
        .name = "fsl-gianfar",  
    \},  
\};  
  
int **gfar\_probe**(struct platform\_device \*pdev)  
\{  
    dev = alloc\_etherdev(sizeof (\*priv)); // 创建net\_device数据结构  
  
    dev->open = **gfar\_enet\_open**;  
    dev->hard\_start\_xmit = **gfar\_start\_xmit**;  
    dev->tx\_timeout = gfar\_timeout;  
    dev->watchdog\_timeo = TX\_TIMEOUT;  
\#ifdef CONFIG\_GFAR\_NAPI  
    netif\_napi\_add(dev, &priv->napi,**gfar\_poll**,GFAR\_DEV\_WEIGHT); //软中断里会调用poll钩子函数  
\#endif  
\#ifdef CONFIG\_NET\_POLL\_CONTROLLER  
    dev->poll\_controller = gfar\_netpoll;  
\#endif  
    dev->stop = gfar\_close;  
    dev->change\_mtu = gfar\_change\_mtu;  
    dev->mtu = 1500;  
    dev->set\_multicast\_list = gfar\_set\_multi;  
    dev->set\_mac\_address = gfar\_set\_mac\_address;  
    dev->ethtool\_ops = &gfar\_ethtool\_ops;  
\}  
  
**五、****启用****网络设备**  
**5.1 用户调用ifconfig等程序，然后通过ioctl系统调用进入内核**  
socket的ioctl()系统调用  
    --> sock\_ioctl()  
        --> dev\_ioctl()                              //判断SIOCSIFFLAGS  
          --> \_\_dev\_get\_by\_name(net, ifr->ifr\_name)  //根据名字选net\_device  
             --> dev\_change\_flags()                  //判断IFF\_UP  
                --> dev\_open(net\_device)             //调用open钩子函数   
  
 对于TSEC来说，挂的钩子函数是 **gfar\_enet\_open(net\_device)**  
  
**5.2 在网络设备的open钩子函数里，分配接收bd，挂中断ISR(包括rx、tx、err)，对于TSEC来说**  
**gfar\_enet\_open**  
    --> 给Rx Tx Bd 分配一致性DMA内存   
    --> 把Rx Bd的“EA地址”赋给数据结构，物理地址赋给TSEC寄存器  
    --> 把Tx Bd的“EA地址”赋给数据结构，物理地址赋给TSEC寄存器  
    --> 给 tx\_skbuff 指针数组 分配内存，并初始化为NULL  
    --> 给 rx\_skbuff 指针数组 分配内存，并初始化为NULL  
  
    --> 初始化Tx Bd  
    --> 初始化Rx Bd，提前分配存储以太网包的skb，这里使用的是一次性dma映射  
       （注意：**\#define DEFAULT\_RX\_BUFFER\_SIZE  1536**保证了skb能存一个以太网包）  
        rxbdp = priv->rx\_bd\_base;  
        for (i = 0; i < priv->rx\_ring\_size; i++) \{  
            struct sk\_buff \*skb = NULL;  
            rxbdp->status = 0;  
            //这里真正分配skb，并且初始化rxbpd->bufPtr, rxbdpd->length  
            **skb = gfar\_new\_skb(dev, rxbdp); ****   **  
            **priv->rx\_skbuff\[i\] = skb;**  
            rxbdp++;  
        \}  
        rxbdp--;  
        rxbdp->status |= RXBD\_WRAP; // 给最后一个bd设置标记WRAP标记  
          
    --> 注册TSEC相关的中断handler： 错误，接收，发送  
        request\_irq(priv->interruptError, **gfar\_error**, 0, "enet\_error", dev)  
        request\_irq(priv->interruptTransmit, **gfar\_transmit**, 0, "enet\_tx", dev)//包发送完  
        request\_irq(priv->interruptReceive,** gfar\_receive**, 0, "enet\_rx", dev)  //包接收完  
  
    -->gfar\_start(net\_device)  
        // 使能Rx、Tx  
        // 开启TSEC的 DMA 寄存器  
        // Mask 掉我们不关心的中断event  
  
**最终，TSEC相关的Bd等数据结构应该是下面这个样子的**  
[![format_png 3][]][format_png 3 1]  
**六、中断里接收以太网包**  
  
TSEC的RX已经使能了，网络数据包进入内存的流程为：  
**    网线 --> Rj45网口 --> MDI 差分线  
         --> bcm5461(PHY芯片进行数模转换) --> MII总线   
         --> TSEC的DMA Engine 会自动检查下一个可用的Rx bd   
         --> 把网络数据包 DMA 到 Rx bd 所指向的内存，即skb->data**  
  
接收到一个完整的以太网数据包后，TSEC会根据event mask触发一个 Rx 外部中断。  
cpu保存现场，根据中断向量，开始执行外部中断处理函数do\_IRQ()  
  
do\_IRQ 伪代码  
\{  
   上半部处理硬中断  
       查看中断源寄存器，得知是网络外设产生了外部中断  
       执行网络设备的rx中断handler（设备不同，函数不同，但流程类似，TSEC是**gfar\_receive**）  
          1. mask 掉 rx event，再来数据包就不会产生rx中断  
          2. 给napi\_struct.state加上 NAPI\_STATE\_SCHED 状态  
          3. 挂网络设备自己的napi\_struct结构到cpu私有变量\_get\_cpu\_var(softnet\_data).poll\_list  
          4. 触发网络接收软中断  
    下半部处理软中断  
        依次执行所有软中断handler，包括timer，tasklet等等  
        执行网络接收的软中断handler ** net\_rx\_action**  
          1. 遍历cpu私有变量\_get\_cpu\_var(softnet\_data).poll\_list   
          2. 取出poll\_list上面挂的napi\_struct 结构,执行钩子函数napi\_struct.poll()  
             (设备不同，钩子函数不同,流程类似，TSEC是**gfar\_poll**)  
          3. 若poll钩子函数处理完所有包，则打开rx event mask，再来数据包的话会产生rx中断  
          4. 调用napi\_complete(napi\_struct \*n)  
             把napi\_struct 结构从\_get\_cpu\_var(softnet\_data).poll\_list 上移走  
             同时去掉 napi\_struct.state 的 NAPI\_STATE\_SCHED 状态  
\}  
  
**6.1 TSEC的接收中断处理函数**  
**gfar\_receive**  
\{  
\#ifdef CONFIG\_GFAR\_NAPI  
    // test\_and\_set当前net\_device的napi\_struct.state 为 NAPI\_STATE\_SCHED  
    // 在软中断里调用 net\_rx\_action 会检查状态 napi\_struct.state  
    if (**netif\_rx\_schedule\_prep**(dev, &priv->napi)) \{    
        tempval = gfar\_read(&priv->regs->imask);              
        tempval &= IMASK\_RX\_DISABLED; //mask掉rx，不再产生rx中断  
        gfar\_write(&priv->regs->imask, tempval);      
        // 将当前net\_device的 napi\_struct.poll\_list 挂到  
        // CPU私有变量\_\_get\_cpu\_var(softnet\_data).poll\_list 上，并触发软中断  
        // 所以，在软中断中调用 net\_rx\_action 的时候，就会执行当前net\_device的  
        // napi\_struct.poll()钩子函数,即 gfar\_poll()  
        **\_\_netif\_rx\_schedule**(dev, &priv->napi);     
    \}   
\#else  
    gfar\_clean\_rx\_ring(dev, priv->rx\_ring\_size);  
\#endif  
\}  
  
**6.2 ****网络接收****软中断net\_rx\_action**  
**net\_rx\_action**()  
\{  
    struct list\_head \*list = &\_\_get\_cpu\_var(softnet\_data).poll\_list;      
    //通过 napi\_struct.poll\_list， 将N多个 napi\_struct 链接到一条链上   
    //通过 CPU私有变量，我们找到了链头，然后开始遍历这个链  
  
    int budget = netdev\_budget; //这个值就是 net.core.netdev\_max\_backlog，通过sysctl来修改  
  
    while (!list\_empty(list)) \{  
        struct napi\_struct \*n;  
        int work, weight;  
        local\_irq\_enable();  
        //从链上取一个 napi\_struct 结构（接收中断处理函数里加到链表上的，如gfar\_receive）  
        n = list\_entry(list->next, struct napi\_struct, poll\_list);  
        weight = n->weight;  
        work = 0;  
        if (test\_bit(NAPI\_STATE\_SCHED, &n->state)) //检查状态标记，此标记在接收中断里加上的     
            work = n->poll(n, weight); //使用NAPI的话，使用的是网络设备自己的napi\_struct.poll  
                                       //对于TSEC是，是**gfar\_poll**  
        WARN\_ON\_ONCE(work > weight);  
        budget -= work;  
        local\_irq\_disable();  
  
        if (unlikely(work == weight)) \{  
            if (unlikely(napi\_disable\_pending(n)))  
                \_\_napi\_complete(n); //操作napi\_struct,把去掉NAPI\_STATE\_SCHED状态，从链表中删去  
            else  
                list\_move\_tail(&n->poll\_list, list);  
        \}  
        netpoll\_poll\_unlock(have);  
    \}  
out:  
    local\_irq\_enable();  
\}  
  
static int **gfar\_poll**(struct napi\_struct \*napi, int budget)  
\{  
    struct gfar\_private \*priv = container\_of(napi, struct gfar\_private, napi);  
    struct net\_device \*dev = priv->dev;  //TSEC对应的网络设备  
    int howmany;    
    //根据dev的rx bd，获取skb并送入协议栈，返回处理的skb的个数，即以太网包的个数  
    howmany = **gfar\_clean\_rx\_ring**(dev, budget);  
    // 下面这个判断比较有讲究的  
    // 收到的包的个数小于budget，代表我们在一个软中断里就全处理完了，所以打开** rx硬中断**  
    // 要是收到的包的个数大于budget，表示一个软中断里处理不完所有包，那就不打开 **rx硬中断**，  
    // **此次软中断的下一轮循环里**再接着处理，直到包处理完(即howmany rx硬中断  
    if (howmany < budget) \{          
        netif\_rx\_complete(dev, napi);  
        gfar\_write(&priv->regs->rstat, RSTAT\_CLEAR\_RHALT);  
        //打开 rx 硬中断，rx 硬中断是在gfar\_receive()中被关闭的  
        gfar\_write(&priv->regs->imask, IMASK\_DEFAULT);   
    \}  
    return howmany;  
\}            
  
**gfar\_clean\_rx\_ring**(dev, budget)  
\{  
    bdp = priv->cur\_rx;  
    while (!((bdp->status & RXBD\_EMPTY) || (--rx\_work\_limit < 0))) \{  
        rmb();  
        skb = priv->rx\_skbuff\[priv->skb\_currx\]; //从rx\_skbuff\[\]中获取skb  
        howmany++;  
        dev->stats.rx\_packets++;  
        pkt\_len = bdp->length - 4;  //从length中去掉以太网包的FCS长度  
        **gfar\_process\_frame**(dev, skb, pkt\_len);  
        dev->stats.rx\_bytes += pkt\_len;  
        dev->last\_rx = jiffies;  
        bdp->status &= ~RXBD\_STATS;  //清rx bd的状态  
      
        skb = gfar\_new\_skb(dev, bdp); // Add another skb for the future  
        priv->rx\_skbuff\[priv->skb\_currx\] = skb;  
  
        if (bdp->status & RXBD\_WRAP)  //更新指向bd的指针  
            bdp = priv->rx\_bd\_base;   //bd有WARP标记，说明是最后一个bd了，需要“绕回来”  
        else  
            bdp++;  
        priv->skb\_currx = (priv->skb\_currx + 1) & RX\_RING\_MOD\_MASK(priv->rx\_ring\_size);  
    \}  
    priv->cur\_rx = bdp; /\* Update the current rxbd pointer to be the next one \*/  
    return howmany;  
\}  
          
**gfar\_process\_frame()  **  
    -->skb->protocol = eth\_type\_trans(skb, dev); //确定网络层包类型，IP、ARP、VLAN等等  
    -->**RECEIVE(skb)** //调用**netif\_receive\_skb(skb)**进入协议栈  
  
  
\#ifdef CONFIG\_GFAR\_NAPI  
**\#define RECEIVE(x) netif\_receive\_skb(x)**  
\#else  
\#define RECEIVE(x) netif\_rx(x)  
\#endif  
  
\------------------------------------ 华丽的分割线 ---------------------------------------  
  
呼，netif\_receive\_skb(skb) 可算到协议栈了，歇会儿....  
  
  
  
以太网的FCS会在网卡中断**（如gfar\_clean\_rx\_ring）**中忽略掉  
    /\* Remove the FCS from the packet length \*/  
    pkt\_len = bdp->length - 4;  
  
至于填充数据，是在协议栈中被忽略掉的，比如ip协议**ip\_rcv()**  
    /\* Our transport medium may have padded the buffer out. Now we know it  
     \* is IP we can trim to the true length of the frame.  
     \* Note this now means skb->len holds ntohs(iph->tot\_len).  
     \*/  
    if (pskb\_trim\_rcsum(skb, len)) \{  
        IP\_INC\_STATS\_BH(IPSTATS\_MIB\_INDISCARDS);  
        goto drop;  
    \}

# **上一篇讲的是内核配置成NAPI的情况，那也是绝大多数内核使用的配置   现在讲讲内核不配置成NAPI时的情况**      **一、no NAPI 数据结构**   [![format_png 4][]][format_png 4 1]   不配置NAPI的时候，网络设备不使用自己的napi\_struct结构，   所有网络设备驱动都使用同一个napi\_struct,即cpu私有变量\_\_get\_cpu\_var(softnet\_data).backlog      每当收到数据包时，网络设备驱动会把\_\_get\_cpu\_var(softnet\_data).backlog挂到\_\_get\_cpu\_var(softnet\_data).poll\_list上面。      所以软中断里net\_rx\_action遍历cpu私有变量\_\_get\_cpu\_var(softnet\_data).poll\_list时，   上面挂的napi\_struct只有一个      **二、内核启动时的准备工作**      也是在**net\_dev\_init**中，初始化了cpu私有变量的napi\_struct，即所有网络设备驱动使用的napi\_struct      \_\_init **net\_dev\_init**()   \{        //每个CPU都有一个私有变量 \_get\_cpu\_var(softnet\_data)       //\_get\_cpu\_var(softnet\_data).poll\_list很重要，软中断中需要遍历它的       for\_each\_possible\_cpu(i) \{            struct softnet\_data \*queue;           queue = &per\_cpu(softnet\_data, i);           skb\_queue\_head\_init(&queue->input\_pkt\_queue); // 不配置NAPI时，才使用这个接收队列           queue->completion\_queue = NULL;           INIT\_LIST\_HEAD(**&queue->poll\_list**);           queue->backlog.poll = process\_backlog;        // poll钩子函数初始化           queue->backlog.weight = weight\_p;             //       \}       open\_softirq(NET\_TX\_SOFTIRQ, net\_tx\_action, NULL); //在软中断上挂网络接收handler       open\_softirq(NET\_RX\_SOFTIRQ, net\_rx\_action, NULL); //在软中断上挂网络发送handler   \}      **三、中断里接受以太网包**      **TSEC的接收中断处理函数**      **gfar\_receive**   \{        gfar\_write(&priv->regs->ievent, IEVENT\_RX\_MASK);   \#ifdef CONFIG\_GFAR\_NAPI       // test\_and\_set当前net\_device的napi\_struct.state 为 NAPI\_STATE\_SCHED       // 在软中断里调用 net\_rx\_action 会检查状态 napi\_struct.state       if (netif\_rx\_schedule\_prep(dev, &priv->napi)) \{             tempval = gfar\_read(&priv->regs->imask);                       tempval &= IMASK\_RX\_DISABLED;           gfar\_write(&priv->regs->imask, tempval);               // 将当前net\_device的 napi\_struct.poll\_list 挂到           // CPU私有变量 &\_\_get\_cpu\_var(softnet\_data).poll\_list 上，并触发软中断           // 所以，在软中断中调用 net\_rx\_action 的时候，就会执行当前net\_device的           // napi\_struct.poll()钩子函数,即 gfar\_poll()           \_\_netif\_rx\_schedule(dev, &priv->napi);          \}    \#else       **gfar\_clean\_rx\_ring**(dev, priv->rx\_ring\_size);   \#endif   \}      **gfar\_clean\_rx\_ring   **   **   **\-->gfar\_process\_frame**  **         -->初始化了skb->dev，这样在软中断里才能判断这个数据包来自哪里         -->**RECEIVE(skb)** // 调用**netif\_rx(skb)**         \#ifdef CONFIG\_GFAR\_NAPI   \#define RECEIVE(x) netif\_receive\_skb(x)   \#else   **\#define RECEIVE(x) netif\_rx(x)**   \#endif      **netif\_rx(skb)**   \{       queue = &\_\_get\_cpu\_var(softnet\_data);      \_\_skb\_queue\_tail(&queue->input\_pkt\_queue, skb); //将skb放到接收队列(在net\_dev\_init初始化)中      napi\_schedule(&queue->backlog); //将cpu私有变量的的napi\_struct挂到cpu私有变量的poll\_list上                                      //test\_and\_set napi\_struct.state为 NAPI\_STATE\_SCHED                                      //触发网络接收软中断   \}      **软中断net\_rx\_action中调用poll钩子函数**      虽说软中断里也遍历cpu私有变量的poll\_list，事实上poll\_list现在只挂一个napi\_struct结构   即cpu私有变量的backlog成员（它在net\_dev\_init中初始化），所以现在调用的poll钩子函数就是process\_backlog了      static int **process\_backlog**(struct napi\_struct \*napi, int quota)   \{        struct softnet\_data \*queue = &\_\_get\_cpu\_var(softnet\_data);       napi->weight = weight\_p;       do \{            struct sk\_buff \*skb;           struct net\_device \*dev;              local\_irq\_disable();           skb = \_\_skb\_dequeue(&queue->input\_pkt\_queue); //从接收队列中取出skb,           if (!skb) \{                                   //这些skb是在**netif\_rx**中进入队列的               \_\_napi\_complete(napi);               local\_irq\_enable();               break;           \}           local\_irq\_enable();           dev = skb->dev;           netif\_receive\_skb(skb);     //进入协议协议栈           dev\_put(dev);       \} while (++work < quota && jiffies == start\_time);       return work;   \} #

# **进入函数netif\_receive\_skb()后，skb正式开始协议栈之旅。   先上图，协议栈大致过程如下所示：**   [![format_png 5][]][format_png 5 1]   跟OSI七层模型不同，linux根据包结构对网络进行分层。   比如，arp头和ip头都是紧跟在以太网头后面的，所以在linux协议栈中arp和ip地位相同(如上图)   但是在OSI七层模型中，arp属于链路层，ip属于网络层.....    这里就不死抠概念，我们就说arp，ip都属于第二层。下面是网络第二层的处理流程      **一、相关数据结构**   内核处理网络第二层，有下面2个重要list\_head变量 （文件linux\_2\_6\_24/net/core/dev.c)   list\_head 链表上挂了很多packet\_type数据结构      static struct list\_head **ptype\_base**\[16\] \_\_read\_mostly;   /\* 16 way hashed list \*/   static struct list\_head **ptype\_all** \_\_read\_mostly;        /\* Taps \*/      struct packet\_type \{        \_\_be16 **type**;                /\* This is really htons(ether\_type).\*/       struct net\_device   \*dev;   /\* NULL is wildcarded here       \*/       int     (\***func**) (struct sk\_buff \*,                        struct net\_device \*,                        struct packet\_type \*,                        struct net\_device \*);       struct sk\_buff    \*(\*gso\_segment)(struct sk\_buff \*skb, int features);       int    (\*gso\_send\_check)(struct sk\_buff \*skb);       void   \*af\_packet\_priv;       struct list\_head    list;   \};      **type** 成员保存了二层协议类型，ETH\_P\_IP、ETH\_P\_ARP等等   **func **成员就是钩子函数了，如 ip\_rcv()、arp\_rcv()等等      **二、操作packet\_type的API**   //把packet\_type结构挂在与type对应的list\_head上面   void **dev\_add\_pack**(struct packet\_type \*pt)\{        int hash;       spin\_lock\_bh(&ptype\_lock);       if (pt->type == htons(ETH\_P\_ALL))        //type为ETH\_P\_ALL时，挂在ptype\_all上面           list\_add\_rcu(&pt->list, &ptype\_all);       else \{            hash = ntohs(pt->type) & 15;         //否则，挂在ptype\_base\[type&15\]上面           list\_add\_rcu(&pt->list, &ptype\_base\[hash\]);       \}       spin\_unlock\_bh(&ptype\_lock);   \}      //把packet\_type从list\_head上删除   void **dev\_remove\_pack**(struct packet\_type \*pt)\{        \_\_dev\_remove\_pack(pt);       synchronize\_net();   \}   void \_\_dev\_remove\_pack(struct packet\_type \*pt)\{        struct list\_head \*head;       struct packet\_type \*pt1;       spin\_lock\_bh(&ptype\_lock);       if (pt->type == htons(ETH\_P\_ALL))           head = &ptype\_all;                        //找到链表头       else           head = &ptype\_base\[ntohs(pt->type) & 15\]; //          list\_for\_each\_entry(pt1, head, list) \{            if (pt == pt1) \{                list\_del\_rcu(&pt->list);               goto out;           \}       \}       printk(KERN\_WARNING "dev\_remove\_pack: %p not found.\\n", pt);   out:       spin\_unlock\_bh(&ptype\_lock);   \}      **三、进入二层协议处理函数**   int netif\_receive\_skb(struct sk\_buff \*skb)   \{       //略去一些代码       rcu\_read\_lock();       //第一步：先处理 ptype\_all 上所有的 packet\_type->func()                   //所有包都会调func，对性能影响严重！内核默认没挂任何钩子函数       list\_for\_each\_entry\_rcu(ptype, **&ptype\_all**, list) \{  //遍历ptye\_all链表           if (!ptype->dev || ptype->dev == skb->dev) \{    //上面的paket\_type.type 为 ETH\_P\_ALL               if (pt\_prev)                                //对所有包调用paket\_type.func()                   ret = deliver\_skb(skb, pt\_prev, orig\_dev); //此函数最终调用paket\_type.func()               pt\_prev = ptype;           \}       \}       //第二步：若编译内核时选上BRIDGE，下面会执行网桥模块       //调用函数指针 br\_handle\_frame\_hook(skb), 在动态模块 linux\_2\_6\_24/net/bridge/br.c中       //br\_handle\_frame\_hook = br\_handle\_frame;       //所以实际函数 br\_handle\_frame。       //注意：在此网桥模块里初始化 skb->pkt\_type 为 PACKET\_HOST、PACKET\_OTHERHOST       skb = **handle\_bridge**(skb, &pt\_prev, &ret, orig\_dev);       if (!skb) goto out;          //第三步：编译内核时选上MAC\_VLAN模块，下面才会执行       //调用 macvlan\_handle\_frame\_hook(skb), 在动态模块linux\_2\_6\_24/drivers/net/macvlan.c中       //macvlan\_handle\_frame\_hook = macvlan\_handle\_frame;        //所以实际函数为 macvlan\_handle\_frame。        //注意：此函数里会初始化 skb->pkt\_type 为 PACKET\_BROADCAST、PACKET\_MULTICAST、PACKET\_HOST       skb = **handle\_macvlan**(skb, &pt\_prev, &ret, orig\_dev);       if (!skb)  goto out;          //第四步：最后 type = skb->protocol; &ptype\_base\[ntohs(type)&15\]       //处理ptype\_base\[ntohs(type)&15\]上的所有的 packet\_type->func()       //根据第二层不同协议来进入不同的钩子函数，重要的有：**ip\_rcv() arp\_rcv()**       type = skb->protocol;       list\_for\_each\_entry\_rcu(ptype, **&ptype\_base\[ntohs(type)&15\]**, list) \{            if (ptype->type == type &&                      //遍历包type所对应的链表               (!ptype->dev || ptype->dev == skb->dev)) \{  //调用链表上所有pakcet\_type.func()               if (pt\_prev)                   ret = deliver\_skb(skb, pt\_prev, orig\_dev); //就这里！arp包会调arp\_rcv()               pt\_prev = ptype;                               //        ip包会调ip\_rcv()           \}       \}       if (pt\_prev) \{            ret = pt\_prev->func(skb, skb->dev, pt\_prev, orig\_dev);       \} else \{               //下面就是数据包从协议栈返回来了           kfree\_skb(skb);    //注意这句，若skb没进入socket的接收队列，则在这里被释放           ret = NET\_RX\_DROP; //若skb进入接收队列，则系统调用取包时skb释放，这里skb引用数减一而已       \}   out:       rcu\_read\_unlock();       return ret;   \}      int deliver\_skb(struct sk\_buff \*skb,struct packet\_type \*pt\_prev, struct net\_device \*orig\_dev)\{        **atomic\_inc(&skb->users);** **//这句不容忽视，与后面流程的kfree\_skb()相呼应**       return **pt\_prev->func(skb, skb->dev, pt\_prev, orig\_dev)**;//调函数ip\_rcv() arp\_rcv()等   \}      这里只是将大致流程，arp\_rcv(), ip\_rcv() 什么的具体流程，以后再写。      **四、网络抓包tcpdump**   tcpdump也是在二层抓包的，用的是libpcap库，它的基本原理是   1.先创建socket，内核dev\_add\_packet()挂上自己的钩子函数   2.然后在钩子函数中，把skb放到自己的接收队列中，   3.接着系统调用recv取出skb来，把数据包skb->data拷贝到用户空间   4.最后关闭socket，内核dev\_remove\_packet()删除自己的钩子函数      下面是一些重要的数据结构，用到的钩子函数都在这里初始化好了   static const struct proto\_ops packet\_ops = \{        .family =    PF\_PACKET,       .owner =    THIS\_MODULE,       .release =    **packet\_release**,    //关闭socket的时候调这个       .bind =        packet\_bind,       .connect =    sock\_no\_connect,       .socketpair =    sock\_no\_socketpair,       .accept =    sock\_no\_accept,       .getname =    packet\_getname,        .poll =        packet\_poll,       .ioctl =    packet\_ioctl,       .listen =    sock\_no\_listen,       .shutdown =    sock\_no\_shutdown,       .setsockopt =    packet\_setsockopt,       .getsockopt =    packet\_getsockopt,       .sendmsg =    packet\_sendmsg,       .recvmsg =    **packet\_recvmsg,   **//socket收包的时候调这个       .mmap =        packet\_mmap,       .sendpage =    sock\_no\_sendpage,   \};      static struct net\_proto\_family packet\_family\_ops = \{        .family =    PF\_PACKET,       .create =    **packet\_create,**     //创建socket的时候调这个       .owner    =    THIS\_MODULE,   \};      至于系统调用 socket、recv、close是如何调到这些内核钩子函数的，以后再讲。这里只关注packet\_type      **4.1 系统调用socket**   libpcap系统调用socket，内核最终调用 packet\_create   static int **packet\_create**(struct net \*net, struct socket \*sock, int protocol)\{        po->prot\_hook.func = **packet\_rcv;**   //初始化钩子函数指针       po->prot\_hook.af\_packet\_priv = sk;       if (protocol) \{            po->prot\_hook.type = protocol;  //类型是系统调用socket形参指定的          ** dev\_add\_pack(&po->prot\_hook);**//关键！！           sock\_hold(sk);           po->running = 1;       \}       return(0);   \}      **4.2 钩子函数 packet\_rcv 将skb放入到接收队列**   文件 linux\_2\_6\_24/net/packet/af\_packet.c   简单来说，packet\_rcv中，skb越过了整个协议栈，直接进入队列      **4.3 系统调用recv**   系统调用recv、read、recvmsg，内核最终会调用**packet\_recvmsg**   从接收队列中取出skb，将数据包内容skb->data拷贝到用户空间      **4.4 系统调用close**   内核最终会调用packet\_release   static int **packet\_release**(struct socket \*sock)\{        struct sock \*sk = sock->sk;       struct packet\_sock \*po;       if (!sk)  return 0;       po = pkt\_sk(sk);       write\_lock\_bh(&packet\_sklist\_lock);       sk\_del\_node\_init(sk);       write\_unlock\_bh(&packet\_sklist\_lock);       // Unhook packet receive handler.       if (po->running) \{            **dev\_remove\_pack(&po->prot\_hook)**;   //就是这句！！把packet\_type从链表中删除           po->running = 0;           po->num = 0;           \_\_sock\_put(sk);       \}       packet\_flush\_mclist(sk);        // Now the socket is dead. No more input will appear.       sock\_orphan(sk);       sock->sk = NULL;       /\* Purge queues \*/       skb\_queue\_purge(&sk->sk\_receive\_queue);       sk\_refcnt\_debug\_release(sk);       sock\_put(sk);       return 0;   \}      \----------------------------------------------------------------------------------------------      搜一下内核源代码，二层协议还真是多。。。   drivers/net/wan/hdlc.c: dev\_add\_pack(&hdlc\_packet\_type);  //ETH\_P\_HDLC    hdlc\_rcv   drivers/net/wan/lapbether.c:               dev\_add\_pack(&lapbeth\_packet\_type);         //ETH\_P\_DEC       lapbeth\_rcv   drivers/net/wan/syncppp.c:               dev\_add\_pack(&sppp\_packet\_type);            //ETH\_P\_WAN\_PPP   sppp\_rcv   drivers/net/bonding/bond\_alb.c:  dev\_add\_pack(pk\_type); //ETH\_P\_ARP       rlb\_arp\_recv   drivers/net/bonding/bond\_main.c:dev\_add\_pack(pk\_type);  //PKT\_TYPE\_LACPDU bond\_3ad\_lacpdu\_recv   drivers/net/bonding/bond\_main.c:dev\_add\_pack(pt);       //ETH\_P\_ARP       bond\_arp\_rcv   drivers/net/pppoe.c: dev\_add\_pack(&pppoes\_ptype);       //ETH\_P\_PPP\_SES   pppoe\_rcv   drivers/net/pppoe.c: dev\_add\_pack(&pppoed\_ptype);       //ETH\_P\_PPP\_DISC  pppoe\_disc\_rcv   drivers/net/hamradio/bpqether.c:                       dev\_add\_pack(&bpq\_packet\_type);     //ETH\_P\_BPQ       bpq\_rcv   net/ipv4/af\_inet.c:  dev\_add\_pack(&ip\_packet\_type);     //**ETH\_P\_IP**       **ip\_rcv**   net/ipv4/arp.c:    dev\_add\_pack(&arp\_packet\_type);      //ETH\_P\_ARP       arp\_rcv   net/ipv4/ipconfig.c:  dev\_add\_pack(&rarp\_packet\_type);  //ETH\_P\_RARP      ic\_rarp\_recv   net/ipv4/ipconfig.c:  dev\_add\_pack(&bootp\_packet\_type); //ETH\_P\_IP        ic\_bootp\_recv   net/llc/llc\_core.c: dev\_add\_pack(&llc\_packet\_type);     //ETH\_P\_802\_2     llc\_rcv   net/llc/llc\_core.c: dev\_add\_pack(&llc\_tr\_packet\_type);  //ETH\_P\_TR\_802\_2  llc\_rcv   net/x25/af\_x25.c:  dev\_add\_pack(&x25\_packet\_type);    //ETH\_P\_X25      x25\_lapb\_receive\_frame   net/8021q/vlan.c:  dev\_add\_pack(&vlan\_packet\_type);     //ETH\_P\_8021Q     vlan\_skb\_recv      这些不同协议的packet\_type，有些是linux系统启动时挂上去的   比如处理ip协议的pakcet\_type，就是在 inet\_init()时挂上去的   还有些驱动模块加载的时候才加上去的。 #

[format_png]: /images/20230528/8d69cd415a9c408180872f4d14f71c28.png
[format_png 1]: http://blog.chinaunix.net/attachment/201106/27/24148050_13091454856k76.jpg
[format_png 2]: /images/20230528/6ea3c4d269cd47e380a1347b479e16e6.png
[format_png 2 1]: http://blog.chinaunix.net/attachment/201106/28/24148050_1309229916Zt09.jpg
[format_png 3]: /images/20230528/bdf49add17224f19ab4e05fda7d62684.png
[format_png 3 1]: http://blog.chinaunix.net/attachment/201106/28/24148050_1309228048B5I2.jpg
[format_png 4]: /images/20230528/e4a6d007b7ea416ab8a939a8f4914163.png
[format_png 4 1]: http://blog.chinaunix.net/attachment/201106/28/24148050_1309230046pwS1.jpg
[format_png 5]: /images/20230528/c310374bce1f449595a81d044c40d844.png
[format_png 5 1]: http://blog.chinaunix.net/attachment/201108/3/24148050_1312338439sZa0.jpg