数据包接收系列 — 上半部实现（网卡驱动）

本文主要内容：网络数据包接收的上半部实现，主要分析网卡驱动相关部分。

内核版本：2.6.37

Author：zhangskd @ csdn blog

 

网卡概述

 

(1) 网卡收包

网线上的物理帧首先被网卡芯片获取，网卡芯片会检查物理帧的CRC，保证完整性。

然后网卡芯片将物理帧头去掉，得到MAC包。

网卡芯片会检查MAC包内的目的MAC地址，如果和本网卡的MAC地址不一样则丢弃(混杂模式除外)。

之后网卡芯片将MAC帧拷贝到网卡内部的缓冲区，触发硬中断。

网卡的驱动程序通过硬中断处理函数，构建sk_buff，把它拷贝到内存中，接下来交给内核处理。

在这个过程中，网卡芯片对物理帧进行了MAC匹配过滤，以减小系统负荷。

 

(2) 网卡发包

网卡驱动程序将IP包添加14字节的MAC头，构成MAC包。

MAC包中含有发送端和接收端的MAC地址，由于是驱动程序创建MAC头，所以可以随便输入地址

进行主机伪装。

驱动程序将MAC包拷贝到网卡芯片内部的缓冲区，接下来由网卡芯片处理。

网卡芯片将MAC包再次封装为物理帧，添加头部同步信息和CRC校验，然后丢到网线上，就完成

一个IP报的发送了，所有接到网线上的网卡都可以看到该物理帧。

 

(3) 网卡数据结构

网卡用net_device来表示，用register_netdevice()注册到系统中，注册过的网卡可以通过

unregister_netdevice()注销掉。

struct net_device {
    char name[IFNAME]; /* 网卡名称，如eth0 */
    ...
    unsigned long mem_end; /* shared mem end，共享内存结束地址 */
    unsigned long mem_start; /* shared mem start ，共享内存起始地址 */
    unsigned long base_addr; /* device I/O address，设备内存映射到I/O内存的起始地址 */
    unsigned int irq; /* device IRQ number，硬中断编号 */
    ...
    unsigned long state; /* 网卡的状态 */
    ...
    struct list_head dev_list;
    struct list_head napi_list; /* NAPI使用 */
    ...
    unsigned long features; /* 网卡功能标识 */
    ...
    int ifindex; /* Interface index. Unique device identifier. 设备ID */
    ...
    struct net_device_stats stats; /* 统计变量 */
    /* dropped packets by core network.
     * Do not use this in drivers.
     * 被内核丢弃的数据包个数。
     */
    atomic_long_t rx_dropped;
    ...
    /* Management operations */
    const struct net_device_ops *netdev_ops; /* 网卡的操作函数集 */
    const struct ethtool_ops *ethtool_ops; /* 配置网卡 */
    ...
    unsigned int promiscuity; /* 混杂模式计数器 */
    ...
    struct netdev_queue *ingress_queue;
    struct netdev_queue *_tx;
    ...
};

/* 网卡的操作函数集 */
struct net_device_ops {
    int (*ndo_init) (struct net_device *dev);
    void (*ndo_uninit) (struct net_device *dev);
    int (*ndo_open) (struct net_device *dev);
    int (*ndo_stop) (struct net_device *dev);
    /* Called when a packet needs to be transmitted */
    netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb, struct net_device *dev);
    ...
};

 

(4) 网卡中断处理函数

产生中断的每个设备都有一个相应的中断处理程序，是设备驱动程序的一部分。

每个网卡都有一个中断处理程序，用于通知网卡该中断已经被接收了，以及把网卡缓冲区的

数据包拷贝到内存中。

当网卡接收来自网络的数据包时，需要通知内核数据包到了。网卡立即发出中断：嗨，内核，

我这里有最新的数据包了。内核通过执行网卡已注册的中断处理函数来做出应答。

中断处理程序开始执行，通知硬件，拷贝最新的网络数据包到内存，然后读取网卡更多的数据包。

这些都是重要、紧迫而又与硬件相关的工作。内核通常需要快速的拷贝网络数据包到系统内存，

因为网卡上接收网络数据包的缓存大小固定，而且相比系统内存也要小得多。所以上述拷贝动作

