Linux kernel 帧的接收

Linux kernel 帧的接收

本文以e1000驱动为例，基于3.10.0-514.10.2版本内核。

---

驱动注册 - e1000_init_module

[root@10-254-0-111 ~]# modprobe e1000  #插入e1000模块
    或者
[root@10-254-0-111 ~]# insmod /path/to/e1000.ko   #insmod后面指定e1000.ko文件路径

上面的操作对应的实现代码如下：

/*** drivers/net/ethernet/intel/e1000/e1000_main.c ***/

 //该e1000驱动对应的pci驱动实例
 static struct pci_driver e1000_driver = {
        .name     = e1000_driver_name, //e1000驱动程序名称，默认e1000
        .id_table = e1000_pci_tbl,     //该驱动程序所支持的网卡设备列表
        .probe    = e1000_probe,       //设备初始化函数，当PCI子系统检测到该驱动所支持的设备被插入到总线上时，调用该函数对设备进行初始化操作。
        .remove   = e1000_remove,      //移除设备时（热插拔或驱动程序被移除时）调用该函数
#ifdef CONFIG_PM //电源管理
        /* Power Management Hooks */
        .suspend  = e1000_suspend,     //系统休眠时调用
        .resume   = e1000_resume,      //系统被唤醒时调用
#endif                  
        .shutdown = e1000_shutdown,    //系统关闭时调用
        .err_handler = &e1000_err_handler //错误处理器
};

/**
 * e1000_init_module - 驱动注册函数
 *
 * e1000_init_module is the first routine called when the driver is
 * loaded. All it does is register with the PCI subsystem.
 **/
static int __init e1000_init_module(void)
{
    int ret;
    pr_info("%s - version %s\n", e1000_driver_string, e1000_driver_version);

    pr_info("%s\n", e1000_copyright);

    /* 注册pci驱动 - 把e1000驱动程序以pci_driver形式注册到pci子系统中 */
    ret = pci_register_driver(&e1000_driver);
    if (copybreak != COPYBREAK_DEFAULT) {
        if (copybreak == 0)
            pr_info("copybreak disabled\n");
        else
            pr_info("copybreak enabled for "
                   "packets <= %u bytes\n", copybreak);
    }
    return ret;
}

module_init(e1000_init_module);

pci_register_driver() 注册的是驱动程序，是把驱动程序安装到内核，准确的说是安装到内核的PCI子系统中。此时还没有设备出现，但是内核已经具备管理e1000设备的能力。

设备发现和初始化 - e1000_probe

刚刚我们通过e1000_init_module()把e1000驱动程序注册到PCI子系统，这样当有e1000设备插入到PCI总线的时候，PCI子系统就可以发现该设备，并调用之前注册的函数e1000_probe()对设备进行初始化

/*** drivers/net/ethernet/intel/e1000/e1000_main.c ***/

/* 设备的操作函数 */
static const struct net_device_ops e1000_netdev_ops = {
        .ndo_open               = e1000_open,   //打开设备
        .ndo_stop               = e1000_close,   //关闭设备
        .ndo_start_xmit         = e1000_xmit_frame,
        .ndo_get_stats          = e1000_get_stats,
        .ndo_set_rx_mode        = e1000_set_rx_mode,
        .ndo_set_mac_address    = e1000_set_mac,
        .ndo_tx_timeout         = e1000_tx_timeout,
        .ndo_change_mtu         = e1000_change_mtu,
        .ndo_do_ioctl           = e1000_ioctl,
        .ndo_validate_addr      = eth_validate_addr,
        .ndo_vlan_rx_add_vid    = e1000_vlan_rx_add_vid,
        .ndo_vlan_rx_kill_vid   = e1000_vlan_rx_kill_vid,
#ifdef CONFIG_NET_POLL_CONTROLLER
        .ndo_poll_controller    = e1000_netpoll,
#endif
        .ndo_fix_features       = e1000_fix_features,
        .ndo_set_features       = e1000_set_features,
};

/**
 * e1000_probe - 设备初始化函数
 * @pdev: PCI device information struct
 * @ent: entry in e1000_pci_tbl
 *
 * Returns 0 on success, negative on failure
 *
 * e1000_probe initializes an adapter identified by a pci_dev structure.
 * The OS initialization, configuring of the adapter private structure,
 * and a hardware reset occur.
 **/
