二十、网卡框架分析、虚拟网卡驱动和DM9621驱动分析

一、网络设备驱动的结构

网卡设备不同于字符设备和块设备， 网络设备并不对应于/dev目录下的文件，它存放在/sys/class/net目录下。

Linux系统对网络设备驱动定义了四个层次：

1. 网络协议接口层：用于实现统一的数据包收发的协议，通过dev_queue_xmit()函数发送数据， 通过netif_rx()函数接收数据

2. 网络设备接口层：通过struct net_device来描述一个具体的网络设备的信息

3. 设备驱动功能层：同于驱动网络设备实现各个功能，通过hard_start_xmit()函数发送数据，通过网络设备上的中断函数接收数据

4. 网络设备与媒介层：用于负责完成数据包发送和接收的物理实体

层次结构如下图（此图基于Linux kernel 4.0，个别函数不适用于kernel 3.5）：

在设计具体的网络设备驱动程序时，我们需要完成的主要工作是编写设备驱动功能层的函数填充struct net_device并将其注册入内核。struct net_device定义如下：

struct net_device {
    char            name[IFNAMSIZ];
...
    unsigned long        mem_end;    /* 内存结束地址        */
    unsigned long        mem_start;  /* 内存开始地址        */
    unsigned long        base_addr;  /* 内存I/O基地址    */
    unsigned int        irq;         /* 中断号            */
...
    struct net_device_stats    stats;             /* 用于保存统计信息    */

    const struct net_device_ops *netdev_ops;      /* 网络设备操作函数 */
...
    unsigned int        mtu;                      /* 最大数据包        */
    unsigned short        type;                   /* 接口硬件类型        */
    unsigned short        hard_header_len;        /* hardware hdr length，一般赋值为ETH_HLEN    */
...
    unsigned char        perm_addr[MAX_ADDR_LEN]; /* 设备MAC地址可以通过ifconfig看到 */
...
    /* Called from unregister, can be used to call free_netdev */
    void (*destructor)(struct net_device *dev);
...
};

其中，

1. struct net_device_stats定义如下：

struct net_device_stats {
    unsigned long    rx_packets;          /* 收到的数据包数 */
    unsigned long    tx_packets;          /* 发送的数据包数 */
    unsigned long    rx_bytes;            /* 收到的字节数 */
    unsigned long    tx_bytes;            /* 发送的字节数 */
    unsigned long    rx_errors;           /* 收到的错误数据包数 */
    unsigned long    tx_errors;           /* 发送的错误数据包数 */
...
};

2. struct net_device_ops定义如下：

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);
    /* 数据包发送函数，也就是图中的hard_start_xmit() */
    netdev_tx_t    (*ndo_start_xmit) (struct sk_buff *skb, struct net_device *dev);
...
    void        (*ndo_set_rx_mode)(struct net_device *dev);
    int            (*ndo_set_mac_address)(struct net_device *dev, void *addr);
...
    /* 发送超时函数 */
    void        (*ndo_tx_timeout) (struct net_device *dev);
..
    struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
...
};

在数据包发送函数中，我们可以知道数据包是struct sk_buff（socket buffer，套接字缓冲区），此结构体定义如下：

struct sk_buff {
    struct sk_buff        *next;    /* 双向链表 */
    struct sk_buff        *prev;
...
    unsigned int        len,        /* 数据包大小 */
                data_len;           /* 数据大小 */
    __u16            mac_len,       /* MAC包大小 */
                hdr_len;            /* 帧大小 */
...
    __u32            priority;      /* 优先级 */
...
    __be16            protocol;     /* 存放上层的协议类型，可通过eth_type_trans()获取 */
...
    sk_buff_data_t        transport_header;    /* 传输层头部的偏移值 */
    sk_buff_data_t        network_header;      /* 网络层头部的偏移值 */
    sk_buff_data_t        mac_header;          /* MAC数据链路层头部的偏移值 */
    /* These elements must be at the end, see alloc_skb() for details.  */
    sk_buff_data_t        tail;     /* 数据包的尾部 */
    sk_buff_data_t        end;      /* 尾部空间的尾部 */
    unsigned char        *head,     /* 头部空间的头部 */
                *data;              /* 数据包的头部 */
...
};

此结构体数据存放格式如下图：

其中头部空间用于存放协议类型，尾部空间用于存储应用层数据。数据包格式如下：

分析完了各个结构体，现在我们通过分析具体文件确定结构体的注册和初始化方式。我选用的设备驱动文件为/drivers/net/cs89x0.c。

文件链接：

