一、网络设备驱动的结构
网卡设备不同于字符设备和块设备， 网络设备并不对应于/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, 0); -> 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 + 1) >> 1); /* 发送包 */ -> 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()定义如下：
1 static irqreturn_t net_interrupt(int irq, void *dev_id) 2 { 3 struct net_device *dev = dev_id; 4 struct net_local *lp; 5 int status; 6 int handled = 0; 7 8 lp = netdev_priv(dev); 9 ... 10 while ((status = ioread16(lp->virt_addr + ISQ_PORT))) { 11 cs89_dbg(4, debug, "%s: event=%04x\n", dev->name, status); 12 handled = 1; 13 switch (status & ISQ_EVENT_MASK) { 14 case ISQ_RECEIVER_EVENT: 15 /* 接包 */ 16 net_rx(dev); 17 break; 18 case ISQ_TRANSMITTER_EVENT: 19 dev->stats.tx_packets++; 20 netif_wake_queue(dev); /* 唤醒 */ 21 /* 更新net_device_stats数据 */ 22 if ((status & (TX_OK | TX_LOST_CRS | TX_SQE_ERROR | TX_LATE_COL | TX_16_COL)) != TX_OK) { 23 if ((status & TX_OK) == 0) 24 dev->stats.tx_errors++; 25 if (status & TX_LOST_CRS) 26 dev->stats.tx_carrier_errors++; 27 if (status & TX_SQE_ERROR) 28 dev->stats.tx_heartbeat_errors++; 29 if (status & TX_LATE_COL) 30 dev->stats.tx_window_errors++; 31 if (status & TX_16_COL) 32 dev->stats.tx_aborted_errors++; 33 } 34 break; 35 ... 36 break; 37 case ISQ_RX_MISS_EVENT: 38 dev->stats.rx_missed_errors += (status >> 6); 39 break; 40 case ISQ_TX_COL_EVENT: 41 dev->stats.collisions += (status >> 6); 42 break; 43 } 44 } 45 return IRQ_RETVAL(handled); 46 }
net_rx()函数调用关系如下：
net_rx(dev); -> skb = netdev_alloc_skb(dev, length + 2); /* 分配skb_buff */ -> skb_reserve(skb, 2); /* 将sk_buff缓冲区里的数据包向后移动2字节，留出头部空间 */ -> skb->data += len; -> skb->tail += len; -> readwords(lp, RX_FRAME_PORT, skb_put(skb, length), length >> 1); /* 读取网络设备上接收的数据。skb_put()用于扩大sk_buff的数据区，参数len表示增加的长度 */ -> skb->data[length-1] = 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.更新统计信息
虚拟网卡驱动源代码：
1 #include <linux/module.h> 2 #include <linux/etherdevice.h> 3 #include <linux/kernel.h> 4 #include <linux/in.h> 5 #include <linux/skbuff.h> 6 #include <linux/init.h> 7 #include <linux/ip.h> 8 9 #include <asm/system.h> 10 #include <asm/io.h> 11 12 static struct net_device *vir_dev; 13 14 static void virtual_rx(struct sk_buff *skb, struct net_device *dev) 15 { 16 /* 参考LDD3 */ 17 unsigned char *type; 18 struct iphdr *ih; 19 __be32 *saddr, *daddr, tmp; 20 unsigned char tmp_dev_addr[ETH_ALEN]; 21 struct ethhdr *ethhdr; 22 23 struct sk_buff *rx_skb; 24 25 /* 对调"源/目的"的mac地址 */ 26 ethhdr = (struct ethhdr *)skb->data; 27 memcpy(tmp_dev_addr, ethhdr->h_dest, ETH_ALEN); 28 memcpy(ethhdr->h_dest, ethhdr->h_source, ETH_ALEN); 29 memcpy(ethhdr->h_source, tmp_dev_addr, ETH_ALEN); 30 31 /* 对调"源/目的"的ip地址 */ 32 ih = (struct iphdr *)(skb->data + sizeof(struct ethhdr)); 33 saddr = &ih->saddr; 34 daddr = &ih->daddr; 35 36 tmp = *saddr; 37 *saddr = *daddr; 38 *daddr = tmp; 39 40 //((u8 *)saddr)[2] ^= 1; /* change the third octet (class C) */ 41 //((u8 *)daddr)[2] ^= 1; 42 type = skb->data + sizeof(struct ethhdr) + sizeof(struct iphdr); 43 //printk("tx package type = %02x\n", *type); 44 /* 修改类型, 原来0x8表示发送包 */ 45 *type = 0; /* 0表示接受包 */ 46 47 ih->check = 0; /* and rebuild the checksum (ip needs it) */ 48 ih->check = ip_fast_csum((unsigned char *)ih,ih->ihl); 49 50 /* 构造一个sk_buff */ 51 rx_skb = dev_alloc_skb(skb->len + 2); 52 skb_reserve(rx_skb, 2); /* align IP on 16B boundary */ 53 memcpy(skb_put(rx_skb, skb->len), skb->data, skb->len); 54 55 /* Write metadata, and then pass to the receive level */ 56 rx_skb->dev = dev; 57 rx_skb->protocol = eth_type_trans(rx_skb, dev); 58 rx_skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */ 59 dev->stats.rx_packets++; 60 dev->stats.rx_bytes += skb->len; 61 62 /* 提交sk_buff */ 63 netif_rx(rx_skb); 64 } 65 66 static int virtual_xmit(struct sk_buff *skb, struct net_device *dev) 67 { 68 static int cnt = 0; 69 netif_stop_queue(dev); 70 71 /* 硬件操作 */ 72 cnt++; 73 printk("cnt: %d\n", cnt); 74 75 virtual_rx(skb, dev); 76 77 dev_kfree_skb(skb); 78 netif_wake_queue(dev); 79 80 dev->stats.rx_packets++; 81 dev->stats.tx_bytes += skb->len; 82 83 return 0; 84 } 85 86 static struct net_device_ops vir_dev_ops = { 87 .ndo_start_xmit = virtual_xmit, 88 }; 89 90 static int vir_net_init(void) 91 { 92 /* 1. 分配net_device */ 93 vir_dev = alloc_etherdev(0); 94 95 /* 2. 配置 */ 96 vir_dev->netdev_ops = &vir_dev_ops; 97 98 vir_dev->dev_addr[0] = 0x08; 99 vir_dev->dev_addr[1] = 0x89; 100 vir_dev->dev_addr[2] = 0x89; 101 vir_dev->dev_addr[3] = 0x89; 102 vir_dev->dev_addr[4] = 0x89; 103 vir_dev->dev_addr[5] = 0x89; 104 105 vir_dev->flags |= IFF_NOARP; 106 107 /* 3. 注册 */ 108 register_netdev(vir_dev); 109 110 return 0; 111 } 112 113 static void vir_net_exit(void) 114 { 115 unregister_netdev(vir_dev); 116 free_netdev(vir_dev); 117 } 118 119 module_init(vir_net_init); 120 module_exit(vir_net_exit); 121 122 MODULE_LICENSE("GPL");
Makefile：
1 KERN_DIR = /work/tiny4412/tools/linux-3.5 2 #KERN_DIR = /work/jz2440/tools/linux-3.4.2 3 4 all: 5 make -C $(KERN_DIR) M=`pwd` modules 6 7 clean: 8 make -C $(KERN_DIR) M=`pwd` modules clean 9 rm -rf modules.order 10 11 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.0 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 (0, 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 (0, 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(0, 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驱动