static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
    struct net_device *netdev;
    struct e1000_adapter *adapter;   //设备私有数据
    struct e1000_hw *hw;

    ...

    err = -ENOMEM;
    /* 为设备分配net_device结构体 */
    netdev = alloc_etherdev(sizeof(struct e1000_adapter));
    if (!netdev)
        goto err_alloc_etherdev;

    ...

    /* 设置设备的私有数据 */
    adapter = netdev_priv(netdev);
    adapter->netdev = netdev;
    adapter->pdev = pdev;
    adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
    adapter->bars = bars;
    adapter->need_ioport = need_ioport;

    ...

    /* 设置设备的操作函数 */
    netdev->netdev_ops = &e1000_netdev_ops;
    e1000_set_ethtool_ops(netdev);

    /**
     * 初始化该设备的napi，用于下半部接收数据；
     * 该函数初始化napi字段，并把napi注册到全局napi_hash表中。
     **/
    netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);

    /* 设置设备名称 */
    strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);

    ...

    /* 初始化延时任务，如看门狗任务 */
    INIT_DELAYED_WORK(&adapter->watchdog_task, e1000_watchdog);
    INIT_DELAYED_WORK(&adapter->fifo_stall_task,
              e1000_82547_tx_fifo_stall_task);
    INIT_DELAYED_WORK(&adapter->phy_info_task, e1000_update_phy_info_task);
    INIT_WORK(&adapter->reset_task, e1000_reset_task);

    ...

    /* reset the hardware with the new settings */
    e1000_reset(adapter);

    strcpy(netdev->name, "eth%d");

    /* 注册网络设备net_device */
    err = register_netdev(netdev);
    if (err)
        goto err_register;

    ...
}

开启设备 - e1000_open

当使用用户空间工具（如ifconfig、iproute）开启网络设备时，PCI子系统就会调用函数e1000_open()

/*** drivers/net/ethernet/intel/e1000/e1000_main.c ***/

/**
 * e1000_open - Called when a network interface is made active
 * @netdev: network interface device structure
 *
 * Returns 0 on success, negative value on failure
 *
 * The open entry point is called when a network interface is made
 * active by the system (IFF_UP).  At this point all resources needed
 * for transmit and receive operations are allocated, the interrupt
 * handler is registered with the OS, the watchdog task is started,
 * and the stack is notified that the interface is ready.
 **/
static int e1000_open(struct net_device *netdev)
{
    struct e1000_adapter *adapter = netdev_priv(netdev);
    struct e1000_hw *hw = &adapter->hw;
    int err;

    /* disallow open during test */
    if (test_bit(__E1000_TESTING, &adapter->flags))
        return -EBUSY;

    netif_carrier_off(netdev);

    /* allocate transmit descriptors */
    err = e1000_setup_all_tx_resources(adapter);
    if (err)
        goto err_setup_tx;

    /* allocate receive descriptors */
    err = e1000_setup_all_rx_resources(adapter);
    if (err)
        goto err_setup_rx;

    e1000_power_up_phy(adapter);

    adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
    if ((hw->mng_cookie.status &
              E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
        e1000_update_mng_vlan(adapter);
    }

    /* before we allocate an interrupt, we must be ready to handle it.
     * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt
     * as soon as we call pci_request_irq, so we have to setup our
     * clean_rx handler before we do so.
     */
    e1000_configure(adapter);

    //注册中断请求，中断处理函数为e1000_intr
    err = e1000_request_irq(adapter);
    if (err)
        goto err_req_irq;

    /* From here on the code is the same as e1000_up() */
    clear_bit(__E1000_DOWN, &adapter->flags);

    napi_enable(&adapter->napi);

    e1000_irq_enable(adapter);

    netif_start_queue(netdev);

    /**
     * fire a link status change interrupt to start the watchdog，
     * 触发链路状态变更中断，启动看门狗
    **/
    ew32(ICS, E1000_ICS_LSC);

    return E1000_SUCCESS;

err_req_irq:
    e1000_power_down_phy(adapter);
    e1000_free_all_rx_resources(adapter);
err_setup_rx:
    e1000_free_all_tx_resources(adapter);
err_setup_tx:
    e1000_reset(adapter);

    return err;
}

设备中断 - e1000_intr

当网卡接收到数据就会发出中断请求（IRQ），对应的中断处理函数就是e1000_intr()，该函数运行在中断上下文中，不可休眠。

/*** drivers/net/ethernet/intel/e1000/e1000_main.c ***/

/**
 * e1000_intr - Interrupt Handler
 * @irq: interrupt number
 * @data: pointer to a network interface device structure
 **/
static irqreturn_t e1000_intr(int irq, void *data)
{
    struct net_device *netdev = data;
    struct e1000_adapter *adapter = netdev_priv(netdev);
    struct e1000_hw *hw = &adapter->hw;
    u32 icr = er32(ICR);

    if (unlikely((!icr)))
        return IRQ_NONE;  /* Not our interrupt */

    /* we might have caused the interrupt, but the above
     * read cleared it, and just in case the driver is
     * down there is nothing to do so return handled
     */
    if (unlikely(test_bit(__E1000_DOWN, &adapter->flags)))
        return IRQ_HANDLED;

    if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
        hw->get_link_status = 1;
        /* guard against interrupt when we're going down */
        if (!test_bit(__E1000_DOWN, &adapter->flags)){
            //启动看门狗任务
            schedule_delayed_work(&adapter->watchdog_task, 1);
        }
    }

    /* disable interrupts, without the synchronize_irq bit */
    ew32(IMC, ~0);
    E1000_WRITE_FLUSH();

    if (likely(napi_schedule_prep(&adapter->napi))) {
        adapter->total_tx_bytes = 0;
        adapter->total_tx_packets = 0;
        adapter->total_rx_bytes = 0;
        adapter->total_rx_packets = 0;

        /**
         * 调度接收
         * 1、把napi加入到cpu的softnet_data.poll_list
         * 2、触发软中断（softirq）NET_RX_SOFTIRQ 准备接收数据
        **/
        __napi_schedule(&adapter->napi);
    } else {
        /* this really should not happen! if it does it is basically a
         * bug, but not a hard error, so enable ints and continue
         */
        if (!test_bit(__E1000_DOWN, &adapter->flags))
            e1000_irq_enable(adapter);
    }

    return IRQ_HANDLED;
}