https://files.cnblogs.com/files/Lioker/20_cs89x0.zip

二、网络设备驱动分析

在此不再一个一个函数分析，直接给出调用关系：

int __init cs89x0_init(void)
  -> platform_driver_probe(&cs89x0_driver, cs89x0_platform_probe);
    -> struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
      -> alloc_netdev_mqs(sizeof_priv, "eth%d", ether_setup, txqs, rxqs);
        -> setup(dev);                       /* 调用传入的ether_setup()设置net_device成员 */
        -> netif_alloc_netdev_queues(dev)    /* 分配接收队列和发送队列 */
    -> cs89x0_probe1(dev, virt_addr, );
      -> iowrite16(PP_ChipID, ioaddr + ADD_PORT);    /* 设置寄存器 */
      -> dev->netdev_ops    = &net_ops;              /* net_device操作函数 */
      -> register_netdev(dev);                       /* 注册net_device */
        -> register_netdevice(dev);
          -> netdev_register_kobject(dev);
            -> device_add(dev);

init()函数所做的有以下几点：

1. 使用alloc_etherdev()分配struct net_device

2. 设置网卡硬件相关寄存器

3. 设置struct net_device的成员

4. 使用register_netdev()注册struct net_device

接下来，我们来看net_device操作函数net_ops的数据包发送函数。

static const struct net_device_ops net_ops = {
...
    .ndo_start_xmit        = net_send_packet,
...
};

此函数调用关系如下：

static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev)
  -> netif_stop_queue(dev);      /* 停止上层传下来的数据包 */
    -> set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
  -> iowrite16(skb->len, lp->virt_addr + TX_LEN_PORT);                /* 设置寄存器，初始化传输队列 */
  -> writewords(lp, TX_FRAME_PORT, skb->data, (skb->len + ) >> );   /* 发送包 */
    -> iowrite16(tmp16, lp->virt_addr + portno);
  -> dev->stats.tx_bytes += skb->len;
  -> dev_kfree_skb(skb);        /* 释放sk_buff */

现在出现一个问题，在ndo_start_xmit()有停止函数netif_stop_queue()，但没有唤醒函数，因此我们可以在文件中搜索“netif_”查找唤醒函数。

在net_timeout()和net_interrupt()中查找到了netif_wake_queue()，net_timeout定义在net_ops中，那么net_interrupt()又是在哪里注册的呢？

经搜索后，确定net_interrupt()在net_open()中注册。

也就是数据包发送成功后，会产生中断，调用net_interrupt()唤醒上层继续传输数据包

因此，ndo_start_xmit()函数所做的有以下几点：

1. 数据包发送之前，使用netif_stop_queue()停止上层传输数据包

2. 设置寄存器，通过网络设备硬件发送数据包

3. 当数据包发送后，使用dev_kfree_skb()释放struct sk_buff

4. 当数据包发送后，会产生中断，调用net_interrupt()唤醒上层继续传输数据包并更新net_device_stats数据

5. 若数据包发送超时，会调用net_timeout()唤醒上层继续传输数据包

分析完初始化和发包过程，接下来需要分析收包过程。

收包主要通过中断函数net_interrupt()处理，函数内部判断中断类型，若为ISQ_RECEIVER_EVENT，表示为接收中断，调用net_rx()将数据包传输给上层。中断函数net_interrupt()定义如下：

 static irqreturn_t net_interrupt(int irq, void *dev_id)
 {
     struct net_device *dev = dev_id;
     struct net_local *lp;
     int status;
     int handled = ;

     lp = netdev_priv(dev);
 ...
     while ((status = ioread16(lp->virt_addr + ISQ_PORT))) {
         cs89_dbg(, debug, "%s: event=%04x\n", dev->name, status);
         handled = ;
         switch (status & ISQ_EVENT_MASK) {
         case ISQ_RECEIVER_EVENT:
             /* 接包 */
             net_rx(dev);
             break;
         case ISQ_TRANSMITTER_EVENT:
             dev->stats.tx_packets++;
             netif_wake_queue(dev);    /* 唤醒 */
             /* 更新net_device_stats数据 */
             if ((status & (TX_OK | TX_LOST_CRS | TX_SQE_ERROR | TX_LATE_COL | TX_16_COL)) != TX_OK) {
                 if ((status & TX_OK) == )
                     dev->stats.tx_errors++;
                 if (status & TX_LOST_CRS)
                     dev->stats.tx_carrier_errors++;
                 if (status & TX_SQE_ERROR)
                     dev->stats.tx_heartbeat_errors++;
                 if (status & TX_LATE_COL)
                     dev->stats.tx_window_errors++;
                 if (status & TX_16_COL)
                     dev->stats.tx_aborted_errors++;
             }
             break;
 ...
             break;
         case ISQ_RX_MISS_EVENT:
             dev->stats.rx_missed_errors += (status >> );
             break;
         case ISQ_TX_COL_EVENT:
             dev->stats.collisions += (status >> );
             break;
         }
     }
     return IRQ_RETVAL(handled);
 }