一旦被延迟，必然造成网卡缓存溢出 - 进入的数据包占满了网卡的缓存，后续的包只能被丢弃。

当网络数据包被拷贝到系统内存后，中断的任务算是完成了，这时它把控制权交还给被系统中断

前运行的程序。处理和操作数据包的其他工作在随后的下半部中进行。

 

上半部的实现

 

接收数据包的上半部处理流程为：

el_interrupt() // 网卡驱动

    |--> el_receive() // 网卡驱动

                |--> netif_rx() // 内核接口

                           |--> enqueue_to_backlog() // 内核接口

 

这里以3c501网卡驱动为例来进行分析（这是个古董级网卡，实现简单：）

 

el_interrupt

 

3c501的网卡中断处理函数为el_interrupt()，调用inb()来获取当前中断处理结果，如果是RX_GOOD，

表明网卡成功接收了数据包，则调用el_receive()来进行接收处理。

/**
 * el_interrupt:
 * @irq: Interrupt number
 * @dev_id: The 3c501 that burped
 */

static irqreturn_t el_interrupt(int irq, void *dev_id)
{
    struct net_device *dev = dev_id;
    struct net_local *lp;
    int ioaddr;
    int axsr; /* Aux. status reg. */

    ioaddr = dev->base_addr; /* I/O映射地址 */
    lp = netdev_priv(dev); /* 网卡的私有数据 */
    spin_lock(&lp->lock); /* 上锁 */

    /* What happened? */
    axsr = inb(AX_STATUS);

    /* log it */
    if (el_debug > 3)
        pr_debug("%s: el_interrupt() aux = %#02x\n", dev->name, axsr);
    if (lp->loading == 1 && ! lp->txing)
        pr_warning("%s: Inconsistent state loading while not in tx\n", dev->name);

    if (lp->txing) { /* 处于发送模式，这里不研究 */
        /* Board in transmit mode. */
        ...

    } else {
        /* In receive mode. 处于接收模式 */
        int rxsr = inb(RX_STATUS); /* 获取中断处理的结果 */
        if (el_debug > 5)
            pr_debug("%s: rxsr=%02x txsr=%02x rp=%04x\n", dev->name, rxsr,
                inb(TX_STATUS), inw(RX_LOW));

        /* Just reading rx_status fixes most errors. */
        if (rxsr & RX_MISSED) /* 没有接收到数据包 */
            dev->stats.rx_missed_errors++;
        else if (rxsr & RX_RUNT) { /* 数据包长度错误 */
            /* Handled to avoid board lock-up. */
            dev->stats.rx_length_errors++;
            if (el_debug > 5)
                pr_debug("%s: runt.\n", dev->name);

        } else if (rxsr & RX_GOOD) {
            /* Receive worked, 成功接收数据包 */
            el_receive(dev); /* 接收函数 */

        } else {
            /* Nothing? Something is broken! */
            if (el_debug > 2)
                pr_debug("%s: No packet seen, rxsr=%02x **resetting 3c501***\n", dev->name, rxsr);

            el_reset(dev); /* 网卡出错，重置 */
        }
    }

    /* Move into receive mode */
    outb(AX_RX, AX_CMD);
    outw(0x00, RX_BUF_CLR);
    inb(RX_STATUS);
    inb(TX_STATUS);
    spin_unlock(&lp->lock);
out:
    return IRQ_HANDLED;
}

 

网卡的私有数据

/* Board-specific info in netdev_priv(dev). */
struct net_local {
    int tx_pkt_start; /* The length of the current Tx packet. */
    int collisions; /* Tx collisions this packet */
    int loading; /* Spot buffer load collisions */
    int txing; /* True if card is in TX mode */
    spinlock_t lock; /* Serializing lock */
};

/**
 * netdev_priv - access network device private data
 * @dev: network device
 * Get network device private data
 */
static inline void *netdev_priv(const struct net_device *dev)
{
    return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
}

 

el_receive

 

el_receive()首先申请一个sk_buff，然后把网卡缓冲区中的数据包拷贝到skb->data。

调用eth_type_trans()来判断数据包使用的三层协议(skb->protocol)、数据包的类型(skb->pkt_type)。

最后调用内核入口函数 — netif_rx()继续处理。

