3. 网络驱动初始化流程

网络设备驱动的初始化是驱动生命周期中最关键的阶段，它决定了设备能否被内核正确识别、资源是否充足、以及数据通路是否畅通。本章将按照驱动加载的完整时序，逐一剖析模块加载/卸载、设备探测、资源分配和 net_device 注册四个核心环节。

3.1 驱动模块加载与卸载

Linux 网络驱动通常以内核模块的形式存在，通过 module_init 和 module_exit 宏声明入口与出口函数。加载时，内核执行初始化入口；卸载时，执行清理并释放资源。

// 模块加载/卸载骨架
static int __init mydrv_init(void)
{
    printk(KERN_INFO "MyNetDrv: module loaded\n");
    // 1. 注册平台驱动或 PCI 驱动
    // 2. 探测设备
    // 3. 分配资源
    // 4. 注册 net_device
    return 0;
}

static void __exit mydrv_exit(void)
{
    printk(KERN_INFO "MyNetDrv: module unloaded\n");
    // 1. 注销 net_device
    // 2. 释放资源
    // 3. 注销驱动
}

module_init(mydrv_init);
module_exit(mydrv_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Kernel Expert");

3.2 设备探测：从总线到驱动匹配

设备探测是驱动与硬件建立联系的起点。对于 PCI 设备，驱动通过 pci_driver 结构体注册 id_table 和 probe 回调；对于平台设备，则使用 platform_driver。当总线发现设备 ID 匹配时，内核自动调用驱动的 probe 函数。

// PCI 驱动探测示例
static struct pci_device_id mydrv_pci_tbl[] = {
    { PCI_DEVICE(0x10EC, 0x8168) }, // Realtek 8168
    { 0, }
};
MODULE_DEVICE_TABLE(pci, mydrv_pci_tbl);

static int mydrv_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
    struct net_device *ndev;
    int ret;

    // 1. 启用 PCI 设备
    ret = pci_enable_device(pdev);
    if (ret)
        return ret;

    // 2. 请求 MMIO / IO 资源
    ret = pci_request_regions(pdev, DRV_NAME);
    if (ret)
        goto err_disable;

    // 3. 分配 net_device
    ndev = alloc_etherdev(sizeof(struct mydrv_priv));
    if (!ndev) {
        ret = -ENOMEM;
        goto err_release;
    }

    // 4. 设置私有数据、回调函数
    // ...

    // 5. 注册 net_device
    ret = register_netdev(ndev);
    if (ret)
        goto err_free;

    pci_set_drvdata(pdev, ndev);
    return 0;

err_free:
    free_netdev(ndev);
err_release:
    pci_release_regions(pdev);
err_disable:
    pci_disable_device(pdev);
    return ret;
}

3.3 资源分配：内存、I/O 与中断

设备探测成功后，驱动必须为数据收发准备必要的系统资源。资源分配不当是驱动崩溃和性能瓶颈的主要来源。

// 资源分配典型代码段
static int mydrv_alloc_resources(struct mydrv_priv *priv)
{
    // 1. 分配 DMA 描述符环（Tx / Rx）
    priv->tx_ring = dma_alloc_coherent(&priv->pdev->dev,
                                        TX_RING_SIZE * sizeof(struct desc),
                                        &priv->tx_ring_dma, GFP_KERNEL);
    if (!priv->tx_ring)
        return -ENOMEM;

    priv->rx_ring = dma_alloc_coherent(&priv->pdev->dev,
                                        RX_RING_SIZE * sizeof(struct desc),
                                        &priv->rx_ring_dma, GFP_KERNEL);
    if (!priv->rx_ring)
        goto err_free_tx;

    // 2. 注册中断（支持 MSI-X 优先）
    priv->irq = pci_irq_vector(priv->pdev, 0);
    if (request_irq(priv->irq, mydrv_isr, 0, DRV_NAME, priv))
        goto err_free_rx;

    // 3. 添加 NAPI
    netif_napi_add(priv->ndev, &priv->napi, mydrv_poll, 64);

    return 0;

err_free_rx:
    dma_free_coherent(&priv->pdev->dev, RX_RING_SIZE * sizeof(struct desc),
                      priv->rx_ring, priv->rx_ring_dma);
err_free_tx:
    dma_free_coherent(&priv->pdev->dev, TX_RING_SIZE * sizeof(struct desc),
                      priv->tx_ring, priv->tx_ring_dma);
    return -ENOMEM;
}