net_rx()函数调用关系如下：

net_rx(dev);
  -> skb = netdev_alloc_skb(dev, length + );    /* 分配skb_buff */
  -> skb_reserve(skb, );                        /* 将sk_buff缓冲区里的数据包向后移动2字节，留出头部空间 */
    -> skb->data += len;
    -> skb->tail += len;
  -> readwords(lp, RX_FRAME_PORT, skb_put(skb, length), length >> );    /* 读取网络设备上接收的数据。skb_put()用于扩大sk_buff的数据区，参数len表示增加的长度 */
  -> skb->data[length-] = ioread16(lp->virt_addr + RX_FRAME_PORT);      /* 将数据复制sk_buff->data地址 */
  -> skb->protocol = eth_type_trans(skb, dev);   /* 获取上层协议 */
  -> netif_rx(skb);                              /* 将sk_buff传输给上层协议 */
  -> dev->stats.rx_packets++;                    /* 更新net_device_stats数据 */
  -> dev->stats.rx_bytes += length;

net_rx()函数所做的有以下几点：

1. 使用netdev_alloc_skb()分配一个新的struct skb_buff

2. 使用skb_reserve()调整struct skb_buff空间布局

3. 通过网络设备硬件读取数据包

4. 将数据包数据复制给新的skb->data

5. 使用eth_type_trans()获取struct sk_buff的上层协议，并将数据传输给上层协议

6. 更新统计信息

整体框架如下：

其中struct ehthdr用于表示MAC head，struct iphdr用于表示IP head，两结构体在第三节中有使用。

三、虚拟网卡驱动编写过程及代码

本节开始写一个虚拟网卡驱动，此驱动不需要硬件相关操作，所以没有中断函数。我们通过Linux的ping命令来实现发包，在发包函数中伪造一个收包函数，实现ping通任何ip地址。

init()函数：

1. 使用alloc_etherdev()分配struct net_device

2. 设置struct net_device的成员

3. 使用register_netdev()注册struct net_device

发包函数：

1. 数据包发送之前，使用netif_stop_queue()停止上层传输数据包

2. 调用收包函数

3. 使用dev_kfree_skb()释放struct sk_buff

4. 更新net_device_stats数据

5. 调用netif_wake_queue()唤醒上层继续传输数据包

收包函数（部分参考《LDD3》）：

1. 对调struct sk_buff数据包中struct ethhdr的源地址（以后简称源）和目的地址（以后简称目的）

2. 对调struct sk_buff数据包中struct iphdr的源和目的

3. 使用ip_fast_csum()重新获取struct iphdr的校验码

4. 修改struct sk_buff数据包中数据类型，从发送包变成接受包

5. 使用netdev_alloc_skb()分配一个新的struct skb_buff

6. 使用skb_reserve()调整struct skb_buff空间布局

7. 将数据包数据复制给新的skb->data

8. 设置新的struct sk_buff其它成员

9. 使用eth_type_trans()获取struct sk_buff的上层协议，并将数据传输给上层协议

10.更新统计信息