下半部处理 - 软中断

设备初始化完毕并开启后，就进入就绪状态，当有数据到达网卡就触发中断（硬件中断），内核执行对应的中断处理程序（中断处理程序是上半部，要简短、迅速），当执行完中断处理程序后内核触发NET_RX_SOFTIRQ软中断，进行下半部处理，NET_RX_SOFTIRQ对应的软中断处理函数是net_rx_action()，注册的地方是在系统初始化时：

/*** drivers/net/ethernet/intel/e1000/e1000_main.c ***/

static int __init net_dev_init(void)
{
        int i, rc = -ENOMEM;

        BUG_ON(!dev_boot_phase);

        ...

        open_softirq(NET_TX_SOFTIRQ, net_tx_action);
        open_softirq(NET_RX_SOFTIRQ, net_rx_action); //注册网络收包的软中断处理函数

        hotcpu_notifier(dev_cpu_callback, 0);
        dst_subsys_init();
        rc = 0;
        ...
}

net_rx_action()函数

/*** net/core/dev.c ***/

static void net_rx_action(struct softirq_action *h)
{
        //获取当前CPU的softnet_data数据
        struct softnet_data *sd = this_cpu_ptr(&softnet_data);

        //设置处理时限
        unsigned long time_limit = jiffies + 2;
        //设置此次最大处理包数
        int budget = netdev_budget;

        LIST_HEAD(list);
        LIST_HEAD(repoll);

        local_irq_disable();

        //把poll_list连接到list上，然后把poll_list清空（把poll_list中的napi缓存到list中）
        list_splice_init(&sd->poll_list, &list);
        local_irq_enable();

        //对list中的napi循环处理
        for (;;) {
                struct napi_struct *n;

                if (list_empty(&list)) {
                        if (!sd_has_rps_ipi_waiting(sd) && list_empty(&repoll))
                                return;
                        break;
                }

                n = list_first_entry(&list, struct napi_struct, poll_list);
                /**
                 * 调用napi->poll函数从设备接收数据，poll函数是由设备驱动程序提供，并在
                 * 设备初始化时通过netif_napi_add()函数放到设备的private data中。
                 * poll函数从硬件中读取数据然后通过napi_gro_receive()函数把skb发送到
                 * 网络协议栈做进一步处理。
                **/
                budget -= napi_poll(n, &repoll);

                /* If softirq window is exhausted then punt.
                 * Allow this to run for 2 jiffies since which will allow
                 * an average latency of 1.5/HZ.
                 */
                if (unlikely(budget <= 0 ||
                             time_after_eq(jiffies, time_limit))) {
                        sd->time_squeeze++;
                        break;
                }
        }

        __kfree_skb_flush();
        local_irq_disable();

        //把未完成的napi加入到CPU全局poll_list中，待下次处理软中断时再次处理
        list_splice_tail_init(&sd->poll_list, &list);
        list_splice_tail(&repoll, &list);
        list_splice(&list, &sd->poll_list);

        //poll_list非空，此次处理超过时限或超过最大处理包数，重新出发软中断进行处理。
        if (!list_empty(&sd->poll_list))
                __raise_softirq_irqoff(NET_RX_SOFTIRQ);

        net_rps_action_and_irq_enable(sd);
}

看门狗

看门狗是用来检测设备状态的，在e1000_open()中启动。

/**
 * e1000_watchdog - work function
 * @work: work struct contained inside adapter struct
 **/