3.4 net_device 注册：驱动与内核网络栈的桥梁

net_device 是内核网络子系统对每个网络接口的抽象。驱动必须正确填充该结构体，并通过 register_netdev() 将其纳入内核管理。注册成功后，用户空间可通过 ifconfig 或 ip 命令看到该接口。

// net_device 注册完整示例
static int mydrv_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
    struct net_device *ndev;
    struct mydrv_priv *priv;
    int ret;

    // 1. 分配 net_device + 私有数据
    ndev = alloc_etherdev(sizeof(struct mydrv_priv));
    if (!ndev)
        return -ENOMEM;

    priv = netdev_priv(ndev);
    priv->ndev = ndev;
    priv->pdev = pdev;

    // 2. 填充操作函数集
    ndev->netdev_ops = &mydrv_netdev_ops;
    ndev->ethtool_ops = &mydrv_ethtool_ops;

    // 3. 设置硬件特性（支持 TSO、SG、RXCSUM）
    ndev->hw_features = NETIF_F_SG | NETIF_F_TSO | NETIF_F_RXCSUM;
    ndev->features |= ndev->hw_features;

    // 4. 设置 MAC 地址（从 EEPROM 读取）
    // eth_hw_addr_set(ndev, mac_addr);

    // 5. 注册到内核
    ret = register_netdev(ndev);
    if (ret) {
        free_netdev(ndev);
        return ret;
    }

    pci_set_drvdata(pdev, ndev);
    return 0;
}

3.5 卸载流程：逆序清理

模块卸载时，必须严格按照初始化的逆序释放所有资源。任何遗漏都会导致内核资源泄漏，严重时影响系统稳定性。

1. 注销 net_device：调用 unregister_netdev(ndev)，将接口从内核网络栈中移除。
2. 删除 NAPI：调用 netif_napi_del(&priv->napi)，清理 NAPI 上下文。
3. 释放中断：调用 free_irq(priv->irq, priv)，注销中断处理函数。
4. 释放 DMA 缓冲区：调用 dma_free_coherent() 释放描述符环和 SKB 数据区。
5. 释放 PCI 资源：调用 pci_release_regions(pdev) 和 pci_disable_device(pdev)。
6. 释放 net_device：调用 free_netdev(ndev)，回收内存。

// 模块卸载函数
static void __exit mydrv_exit(void)
{
    struct net_device *ndev = pci_get_drvdata(pdev);
    struct mydrv_priv *priv = netdev_priv(ndev);

    // 1. 注销 net_device
    unregister_netdev(ndev);

    // 2. 删除 NAPI
    netif_napi_del(&priv->napi);

    // 3. 释放中断
    free_irq(priv->irq, priv);

    // 4. 释放 DMA 缓冲区
    dma_free_coherent(&priv->pdev->dev, TX_RING_SIZE * sizeof(struct desc),
                      priv->tx_ring, priv->tx_ring_dma);
    dma_free_coherent(&priv->pdev->dev, RX_RING_SIZE * sizeof(struct desc),
                      priv->rx_ring, priv->rx_ring_dma);

    // 5. 释放 PCI 资源
    pci_release_regions(priv->pdev);
    pci_disable_device(priv->pdev);

    // 6. 释放 net_device
    free_netdev(ndev);
}

3.6 初始化流程全景图

将上述四个环节串联起来，形成完整的驱动初始化生命周期。理解这张图，就掌握了网络驱动加载的核心脉络。

3.7 常见错误与调试技巧