虚拟网卡驱动源代码：

 #include <linux/module.h>
 #include <linux/etherdevice.h>
 #include <linux/kernel.h>
 #include <linux/in.h>
 #include <linux/skbuff.h>
 #include <linux/init.h>
 #include <linux/ip.h>

 #include <asm/system.h>
 #include <asm/io.h>

 static struct net_device *vir_dev;

 static void virtual_rx(struct sk_buff *skb, struct net_device *dev)
 {
     /* 参考LDD3 */
     unsigned char    *type;
     struct iphdr    *ih;
     __be32            *saddr, *daddr, tmp;
     unsigned char    tmp_dev_addr[ETH_ALEN];
     struct ethhdr    *ethhdr;

     struct sk_buff    *rx_skb;

     /* 对调"源/目的"的mac地址 */
     ethhdr = (struct ethhdr *)skb->data;
     memcpy(tmp_dev_addr, ethhdr->h_dest, ETH_ALEN);
     memcpy(ethhdr->h_dest, ethhdr->h_source, ETH_ALEN);
     memcpy(ethhdr->h_source, tmp_dev_addr, ETH_ALEN);

     /* 对调"源/目的"的ip地址 */
     ih = (struct iphdr *)(skb->data + sizeof(struct ethhdr));
     saddr = &ih->saddr;
     daddr = &ih->daddr;

     tmp = *saddr;
     *saddr = *daddr;
     *daddr = tmp;

     //((u8 *)saddr)[2] ^= 1; /* change the third octet (class C) */
     //((u8 *)daddr)[2] ^= 1;
     type = skb->data + sizeof(struct ethhdr) + sizeof(struct iphdr);
     //printk("tx package type = %02x\n", *type);
     /* 修改类型, 原来0x8表示发送包 */
     *type = ;        /* 0表示接受包 */

     ih->check = ;           /* and rebuild the checksum (ip needs it) */
     ih->check = ip_fast_csum((unsigned char *)ih,ih->ihl);

     /* 构造一个sk_buff */
     rx_skb = dev_alloc_skb(skb->len + );
     skb_reserve(rx_skb, ); /* align IP on 16B boundary */
     memcpy(skb_put(rx_skb, skb->len), skb->data, skb->len);

     /* Write metadata, and then pass to the receive level */
     rx_skb->dev = dev;
     rx_skb->protocol = eth_type_trans(rx_skb, dev);
     rx_skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
     dev->stats.rx_packets++;
     dev->stats.rx_bytes += skb->len;

     /* 提交sk_buff */
     netif_rx(rx_skb);
 }

 static int virtual_xmit(struct sk_buff *skb, struct net_device *dev)
 {
     static int cnt = ;
     netif_stop_queue(dev);

     /* 硬件操作 */
     cnt++;
     printk("cnt: %d\n", cnt);

     virtual_rx(skb, dev);

     dev_kfree_skb(skb);
     netif_wake_queue(dev);

     dev->stats.rx_packets++;
     dev->stats.tx_bytes += skb->len;

     return ;
 }

 static struct net_device_ops vir_dev_ops = {
     .ndo_start_xmit = virtual_xmit,
 };

 static int vir_net_init(void)
 {
     /* 1. 分配net_device */
     vir_dev = alloc_etherdev();

     /* 2. 配置 */
     vir_dev->netdev_ops = &vir_dev_ops;

     vir_dev->dev_addr[] = 0x08;
     vir_dev->dev_addr[] = 0x89;
     vir_dev->dev_addr[] = 0x89;
     vir_dev->dev_addr[] = 0x89;
     vir_dev->dev_addr[] = 0x89;
     vir_dev->dev_addr[] = 0x89;

     vir_dev->flags       |= IFF_NOARP;

     /* 3. 注册 */
     register_netdev(vir_dev);

     return ;
 }

 static void vir_net_exit(void)
 {
     unregister_netdev(vir_dev);
     free_netdev(vir_dev);
 }

 module_init(vir_net_init);
 module_exit(vir_net_exit);

 MODULE_LICENSE("GPL");

Makefile：

 KERN_DIR = /work/tiny4412/tools/linux-3.5
 #KERN_DIR = /work/jz2440/tools/linux-3.4.

 all:
     make -C $(KERN_DIR) M=`pwd` modules 

 clean:
     make -C $(KERN_DIR) M=`pwd` modules clean
     rm -rf modules.order

 obj-m    += virnet.o

测试：

在编译并在开发板上insmod后执行：

# ifconfig eth1 8.8.8.8　　/* 注意虚拟网卡的网段不能与其它网卡网段重复 */

# ifconfig　　　　　　　　 /* 可以看到产生了虚拟网卡eth1 */

# ping 8.8.8.7　　　　　　 /* 可以ping通同一网段任何IP，不同网段无法ping通 */

# ping 6.6.6.7

效果如下图：

在上一节分析完虚拟网卡后，本节我们来分析itop4412所使用的网卡——DM9621，它所对应的驱动文件为drivers/net/usb/dm9620.c。

文件链接：

https://files.cnblogs.com/files/Lioker/20_dm9620.zip

四、DM9621驱动分析

根据代码第二行的注释Davicom DM9620 USB 2.0 10/100Mbps ethernet devices，我们可以确定该网卡属于USB网卡。也就是说它会使用到usb驱动相关知识：十六、USB驱动

在我们使用usb网卡前，需要make menuconfig配置内核支持usb网卡：