/**
 * el_receive:
 * @dev: Device to pull the packets from
 *
 * We have a good packet. Well, not really "good", just mostly not broken.
 * We must check everything to see if it is good. In particular we occasionally
 * get wild packet sizes from the card. If the packet seems sane we PIO it off
 * the card and queue it for the protocol layers.
 */ 

static void el_receive(struct net_device *dev)
{
    int ioaddr = dev->base_addr;
    int pkt_len;
    struct sk_buff *skb;

    pkt_len = inw(RX_LOW);
    if (el_debug > 4)
        pr_debug("el_receive %d.\n", pkt_len);

    if (pkt_len < 60 || pkt_len > 1536) { /* 数据包长度错误 */
        if (el_debug)
            pr_debug("%s: bogus packet, length=%d\n", dev->name, pkt_len);
        dev->stats.rx_over_errors++;
        return;
    }

    /* Command mode so we can empty the buffer */
    outb(AX_SYS, AX_CMD);

    skb = dev_alloc_skb(pkt_len + 2); /* 申请一个skb，2字节用于对齐IP */

    /* Start of frame */
    outw(0x00, GP_LOW);

    if (skb == NULL) {
        pr_info("%s: Memory squeeze, dropping packet.\n", dev->name);
        dev->stats.rx_dropped++;
        return;

    } else {
        /* 因为mac头是14字节，预留2字节可使IP以16字节对齐 */
        skb_reserve(skb, 2); 

        /* 扩展skb的data room，并把网卡缓存的数据包拷贝到skb->data中 */
        insb(DATAPORT, skb_put(skb, pkt_len), pkt_len);

        /* 使用哪种三层协议，一般是IP协议 */
        skb->protocol = eth_type_trans(skb, dev);

        netif_rx(skb); /* 旧的接收处理函数 */

        dev->stats.rx_packets++;
        dev->stats.rx_bytes += pkt_len;
    }

}

 

以太网协议头

#define ETH_ALEN 6 /* Octets in one ethernet addr */
#define ETH_HLEN 14 /* Total octects in header */

struct ethhdr {
    unsigned char h_dest[ETH_ALEN]; /* destination eth addr */
    unsigned char h_source[ETH_ALEN]; /* source ether addr */
    unsigned short h_proto; /* packet type ID field */
};

eth_type_trans()进行二层协议的简单处理，主要是判断数据包的类型(skb->pkt_type)

是单播/广播/多播，返回三层协议类型(skb->protocol)，一般是IP协议。

/**
 * eth_type_trans - determine the packet's protocol ID.
 * @skb: received socket data
 * @dev: receiving network device
 * The rule here is that we assume 802.3 if the type field is short enough to be a length.
 * This is normal practice and works for any now in use protocol.
 */

__be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev)
{
    struct ethhdr *eth;
    skb->dev = dev; /* 记录接收网卡设备 */
    skb_reset_mac_header(skb); /* 赋值skb->mac_header */

    /* skb->data指向三层协议头，skb->len -= 14 */
    skb_pull_inline(skb, ETH_HLEN);
    eth = eth_hdr(skb);

    /* 记录数据包类型skb->pkt_type */  
    if (unlikely(is_multicast_ether_addr(eth->h_dest))) { /* 是否为多播 */
        if (! compare_ether_addr_64bits(eth->h_dest, dev->broadcast)) /* 是否为广播 */
            skb->pkt_type = PACKET_BROADCAST;
        else
            skb->pkt_type = PACKET_MULTICAST;

    } else if (unlikely(compare_ether_addr_64bits(eth->h_dest, dev->dev_addr)))
        skb->pkt_type = PACKET_OTHERHOST; /* 其它网卡的 */

    /* 判断使用的三层协议 */
    if (netdev_uses_dsa_tags(dev))
        return htons(ETH_P_DSA);
    if (netdev_uses_trailer_tags(dev))
        return htons(ETH_P_TRAILER);

    if (ntohs(eth->h_proto) >= 1536) /* 大于1536即为协议ID */
        return eth->h_proto;

    if (skb->len >= 2 && *(unsigned short *)(skb->data) == 0xFFFF)
        return htons(ETH_P_802_3);
    return htons(ETH_P_802_2);
}