static void e1000_watchdog(struct work_struct *work)
{
    struct e1000_adapter *adapter = container_of(work,
                             struct e1000_adapter,
                             watchdog_task.work);
    struct e1000_hw *hw = &adapter->hw;
    struct net_device *netdev = adapter->netdev;
    struct e1000_tx_ring *txdr = adapter->tx_ring;
    u32 link, tctl;

    link = e1000_has_link(adapter);
    //链路已激活并有载波->链路状态正常，去更新统计数据
    if ((netif_carrier_ok(netdev)) && link)
        goto link_up;

    if (link) {
        if (!netif_carrier_ok(netdev)) {
            //链路已激活但是没有载波，检测到设备启动
            u32 ctrl;
            bool txb2b = true;
            /* update snapshot of PHY registers on LSC */
            e1000_get_speed_and_duplex(hw,
                           &adapter->link_speed,
                           &adapter->link_duplex);

            ctrl = er32(CTRL);
            pr_info("%s NIC Link is Up %d Mbps %s, "
                "Flow Control: %s\n",
                netdev->name,
                adapter->link_speed,
                adapter->link_duplex == FULL_DUPLEX ?
                "Full Duplex" : "Half Duplex",
                ((ctrl & E1000_CTRL_TFCE) && (ctrl &
                E1000_CTRL_RFCE)) ? "RX/TX" : ((ctrl &
                E1000_CTRL_RFCE) ? "RX" : ((ctrl &
                E1000_CTRL_TFCE) ? "TX" : "None")));

            /* adjust timeout factor according to speed/duplex */
            adapter->tx_timeout_factor = 1;
            switch (adapter->link_speed) {
            case SPEED_10:
                txb2b = false;
                adapter->tx_timeout_factor = 16;
                break;
            case SPEED_100:
                txb2b = false;
                /* maybe add some timeout factor ? */
                break;
            }

            /* enable transmits in the hardware */
            tctl = er32(TCTL);
            tctl |= E1000_TCTL_EN;
            ew32(TCTL, tctl);

            netif_carrier_on(netdev);
            if (!test_bit(__E1000_DOWN, &adapter->flags))
                schedule_delayed_work(&adapter->phy_info_task,
                              2 * HZ);
            adapter->smartspeed = 0;
        }
    } else {
        if (netif_carrier_ok(netdev)) {
            //链路未激活但有载波，检测到设备关闭
            adapter->link_speed = 0;
            adapter->link_duplex = 0;
            pr_info("%s NIC Link is Down\n",
                netdev->name);
            netif_carrier_off(netdev);

            if (!test_bit(__E1000_DOWN, &adapter->flags))
                schedule_delayed_work(&adapter->phy_info_task,
                              2 * HZ);
        }

        e1000_smartspeed(adapter);
    }

link_up:
    e1000_update_stats(adapter);

    hw->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
    adapter->tpt_old = adapter->stats.tpt;
    hw->collision_delta = adapter->stats.colc - adapter->colc_old;
    adapter->colc_old = adapter->stats.colc;

    adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old;
    adapter->gorcl_old = adapter->stats.gorcl;
    adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old;
    adapter->gotcl_old = adapter->stats.gotcl;

    e1000_update_adaptive(hw);

    if (!netif_carrier_ok(netdev)) {
        if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
            /* We've lost link, so the controller stops DMA,
             * but we've got queued Tx work that's never going
             * to get done, so reset controller to flush Tx.
             * (Do the reset outside of interrupt context).
             */
            adapter->tx_timeout_count++;
            schedule_work(&adapter->reset_task);
            /* exit immediately since reset is imminent */
            return;
        }
    }

    /* Simple mode for Interrupt Throttle Rate (ITR) */
    if (hw->mac_type >= e1000_82540 && adapter->itr_setting == 4) {
        /* Symmetric Tx/Rx gets a reduced ITR=2000;
         * Total asymmetrical Tx or Rx gets ITR=8000;
         * everyone else is between 2000-8000.
         */
        u32 goc = (adapter->gotcl + adapter->gorcl) / 10000;
        u32 dif = (adapter->gotcl > adapter->gorcl ?
                adapter->gotcl - adapter->gorcl :
                adapter->gorcl - adapter->gotcl) / 10000;
        u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;

        ew32(ITR, 1000000000 / (itr * 256));
    }

    /* Cause software interrupt to ensure rx ring is cleaned */
    ew32(ICS, E1000_ICS_RXDMT0);

    /* Force detection of hung controller every watchdog period */
    adapter->detect_tx_hung = true;

    /* Reschedule the task 2HZ后再次调用看门狗检测设备状态*/
    if (!test_bit(__E1000_DOWN, &adapter->flags)){
        schedule_delayed_work(&adapter->watchdog_task, 2 * HZ);
    }
}

欢迎交流学习！