Device Drivers --->
    [*] Network device support --->
        USB Network Adapters --->
            <*> Multi-purpose USB Networking Framework
            <*> Davicom DM9620 USB2. Fast Ethernet devices

在此不再一个一个函数分析，直接给出调用关系：

int __init dm9620_init(void)
  -> usb_register(&dm9620_driver);
    -> .probe = usbnet_probe,
      -> struct usb_driver *driver = to_usb_driver(udev->dev.driver);
      -> struct usb_device *xdev = interface_to_usbdev (udev);    /* 分配、设置usb相关 */
      -> net = alloc_etherdev(sizeof(*dev));     /* 分配、设置net_device */
      -> net->netdev_ops = &usbnet_netdev_ops;
      -> status = init_status (dev, udev);       /* 初始化urb */
        -> pipe = usb_rcvintpipe (dev->udev, dev->status->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
        -> dev->interrupt = usb_alloc_urb (, GFP_KERNEL);
        -> usb_fill_int_urb(dev->interrupt, dev->udev, pipe, buf, maxp, intr_complete, dev, period);
      -> status = register_netdev (net);         /* 注册net_device */
      -> netif_device_attach (net);
        -> netif_tx_wake_all_queues(dev);        /* 唤醒net传输 */
      -> netif_carrier_off(net);                 /* 添加延时队列 */
        -> linkwatch_schedule_work(urgent);
          -> schedule_delayed_work(&linkwatch_work, delay)

其中，需要注意的是net->netdev_ops = &usbnet_netdev_ops;，通过这段代码可以确定dm9621驱动使用的是通用的usb网卡设备操作函数。

probe()函数所做的有以下几点：

1. 获取端点描述符

2. 在usb上建立net_device

3. 添加延时队列

根据网卡分析顺序，现在我们来看数据包发送函数：

static const struct net_device_ops usbnet_netdev_ops = {
...
    .ndo_start_xmit        = usbnet_start_xmit,
...
};

usbnet_start_xmit
  -> urb = usb_alloc_urb (, GFP_ATOMIC)              /* 分配新的urb并填充 */
  -> sb_fill_bulk_urb (urb, dev->udev, dev->out, skb->data, skb->len, tx_complete, skb);
  -> switch ((retval = usb_submit_urb (urb, GFP_ATOMIC)))    /* 提交urb */
    -> case -EPIPE:                    /* 如果没有管道 */
      -> netif_stop_queue (net);       /* 停止上层数据传输 */
      -> usbnet_defer_kevent (dev, EVENT_TX_HALT);    /* 唤醒工作队列 */
        -> schedule_work (&dev->kevent)               /* 唤醒延时队列处理数据 */
  /* 传输完成会调用sb_fill_bulk_urb()注册的tx_complete() */
  -> tx_complete()
    -> dev->net->stats.tx_packets++;        /* 更新数据 */
    -> dev->net->stats.tx_bytes += entry->length;
    -> (void) defer_bh(dev, skb, &dev->txq, tx_done);
      -> __skb_queue_tail(&dev->done, skb); /* 把skb放到传输队列中 */
      -> tasklet_schedule(&dev->bh);        /* 调用中断底半部 */
        -> usbnet_bh
          -> case tx_done:
            -> usb_free_urb (entry->urb);   /* 释放urb和skb */
            -> dev_kfree_skb (skb);

发送函数分配urb，将skb数据传给urb，通过urb发送数据。

分析完初始化和发包过程，接下来需要分析收包过程。

由于上层使用dev调用，我们很难通过上一章的方式确定收包函数。我们需要换一种方式：当我们执行ifconfig usb0 up命令时，open()函数被调用，其调用过程如下：

usbnet_open
  -> retval = usb_submit_urb (dev->interrupt, GFP_KERNEL);    /* 提交urb */
  -> netif_start_queue (net);                /* 启动延时队列 */
  -> tasklet_schedule (&dev->bh);            /* 调用中断底半部 */
    -> usbnet_bh
      -> rx_alloc_submit(dev, GFP_ATOMIC);
        -> urb = usb_alloc_urb(, flags);    /* 分配urb */
        -> rx_submit(dev, urb, flags)        /* 接收urb数据 */
  /* 传输完成后会进入case rx_done: */
  -> case rx_done:
    -> entry->state = rx_cleanup;
    -> rx_process (dev, skb);                /* 更新统计信息 */
  -> case rx_cleanup:
    -> usb_free_urb (entry->urb);
    -> dev_kfree_skb (skb);

当有数据时，收包函数通过调用中断底半部函数创建urb接收数据，并更新统计信息。

下一章  二十一、RTC驱动