网络数据包收发流程(一)：从驱动到协议栈-凯发app官方网站

早就想整理网络数据包收发流程了，一直太懒没动笔。今天下决心写了

一、硬件环境

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 相关数据结构

每个网络设备（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等数据结构应该是下面这个样子的

六、中断里接收以太网包

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;
    }