1. 总线、设备和驱动
1.1 简单介绍
Linux设备模型中三个很重要的概念就是总线、设备和驱动，即bus，device和driver。它们分别对应的数据结构分别为struct bus_type，struct device和struct device_driver。
总线是处理器与一个或多个设备之间的通道，在设备模型中，所有的设备都通过总线相连。在最底层，Linux系统中的每一个设备都用device结构的一个实例来表示。而驱动则是使总线上的设备能够完成它应该完成的功能。
在系统中有多种总线，如PCI总线、SCSI总线等。系统中的多个设备和驱动是通过总线让它们联系起来的。==在bus_type中两个很重要的成员就是 struct kset drivers和struct kset devices。它分别代表了连接在这个总线上的两个链，一个是设备链表，另一个则是设备驱动链表。==也就是说，通过一个总线描述符，就可以找到挂载到这条 总线上的设备，以及支持该总线的不同的设备驱动程序。
1.2 总线、设备与驱动的绑定
在系统启动时，它会对每种类型的总线创建一个描述符，并将使用该总线的设备链接到该总线描述符的devices链上来。也即是说在系统初始化时，它会扫描 连接了哪些设备，并且为每个设备建立一个struce device变量，然后将该变量链接到这个设备所连接的总线的描述符上去。另一方面，每当加载了一个设备驱动，则系统也会准备一个struct device_driver结构的变量，然后再将这个变量也链接到它所在总线的描述符的drivers链上去。
对于设备来说，在结构体struct device中有两个重要的成员，一个是struct bus_type *bus，另一个是struct device_driver *driver。bus成员就表示该设备是链接到哪一个总线上的，而driver成员就表示当前设备是由哪个驱动程序所驱动的。对于驱动程序来说，在结构 体struct device_driver中也有两个成员，struct bus_type *bus和struct list_head devices，这里的bus成员也是指向这个驱动是链接到哪个总线上的，而devices这个链表则是表示当前这个驱动程序可以去进行驱动的那些设备。 一个驱动程序可以支持一个或多个设备，而一个设备则只会绑定给一个驱动程序。
对于device与device_driver之间建立联系的方式，主要有两种方式。第一种，在计算机启动的时候，总线开始扫描连接在其上的设备，为每个 设备建立一个struct device变量并链接到该总线的devices链上，然后开始初始化不同的驱动程序，驱动程序到它所在的总线的devices链上去遍历每一个还没有被 绑定给某个驱动的设备，然后再查看是否能够支持这种设备，如果它能够支持这种设备，则将这个设备与这个驱动联系起来。即，将这个设备的device变量加 到驱动的devices链上，同时让struct device中的device_driver指向当前这个驱动。第二种则是热插拔。也即是在系统运行时插入了设备，此时内核会去查找在该bus链上注册了 的device_driver，然后再将设备与驱动联系起来。设备与驱动根据什么规则联系起来，它们是如何被联系起来的代码我们将在后面的章节进行详细的 描述。
1.3 PCI总线
PCI是一种在CPU与I/O设备之间进行高速数据传输的一种总线。有很多设备都是使用PCI总线的，网卡就是其中之一。我们在前面讲了那些总线、设备与 驱动方面的知识，原因就在于网卡是连接到PCI总线上，所以PCI总线、网卡设备以及网卡驱动就成了我们研究网卡的一个很重要的线索，尤其是在网络的链路 层部分。下图显示了在一个系统中PCI设备的一个框图：
PCI子系统声明了一个bus_type结构，为pci_bus_type。它就是PCI总线的描述符。在这个变量上，链接了PCI设备以及支持PCI设备的驱动程序。
1.4 PCI设备与驱动
PCI设备通常由一组参数唯一地标识，它们被vendorID，deviceID和class nodes所标识，即设备厂商，型号等，这些参数保存在pci_device_id结构中。每个PCI设备都会被分配一个pci_dev变量，内核就用这 个数据结构来表示一个PCI设备。
所有的PCI驱动程序都必须定义一个pci_driver结构变量，在该变量中包含了这个PCI驱动程序所提供的不同功能的函数，同时，在这个结构中也包 含了一个device_driver结构，这个结构定义了PCI子系统与PCI设备之间的接口。在注册PCI驱动程序时，这个结构将被初始化，同时这个 pci_driver变量会被链接到pci_bus_type中的驱动链上去。
在pci_driver中有一个成员struct pci_device_id *id_table，它列出了这个设备驱动程序所能够处理的所有PCI设备的ID值。
1.5 PCI设备与驱动的绑定过程
下面描述一下对于PCI设备与驱动绑定的过程。首先在系统启动的时候，PCI总线会去扫描连接到这个总线上的设备，同时为每一个设备建立一个 pci_dev结构，在这个结构中有一个device成员，并将这些pci_dev结构链接到PCI总线描述符上的devices链。如下图所示：
第二步是当PCI驱动被加载时，pci_driver结构体将被初始化，这一过程在函数pci_register_driver中：
drv->driver.bus = &pci_bus_type;
drv->driver.probe = pci_device_probe;
最后会调用driver_register(&drv->driver)将这个PCI驱动挂载到总线描述符的驱动链上。同时在注册的过程 中，会根据pci_driver中的id_table中的ID值去查看该驱动支持哪些设备，将这些设备挂载到pci_driver中的devices链中 来。如下图所示：
对于不同的设备，可能驱动程序也不一样，因此，对于上图中的Dev3，可能就需要另外一个驱动程序来对其进行驱动。所以当加载了Dev3的驱动程序时，其示意图如下图所示：
上面这三个示意图就描述了总线、设备以及驱动在系统中是如何进行相互联系的。前面对于驱动注册这些函数的描述较为简单，因为网卡是一个PCI设备，因此在后面具体地讲到网卡注册时再来详细地讲解和PCI相关的注册等函数。
2. 网卡在PCI层的注册
2.1 数据结构
前面第一章讲了总线、设备以及驱动方面的关系，也讲到了大多数网卡设备实际上是一个PCI设备。因此，本章就讲解网卡设备在注册时是如何注册到PCI总线上去的。在这里，以Intel的E100网卡驱动进行讲解。
前面讲到每个PCI设备都由一组参数唯一地标识，这些参数保存在结构体pci_device_id中，如下所示：
struct pci_device_id {
__u32 vendor, device; /* Vendor and device ID or PCI_ANY_ID*/
__u32 subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
__u32 class, class_mask; /* (class,subclass,prog-if) triplet */
kernel_ulong_t driver_data; /* Data private to the driver */
};
每个PCI设备驱动都有一个pci_driver变量，它描述了一个PCI驱动的信息，如下所示：
struct pci_driver {
struct list_head node;
char *name;
const struct pci_device_id *id_table; /* must be non-NULL for probe to be called */
int (*probe) (struct pci_dev *dev, const struct pci_device_id *id); /* New device inserted */
void (*remove) (struct pci_dev *dev); /* Device removed (NULL if not a hot-plug capable driver) */
int (*suspend) (struct pci_dev *dev, pm_message_t state); /* Device suspended */
int (*suspend_late) (struct pci_dev *dev, pm_message_t state);
int (*resume_early) (struct pci_dev *dev);
int (*resume) (struct pci_dev *dev); /* Device woken up */
int (*enable_wake) (struct pci_dev *dev, pci_power_t state, int enable); /* Enable wake event */
void (*shutdown) (struct pci_dev *dev);
struct pci_error_handlers *err_handler;
struct device_driver driver;
struct pci_dynids dynids;
int multithread_probe;
};
每个PCI驱动中都有一个id_table成员变量，记录了当前这个驱动所能够进行驱动的那些设备的ID值。
对于E100网卡驱动来说，它的pci_driver变量定义为：
static struct pci_driver e100_driver = {
.name = DRV_NAME,
.id_table = e100_id_table,
.probe = e100_probe,
.remove = __devexit_p(e100_remove),
#ifdef CONFIG_PM
/* Power Management hooks */
.suspend = e100_suspend,
.resume = e100_resume,
#endif
.shutdown = e100_shutdown,
.err_handler = &e100_err_handler,
};
里面e100_id_table就表示该E100驱动所能够支持的PCI设备的ID号，其定义为：
#define INTEL_8255X_ETHERNET_DEVICE(device_id, ich) {\
PCI_VENDOR_ID_INTEL, device_id, PCI_ANY_ID, PCI_ANY_ID, \
PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00, ich }
static struct pci_device_id e100_id_table[] = {
INTEL_8255X_ETHERNET_DEVICE(0x1029, 0),
INTEL_8255X_ETHERNET_DEVICE(0x1030, 0),
…
{ 0, }
};
当PCI层检测到一个PCI设备能够被某PCI驱动所支持时（这是通过函数pci_match_one_device来进行检测的），就会调用这个PCI驱动上的probe函数，在该函数中会对该特定的PCI设备进行一些具体的初始化等操作。比如对于E100设备驱动来说，其probe函数为e100_probe。在这个函数中，会对网卡设备进行初始化。
e100_probe主要就涉及到网卡设备net_device的初始化，我们现在先来关注一下从网卡注册一直到调用e100_probe这一个过程的整个流程。
2.2 E100初始化
E100驱动程序的初始化是在函数e100_init_module()中的，如下：
static int __init e100_init_module(void)
{
if(((1 << debug) - 1) & NETIF_MSG_DRV) {
printk(KERN_INFO PFX "%s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
printk(KERN_INFO PFX "%s\n", DRV_COPYRIGHT);
}
return pci_register_driver(&e100_driver);
}
在这个函数中，调用了pci_register_driver()函数，对e100_driver这个驱动进行注册。
Linux网络设备驱动程序体系结构
从上到下：网络协议接口层–>网络设备结构层–>设备驱动实现层–>网络设备与媒介层
记忆方法：
分三层，1、最上面理解为我们用的网络传输方法，就是网络协议，2、最下面就是物理硬件，即网络设备层，3、中间是一层，设备驱动，然后拆成2部分，上部分是结构（层），下部分是结构中函数的实现（层）。
功能描述：
网络协议接口层
dev_queue_xmit() 发送数据， netif_rx() 接收数据。
网络设备结构层
有一个结构net_device
设备驱动实现层
net_device里的函数实现， 通过hard_start_xmit()启动发送操作，通过中断触发接收操作。
网络设备与媒介层
哪里管的了那么多，不理它硬件怎么实现的。
网络协议接口层
有一个NB的结构体:sk_buff，叫做：套接字缓冲区，各层之间数据传输都靠他。
dev_queue_xmit()、netif_rx()的参数都是只是sk_buff。
函数原型：
dev_queue_xmit(struct sk_buff *sb ); //sb实际是 skb，少写一个k助记
netif_rx(struct sk_buff sk_buff *sb); //同上
sk_buff 内容详解
1 协议头 ，有好多好多协议要使用，所以协议头是必要滴，当然不能同时使用TCP/IP UDP或者其他什么协议，所以把头结构定义成联合体。
2 数据缓冲区：要搞个地方放数据，要功能强大必须能找到各需要的位置比如：头、尾… 所以在sk_buff中定义了4个指针：head、 data、tail、end。指向数据缓冲区。
head：缓冲区起始地址，sk_buff 一旦创建，head数据就固定了。
data：当前层的有效数据起始地址
tail： 有效数据的结尾地址，和data对应
end：缓冲区的结尾地址，sk_buff 一旦创建，end数据就固定了。
3 长度信息
len:数据包有效数据长度，包括协议头和负载（Payload？）
data_len:记录分片的数据长度,数据包的有效数据是分成几片存在不同的内存空间中，每片空间最大是一页。
truesize：缓冲区的整体长度，即：sizeof(struct sk_buff)+（传入alloc_sdb()或dev_alloc_skb()函数的长度）–说实话不理解传入函数的长度是什么.
NB的结构体:sk_buff的操作
各层之间就靠他，当然需要对他进行操作。
Ø 分配：
struct sk_buff *alloc_skb(unsigned int len,int priority);
分配一个套接字缓冲区（sk_buff）和一个数据缓冲区，参数len为数据缓冲区的空间大小。16字节对齐， priority是内存分配的优先级。
struct sk_buff *dev_alloc_skb(unsigned int len);
用这个函数优先级就确定了–FGP_ATOMIC:代表分配过程中不能被中断。
会调用alloc_skb()函数，并保存skb->head和sdk_data 之间的16个字节。
分配完成后, skb_buff的 data、tail指针都指向存储空间的起始地址head,而len的大小是0。
Ø 释放
就是释放alloc_skb()分配的套接字缓冲区，和数据缓冲区。
linux专用：
void kree_skb(struct sk_buff *skb)；
网络设备驱动程序用：
非中断上下文专用：void dev_kree_skb(struct sk_buff *skb);
中断上下文转用：void dev_kree_skb_irq(strcut sk_buff *skb);
中断非中断上下文都可用：void dev_kree_skb_any(struct sk_buff *skb);
Ø 指针移动
sk_buff中的数据缓冲区指针操作有: put、push、 pull、reserve。
put操作：
往数据缓冲区尾部添加可以存储网络数据包的空间。
unsigned char *skb_put(struct sk_buff *skb , unsigned int len); // 会检测放入的数据
unsigned char *__skb_put(同上)； //不检查
上述函数使tail指针下移，增加sk_buff中的len值，并返回skb_tail的值。
push操作：
往数据缓冲区头部增加一段可以存储网络数据包的空间。主要用于在数据包发送时添加头部。
unsigned char *skb_push(struct sk_buff *skb , unsigned int len); // 会检测放入的数据
unsigned char *__skb_push(同上)； //不检查
会使data指针上移，也增加len的值。
pull操作：
用于下层协议向上层协议移交数据包，使data指针指向上一层协议的协议头。
unsigned char *skb_pull(struct sk_buff *skb , unsigned int len);
会将data指针下移，并减小skb的len值。
reserve操作：
主要用于在存储空间的头部预留len长度的空隙。
void skb_reserve(struct sk_buff *skb , unsigned int len);
会使data指针和tail指针同时下移。
skb_buff的操作过程绝大部分由linux内核完成，驱动工程师只需要完成数据链路层部分工作。下面搞个例子加深理解！
补充协议头设定：
sk_buff中定义了3个协议头用于网络协议的不同层次，传输层TCP/IP协议头:h，网络层协议头：nh，链路层协议头mac,前面说了，这三个头都各定义成联合体。
网卡接收到一个UDP数据包，Linux从下到上处理的流程：1、2、3、4。
skb->mac.raw在步骤1到位，指向的位置就不变了，其他头指针也是这样。skb->nh.raw在步骤2到位，skb->h.raw在步骤3到位。每次pull到上一层，data指向就移到上面一层数据开始的地方，然后len减掉previous(避免中文歧义)的那层的头长度。
流程：
1、创建一个sk_buff结构体和数据缓冲区，将收到的数据复制到data指向的空间，skb->mac.raw指向数据， 有效数据的开始位子是一个以太网头，skb->mac.raw指向链路层的以太网头部。
2、用pull传到网络层之后，以太网协议头被剥掉了，skb->data指向下移到IP头了，len也减掉链路层头部那个长度skb_nh.raw指向data，即IP头部。
3、用pull传到传输层，剥掉IP头，data指针继续向下移，len长度再减掉ip头长度，skb_h.raw指向UDP头部。
4、应用程序调用recv()接收数据时，从skb->data+sizeof(struct udphdr)的位置开始复制到应用层缓冲区，所以,UDP头得以幸存，没有被剥掉.
snull源码：
1. #include <linux/config.h>
2. #include <linux/module.h>
3. #include <linux/init.h>
4. #include <linux/moduleparam.h>
5.
6. #include <linux/sched.h>
7. #include <linux/kernel.h> /* printk() */
8. #include <linux/slab.h> /* kmalloc() */
9. #include <linux/errno.h> /* error codes */
10. #include <linux/types.h> /* size_t */
11. #include <linux/interrupt.h> /* mark_bh */
12.
13. #include <linux/in.h>
14. #include <linux/netdevice.h> /* struct device, and other headers */
15. #include <linux/etherdevice.h> /* eth_type_trans */
16. #include <linux/ip.h> /* struct iphdr */
17. #include <linux/tcp.h> /* struct tcphdr */
18. #include <linux/skbuff.h>
19.
20. #include "snull.h"
21.
22. #include <linux/in6.h>
23. #include <asm/checksum.h>
24.
25. MODULE_AUTHOR("Alessandro Rubini, Jonathan Corbet");
26. MODULE_LICENSE("Dual BSD/GPL");
27.
28.
29. /*
30. * Transmitter lockup simulation, normally disabled.
31. */
32. static int lockup = 0;
33. module_param(lockup, int, 0);
34.
35. static int timeout = SNULL_TIMEOUT;
36. module_param(timeout, int, 0);
37.
38. /*
39. * Do we run in NAPI mode?
40. */
41. static int use_napi = 0;
42. module_param(use_napi, int, 0);
43.
44.
45. /*
46. * A structure representing an in-flight packet.
47. */
48. struct snull_packet {
49. struct snull_packet *next;
50. struct net_device *dev;
51. int datalen;
52. u8 data[ETH_DATA_LEN];
53. };
54.
55. int pool_size = 8;
56. module_param(pool_size, int, 0);
57.
58. /*
59. * This structure is private to each device. It is used to pass
60. * packets in and out, so there is place for a packet
61. */
62.
63. struct snull_priv {
64. struct net_device_stats stats;
65. int status;
66. struct snull_packet *ppool;
67. struct snull_packet *rx_queue; /* List of incoming packets */
68. int rx_int_enabled;
69. int tx_packetlen;
70. u8 *tx_packetdata;
71. struct sk_buff *skb;
72. spinlock_t lock;
73. };
74.
75. static void snull_tx_timeout(struct net_device *dev);
76. static void (*snull_interrupt)(int, void *, struct pt_regs *);
77.
78. /*
79. * 设置设备的包缓冲池.
80. * 当需要使用NAPI，而非中断处理的时候，设备需要能够保存多个数据包的能力，这个保存所需的缓存，
81. * 或者在板卡上，或者在内核的DMA环中。
82. * 作者这里的演示程序，根据pool_size的大小，分配pool_size个大小为struct snull_packet的缓冲区，
83. * 这个缓冲池用链表组织，“私有数据”结构的ppool成员指针指向链表首部。
84. */
85. void snull_setup_pool(struct net_device *dev)
86. {
87. struct snull_priv *priv = netdev_priv(dev);
88. int i;
89. struct snull_packet *pkt;
90.
91. priv->ppool = NULL;
92. for (i = 0; i < pool_size; i++) {
93. pkt = kmalloc (sizeof (struct snull_packet), GFP_KERNEL);
94. if (pkt == NULL) {
95. printk (KERN_NOTICE "Ran out of memory allocating packet pool\n");
96. return;
97. }
98. pkt->dev = dev;
99. pkt->next = priv->ppool;
100. priv->ppool = pkt;
101. }
102. }
103.
104. /*因为snull_setup_pool分配了pool_size个struct snull_packet，所以，驱动退出时，需要释放内存*/
105. void snull_teardown_pool(struct net_device *dev)
106. {
107. struct snull_priv *priv = netdev_priv(dev);
108. struct snull_packet *pkt;
109.
110. while ((pkt = priv->ppool)) {
111. priv->ppool = pkt->next;
112. kfree (pkt);
113. /* FIXME - in-flight packets ? */
114. }
115. }
116.
117. /*
118. * 获取设备要传输的第一个包，传输队列首部相应的移动到下一个数据包.
119. */
120. struct snull_packet *snull_get_tx_buffer(struct net_device *dev)
121. {
122. struct snull_priv *priv = netdev_priv(dev);
123. unsigned long flags;
124. struct snull_packet *pkt;
125.
126. spin_lock_irqsave(&priv->lock, flags);
127. pkt = priv->ppool;
128. priv->ppool = pkt->next;
129. if (priv->ppool == NULL) {
130. printk (KERN_INFO "Pool empty\n");
131. netif_stop_queue(dev);
132. }
133. spin_unlock_irqrestore(&priv->lock, flags);
134. return pkt;
135. }
136.
137. /*将包缓存交还给缓存池*/
138. void snull_release_buffer(struct snull_packet *pkt)
139. {
140. unsigned long flags;
141. struct snull_priv *priv = netdev_priv(pkt->dev);
142.
143. spin_lock_irqsave(&priv->lock, flags);
144. pkt->next = priv->ppool;
145. priv->ppool = pkt;
146. spin_unlock_irqrestore(&priv->lock, flags);
147. if (netif_queue_stopped(pkt->dev) && pkt->next == NULL)
148. netif_wake_queue(pkt->dev);
149. }
150.
151. /*将要传输的包加入到设备dev的传输队列首部，当然，这只是一个演示，这样一来，就变成先进先出了*/
152. void snull_enqueue_buf(struct net_device *dev, struct snull_packet *pkt)
153. {
154. unsigned long flags;
155. struct snull_priv *priv = netdev_priv(dev);
156.
157. spin_lock_irqsave(&priv->lock, flags);
158. pkt->next = priv->rx_queue; /* FIXME - misorders packets */
159. priv->rx_queue = pkt;
160. spin_unlock_irqrestore(&priv->lock, flags);
161. }
162.
163. /*取得传输队列中的第一个数据包*/
164. struct snull_packet *snull_dequeue_buf(struct net_device *dev)
165. {
166. struct snull_priv *priv = netdev_priv(dev);
167. struct snull_packet *pkt;
168. unsigned long flags;
169.
170. spin_lock_irqsave(&priv->lock, flags);
171. pkt = priv->rx_queue;
172. if (pkt != NULL)
173. priv->rx_queue = pkt->next;
174. spin_unlock_irqrestore(&priv->lock, flags);
175. return pkt;
176. }
177.
178. /*
179. * 打开/关闭接收中断.
180. */
181. static void snull_rx_ints(struct net_device *dev, int enable)
182. {
183. struct snull_priv *priv = netdev_priv(dev);
184. priv->rx_int_enabled = enable;
185. }
186.
187.
188. /*
189. * 设备打开函数，是驱动最重要的函数之一，它应该注册所有的系统资源（I/O端口，IRQ、DMA等等），
190. * 并对设备执行其他所需的设置。
191. * 因为这个例子中，并没有真正的物理设备，所以，它最重要的工作就是启动传输队列。
192. */
193.
194. int snull_open(struct net_device *dev)
195. {
196. /* request_region(), request_irq(), .... (like fops->open) */
197.
198. /*
199. * Assign the hardware address of the board: use "\0SNULx", where
200. * x is 0 or 1. The first byte is '\0' to avoid being a multicast
201. * address (the first byte of multicast addrs is odd).
202. */
203. memcpy(dev->dev_addr, "\0SNUL0", ETH_ALEN);
204. if (dev == snull_devs[1])
205. dev->dev_addr[ETH_ALEN-1]++; /* \0SNUL1 */
206. netif_start_queue(dev);
207. return 0;
208. }
209.
210. /*设备停止函数，这里的工作就是停止传输队列*/
211. int snull_release(struct net_device *dev)
212. {
213. /* release ports, irq and such -- like fops->close */
214.
215. netif_stop_queue(dev); /* can't transmit any more */
216. return 0;
217. }
218.
219. /*
220. * 当用户调用ioctl时类型为SIOCSIFMAP时，如使用ifconfig，系统会调用驱动程序的set_config 方法。
221. * 用户会传递一个ifmap结构包含需要设置的I/O地址、中断等参数。
222. */
223. int snull_config(struct net_device *dev, struct ifmap *map)
224. {
225. if (dev->flags & IFF_UP) /* 不能设置一个正在运行状态的设备 */
226. return -EBUSY;
227.
228. /* 这个例子中，不允许改变 I/O 地址*/
229. if (map->base_addr != dev->base_addr) {
230. printk(KERN_WARNING "snull: Can't change I/O address\n");
231. return -EOPNOTSUPP;
232. }
233.
234. /* 允许改变 IRQ */
235. if (map->irq != dev->irq) {
236. dev->irq = map->irq;
237. /* request_irq() is delayed to open-time */
238. }
239.
240. /* ignore other fields */
241. return 0;
242. }
243.
244. /*
245. * 接收数据包函数
246. * 它被“接收中断”调用，重组数据包，并调用函数netif_rx进一步处理。
247. * 我们从“硬件”中收到的包，是用struct snull_packet来描述的，但是内核中描述一个包，是使用
248. * struct sk_buff（简称skb），所以，这里要完成一个把硬件接收的包拷贝至内核缓存skb的一个
249. * 组包过程(PS：不知在接收之前直接分配一个skb，省去这一步，会如何提高性能，没有研究过，见笑了^o^)。
250. */
251. void snull_rx(struct net_device *dev, struct snull_packet *pkt)
252. {
253. struct sk_buff *skb;
254. struct snull_priv *priv = netdev_priv(dev);
255.
256. /*
257. * 分配skb缓存
258. */
259. skb = dev_alloc_skb(pkt->datalen + 2);
260. if (!skb) { /*分配失败*/
261. if (printk_ratelimit())
262. printk(KERN_NOTICE "snull rx: low on mem - packet dropped\n");
263. priv->stats.rx_dropped++;
264. goto out;
265. }
266. /*
267. * skb_reserver用来增加skb的date和tail，因为以太网头部为14字节长，再补上两个字节就刚好16字节边界
268. * 对齐，所以大多数以太网设备都会在数据包之前保留2个字节。
269. */
270. skb_reserve(skb, 2); /* align IP on 16B boundary */
271. memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);
272.
273. skb->dev = dev; /*skb与接收设备就关联起来了，它在网络栈中会被广泛使用，没道理不知道数据是谁接收来的吧*/
274. skb->protocol = eth_type_trans(skb, dev); /*获取上层协议类型，这样，上层处理函数才知道如何进一步处理*/
275. skb->ip_summed = CHECKSUM_UNNECESSARY; /* 设置较验标志：不进行任何校验，作者的驱动的收发都在内存中进行，是没有必要进行校验*/
276.
277. /*累加计数器*/
278. priv->stats.rx_packets++;
279. priv->stats.rx_bytes += pkt->datalen;
280.
281. /*
282. * 把数据包交给上层。netif_rx会逐步调用netif_rx_schedule -->__netif_rx_schedule，
283. * __netif_rx_schedule函数会调用__raise_softirq_irqoff(NET_RX_SOFTIRQ);触发网络接收数据包的软中断函数net_rx_action。
284. * 软中断是Linux内核完成中断推后处理工作的一种机制，请参考《Linux内核设计与实现》第二版。
285. * 唯一需要提及的是，这个软中断函数net_rx_action是在网络系统初始化的时候(linux/net/core/dev.c)：注册的
286. * open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
287. */
288. netif_rx(skb);
289. out:
290. return;
291. }
292.
293.
294. /*
295. * NAPI 的poll轮询函数.
296. */
297. static int snull_poll(struct net_device *dev, int *budget)
298. {
299. /*
300. * dev->quota是当前CPU能够从所有接口中接收数据包的最大数目，budget是在
301. * 初始化阶段分配给接口的weight值，轮询函数必须接受二者之间的最小值。表示
302. * 轮询函数本次要处理的数据包个数。
303. */
304. int npackets = 0, quota = min(dev->quota, *budget);
305. struct sk_buff *skb;
306. struct snull_priv *priv = netdev_priv(dev);
307. struct snull_packet *pkt;
308.
309. /*这个循环次数由要处理的数据包个数，并且，以处理完接收队列为上限*/
310. while (npackets < quota && priv->rx_queue) {
311. /*从队列中取出数据包*/
312. pkt = snull_dequeue_buf(dev);
313.
314. /*接下来的处理，和传统中断事实上是一样的*/
315. skb = dev_alloc_skb(pkt->datalen + 2);
316. if (! skb) {
317. if (printk_ratelimit())
318. printk(KERN_NOTICE "snull: packet dropped\n");
319. priv->stats.rx_dropped++;
320. snull_release_buffer(pkt);
321. continue;
322. }
323. skb_reserve(skb, 2); /* align IP on 16B boundary */
324. memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);
325. skb->dev = dev;
326. skb->protocol = eth_type_trans(skb, dev);
327. skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
328.
329. /*需要调用netif_receive_skb而不是net_rx将包交给上层协议栈*/
330. netif_receive_skb(skb);
331.
332. /*累加计数器 */
333. npackets++;
334. priv->stats.rx_packets++;
335. priv->stats.rx_bytes += pkt->datalen;
336. snull_release_buffer(pkt);
337. }
338. /* If we processed all packets, we're done; tell the kernel and reenable ints */
339. *budget -= npackets;
340. dev->quota -= npackets;
341.
342. //
343. if (! priv->rx_queue) {
344. netif_rx_complete(dev);
345. snull_rx_ints(dev, 1);
346. return 0;
347. }
348. /* We couldn't process everything. */
349. return 1;
350. }
351.
352.
353. /*
354. * 设备的中断函数，当需要发/收数据，出现错误，连接状态变化等，它会被触发
355. * 对于典型的网络设备，一般会在open函数中注册中断函数，这样，当网络设备产生中断时，如接收到数据包时，
356. * 中断函数将会被调用。不过在这个例子中，因为没有真正的物理设备，所以，不存在注册中断，也就不存在触
357. * 发，对于接收和发送，它都是在自己设计的函数的特定位置被调用。
358. * 这个中断函数设计得很简单，就是取得设备的状态，判断是“接收”还是“发送”的中断，以调用相应的处理函数。
359. * 而对于，“是哪个设备产生的中断”这个问题，则由调用它的函数通过第二个参数的赋值来决定。
360. */
361. static void snull_regular_interrupt(int irq, void *dev_id, struct pt_regs *regs)
362. {
363. int statusword;
364. struct snull_priv *priv;
365. struct snull_packet *pkt = NULL;
366. /*
367. * 通常，需要检查 "device" 指针以确保这个中断是发送给自己的。
368. * 然后为 "struct device *dev" 赋
369. */
370. struct net_device *dev = (struct net_device *)dev_id;
371.
372. /* paranoid */
373. if (!dev)
374. return;
375.
376. /* 锁住设备 */
377. priv = netdev_priv(dev);
378. spin_lock(&priv->lock);
379.
380. /* 取得设备状态指字，对于真实设备，使用I/O指令，比如：int txsr = inb(TX_STATUS); */
381. statusword = priv->status;
382. priv->status = 0;
383. if (statusword & SNULL_RX_INTR) { /*如果是接收数据包的中断*/
384. /* send it to snull_rx for handling */
385. pkt = priv->rx_queue;
386. if (pkt) {
387. priv->rx_queue = pkt->next;
388. snull_rx(dev, pkt);
389. }
390. }
391. if (statusword & SNULL_TX_INTR) { /*如果是发送数据包的中断*/
392. /* a transmission is over: free the skb */
393. priv->stats.tx_packets++;
394. priv->stats.tx_bytes += priv->tx_packetlen;
395. dev_kfree_skb(priv->skb);
396. }
397.
398. /* 释放锁 */
399. spin_unlock(&priv->lock);
400.
401. /*释放缓冲区*/
402. if (pkt) snull_release_buffer(pkt); /* Do this outside the lock! */
403. return;
404. }
405.
406. /*
407. * A NAPI interrupt handler.
408. * 在设备初始化的时候，poll指向指向了snull_poll函数，所以，NAPI中断处理函数很简单，
409. * 当“接收中断”到达的时候，它就屏蔽此中断，然后netif_rx_schedule函数接收，接收函数
410. * 会在未来某一时刻调用注册的snull_poll函数实现轮询，当然，对于“传输中断”，处理方法
411. * 同传统中断处理并无二致。
412. */
413. static void snull_napi_interrupt(int irq, void *dev_id, struct pt_regs *regs)
414. {
415. int statusword;
416. struct snull_priv *priv;
417.
418. /*
419. * As usual, check the "device" pointer for shared handlers.
420. * Then assign "struct device *dev"
421. */
422. struct net_device *dev = (struct net_device *)dev_id;
423. /* ... and check with hw if it's really ours */
424.
425. /* paranoid */
426. if (!dev)
427. return;
428.
429. /* Lock the device */
430. priv = netdev_priv(dev);
431. spin_lock(&priv->lock);
432.
433. /* retrieve statusword: real netdevices use I/O instructions */
434. statusword = priv->status;
435. priv->status = 0;
436.
437. /*
438. * 唯一的区别就在这里，它先屏蔽掉接收中断，然后调用netif_rx_schedule，而不是netif_rx
439. * 重点还是在于poll函数的设计。
440. */
441. if (statusword & SNULL_RX_INTR) {
442. snull_rx_ints(dev, 0); /* Disable further interrupts */
443. netif_rx_schedule(dev);
444. }
445. if (statusword & SNULL_TX_INTR) {
446. /* a transmission is over: free the skb */
447. priv->stats.tx_packets++;
448. priv->stats.tx_bytes += priv->tx_packetlen;
449. dev_kfree_skb(priv->skb);
450. }
451.
452. /* Unlock the device and we are done */
453. spin_unlock(&priv->lock);
454. return;
455. }
456.
457.
458.
459. /*
460. * Transmit a packet (low level interface)
461. */
462. static void snull_hw_tx(char *buf, int len, struct net_device *dev)
463. {
464. /*
465. * This function deals with hw details. This interface loops
466. * back the packet to the other snull interface (if any).
467. * In other words, this function implements the snull behaviour,
468. * while all other procedures are rather device-independent
469. */
470. struct iphdr *ih;
471. struct net_device *dest;
472. struct snull_priv *priv;
473. u32 *saddr, *daddr;
474. struct snull_packet *tx_buffer;
475.
476. /* I am paranoid. Ain't I? */
477. if (len < sizeof(struct ethhdr) + sizeof(struct iphdr)) {
478. printk("snull: Hmm... packet too short (%i octets)\n",
479. len);
480. return;
481. }
482.
483. if (0) { /* enable this conditional to look at the data */
484. int i;
485. PDEBUG("len is %i\n" KERN_DEBUG "data:",len);
486. for (i=14 ; i<len; i++)
487. printk(" %02x",buf[i]&0xff);
488. printk("\n");
489. }
490. /*
491. * 取得来源IP和目的IP地址
492. */
493. ih = (struct iphdr *)(buf+sizeof(struct ethhdr));
494. saddr = &ih->saddr;
495. daddr = &ih->daddr;
496.
497. /*
498. * 这里做了三个调换，以实现欺骗：来源地址第三octet 0<->1，目的地址第三octet 0<->1，设备snX编辑0<->1，这样做的理由是：
499. * sn0(发):192.168.0.88 --> 192.168.0.99 做了调换后，就变成：
500. * sn1(收):192.168.1.88 --> 192.168.1.99 因为sn1的地址就是192.168.1.99，所以，它收到这个包后，会回应：
501. * sn1(发):192.168.1.99 --> 192.168.1.88 ，同样地，做了这样的调换后，就变成：
502. * sn0(收):192.168.0.99 --> 192.168.0.88 这样，sn0就会收到这个包，实现了ping的请求与应答，^o^
503. */
504. ((u8 *)saddr)[2] ^= 1; /* change the third octet (class C) */
505. ((u8 *)daddr)[2] ^= 1;
506.
507. /*重新计算较验和*/
508. ih->check = 0; /* and rebuild the checksum (ip needs it) */
509. ih->check = ip_fast_csum((unsigned char *)ih,ih->ihl);
510.
511. /*输出调试信息*/
512. if (dev == snull_devs[0])
513. PDEBUGG("%08x:%05i --> %08x:%05i\n",
514. ntohl(ih->saddr),ntohs(((struct tcphdr *)(ih+1))->source),
515. ntohl(ih->daddr),ntohs(((struct tcphdr *)(ih+1))->dest));
516. else
517. PDEBUGG("%08x:%05i <-- %08x:%05i\n",
518. ntohl(ih->daddr),ntohs(((struct tcphdr *)(ih+1))->dest),
519. ntohl(ih->saddr),ntohs(((struct tcphdr *)(ih+1))->source));
520.
521. /*调换设备编号，即dest指向接收设备，原因如前所述*/
522. dest = snull_devs[dev == snull_devs[0] ? 1 : 0];
523.
524. /*将发送的数据添加到接收设备的接收队列中*/
525. priv = netdev_priv(dest);
526. tx_buffer = snull_get_tx_buffer(dev);
527. tx_buffer->datalen = len;
528. memcpy(tx_buffer->data, buf, len);
529. snull_enqueue_buf(dest, tx_buffer);
530.
531. /*
532. * 如果设备接收标志打开，就调用中断函数把数据包发送给目标设备——即触发目的设备的接收中断，这样
533. * 中断程序就会自接收设备的接收队列中接收数据包，并交给上层网络栈处理
534. */
535. if (priv->rx_int_enabled) {
536. priv->status |= SNULL_RX_INTR;
537. snull_interrupt(0, dest, NULL);
538. }
539.
540. /*发送完成后，触发“发送完成”中断*/
541. priv = netdev_priv(dev);
542. priv->tx_packetlen = len;
543. priv->tx_packetdata = buf;
544. priv->status |= SNULL_TX_INTR;
545.
546. /*
547. * 如果insmod驱动的时候，指定了模拟硬件锁的lockup=n，则在会传输n个数据包后，模拟一次硬件锁住的情况，
548. * 这是通过调用netif_stop_queue函数来停止传输队列，标记“设备不能再传输数据包”实现的，它将在传输的超
549. * 时函数中，调用netif_wake_queue函数来重新启动传输队例，同时超时函数中会再次调用“接收中断”，这样
550. * stats.tx_packets累加，又可以重新传输新的数据包了(参接收中断和超时处理函数的实现)。
551. */
552. if (lockup && ((priv->stats.tx_packets + 1) % lockup) == 0) {
553. /* Simulate a dropped transmit interrupt */
554. netif_stop_queue(dev); /*停止数据包的传输*/
555. PDEBUG("Simulate lockup at %ld, txp %ld\n", jiffies,
556. (unsigned long) priv->stats.tx_packets);
557. }
558. else
559. /*发送完成后，触发中断，中断函数发现发送完成，就累加计数器，释放skb缓存*/
560. snull_interrupt(0, dev, NULL);
561.
562. /*
563. * 看到这里，我们可以看到，这个发送函数其实并没有把数据包通过I/O指令发送给硬件，而仅仅是做了一个地址/设备的调换，
564. * 并把数据包加入到接收设备的队例当中。
565. */
566. }
567.
568. /*
569. * 数据包传输函数，Linux网络堆栈，在发送数据包时，会调用驱动程序的hard_start_transmit函数，
570. * 在设备初始化的时候，这个函数指针指向了snull_tx。
571. */
572. int snull_tx(struct sk_buff *skb, struct net_device *dev)
573. {
574. int len;
575. char *data, shortpkt[ETH_ZLEN];
576. struct snull_priv *priv = netdev_priv(dev);
577.
578. data = skb->data;
579. len = skb->len;
580. if (len < ETH_ZLEN) { /*处理短帧的情况，如果小于以太帧最小长度，不足位全部补0*/
581. memset(shortpkt, 0, ETH_ZLEN);
582. memcpy(shortpkt, skb->data, skb->len);
583. len = ETH_ZLEN;
584. data = shortpkt;
585. }
586. dev->trans_start = jiffies; /* 保存时间戳 */
587.
588. /*
589. * 因为“发送”完成后，需要释放skb，所以，先要保存它 ,释放都是在网卡发送完成，产生中断，而中断函数收
590. * 到网卡的发送完成的中断信号后释放
591. */
592. priv->skb = skb;
593.
594. /*
595. * 让硬件把数据包发送出去，对于物理设备，就是一个读网卡寄存器的过程，不过，这里，只是一些
596. * 为了实现演示功能的虚假的欺骗函数，比如操作源/目的IP，然后调用接收函数（所以，接收时不用调用中断）
597. */
598. snull_hw_tx(data, len, dev);
599.
600. return 0; /* Our simple device can not fail */
601. }
602.
603. /*
604. * 传输超时处理函数
605. * 比如在传输数据时，由于缓冲已满，需要关闭传输队列，但是驱动程序是不能丢弃数据包，它将在“超时”的时候触发
606. * 超时处理函数，这个函数将发送一个“传输中断”，以填补丢失的中断，并重新启动传输队例子
607. */
608. void snull_tx_timeout (struct net_device *dev)
609. {
610. struct snull_priv *priv = netdev_priv(dev);
611.
612. PDEBUG("Transmit timeout at %ld, latency %ld\n", jiffies,
613. jiffies - dev->trans_start);
614. /* Simulate a transmission interrupt to get things moving */
615. priv->status = SNULL_TX_INTR;
616. snull_interrupt(0, dev, NULL);
617. priv->stats.tx_errors++;
618. netif_wake_queue(dev);
619. return;
620. }
621.
622.
623.
624. /*
625. * Ioctl 命令
626. */
627. int snull_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
628. {
629. PDEBUG("ioctl\n");
630. return 0;
631. }
632.
633. /*
634. * 获取设备的状态
635. */
636. struct net_device_stats *snull_stats(struct net_device *dev)
637. {
638. struct snull_priv *priv = netdev_priv(dev);
639. return &priv->stats;
640. }
1. /*
2. * 有些网络有硬件地址(比如Ethernet)，并且在发送硬件帧时需要知道目的硬件 地址会进行ARP请求/应答，以完成MAC地址解析，
3. * 需要做arp请求的设备在发送之前会调用驱动程序的rebuild_header函数。需要做arp的的设备在发送之前会调用驱动程序的
4. * rebuild_header方 法。调用的主要参数包括指向硬件帧头的指针，协议层地址。如果驱动程序能够解 析硬件地址，就返回1，
5. * 如果不能，返回0。
6. * 当然，作者实现的演示设备中，不支持这个过程。
7. */
8. int snull_rebuild_header(struct sk_buff *skb)
9. {
10. struct ethhdr *eth = (struct ethhdr *) skb->data;
11. struct net_device *dev = skb->dev;
12.
13. memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
14. memcpy(eth->h_dest, dev->dev_addr, dev->addr_len);
15. eth->h_dest[ETH_ALEN-1] ^= 0x01; /* dest is us xor 1 */
16. return 0;
17. }
18.
19. /*
20. * 为上层协议创建一个二层的以太网首部。
21. * 事实上，如果一开始调用alloc_etherdev分配以太设备，它会调用ether_setup进行初始化，初始化函数会设置：
22. * dev->hard_header = eth_header;
23. * dev->rebuild_header = eth_rebuild_header;
24. * 驱动开发人员并不需要自己来实现这个函数，作者这样做，只是为了展示细节。
25. */
26.
27. int snull_header(struct sk_buff *skb, struct net_device *dev,
28. unsigned short type, void *daddr, void *saddr,
29. unsigned int len)
30. {
31. /*获取以太头指针*/
32. struct ethhdr *eth = (struct ethhdr *)skb_push(skb,ETH_HLEN);
33.
34. eth->h_proto = htons(type); /*填写协议*/
35.
36. /*填写来源/目的MAC地址，如果地址为空，则用设备自己的地址代替之*/
37. memcpy(eth->h_source, saddr ? saddr : dev->dev_addr, dev->addr_len);
38. memcpy(eth->h_dest, daddr ? daddr : dev->dev_addr, dev->addr_len);
39.
40. /*
41. * 将第一个octet设为0，主要是为了可以在不支持组播链路，如ppp链路上运行
42. * PS：作者这样做，仅仅是演示在PC机上的实现，事实上，直接使用ETH_ALEN-1是
43. * 不适合“大头”机器的。
44. */
45. eth->h_dest[ETH_ALEN-1] ^= 0x01; /* dest is us xor 1 */
46. return (dev->hard_header_len);
47. }
48.
49. /*
50. * 改变设备MTU值.
51. */
52. int snull_change_mtu(struct net_device *dev, int new_mtu)
53. {
54. unsigned long flags;
55. struct snull_priv *priv = netdev_priv(dev);
56. spinlock_t *lock = &priv->lock;
57.
58. /* check ranges */
59. if ((new_mtu < 68) || (new_mtu > 1500))
60. return -EINVAL;
61. /*
62. * Do anything you need, and the accept the value
63. */
64. spin_lock_irqsave(lock, flags);
65. dev->mtu = new_mtu;
66. spin_unlock_irqrestore(lock, flags);
67. return 0; /* success */
68. }
69.
70.
71.
72. /*
73. * 设备初始化函数，它必须在 register_netdev 函数被调用之前调用
74. */
75. void snull_init(struct net_device *dev)
76. {
77. /*设备的“私有”结构，保存一些设备一些“私有数据”*/
78. struct snull_priv *priv;
79. #if 0
80. /*
81. * Make the usual checks: check_region(), probe irq, ... -ENODEV
82. * should be returned if no device found. No resource should be
83. * grabbed: this is done on open().
84. */
85. #endif
86.
87. /*
88. * 初始化以太网设备的一些共用的成员
89. */
90. ether_setup(dev); /* assign some of the fields */
91.
92. /*设置设备的许多成员函数指针*/
93. dev->open = snull_open;
94. dev->stop = snull_release;
95. dev->set_config = snull_config;
96. dev->hard_start_xmit = snull_tx;
97. dev->do_ioctl = snull_ioctl;
98. dev->get_stats = snull_stats;
99. dev->change_mtu = snull_change_mtu;
100. dev->rebuild_header = snull_rebuild_header;
101. dev->hard_header = snull_header;
102. dev->tx_timeout = snull_tx_timeout;
103. dev->watchdog_timeo = timeout;
104.
105. /*如果使用NAPI，设置pool函数*/
106. if (use_napi) {
107. dev->poll = snull_poll;
108. dev->weight = 2; /*weight是接口在资源紧张时，在接口上能承受多大流量的权重*/
109. }
110. /* keep the default flags, just add NOARP */
111. dev->flags |= IFF_NOARP;
112. dev->features |= NETIF_F_NO_CSUM;
113. dev->hard_header_cache = NULL; /* Disable caching */
114.
115. /*
116. * 取得私有数据区，并初始化它.
117. */
118. priv = netdev_priv(dev);
119. memset(priv, 0, sizeof(struct snull_priv));
120. spin_lock_init(&priv->lock);
121. snull_rx_ints(dev, 1); /* 打开接收中断标志 */
122. snull_setup_pool(dev); /*设置使用NAPI时的接收缓冲池*/
123. }
124.
125. /*
126. * The devices
127. */
128.
129. struct net_device *snull_devs[2];
130.
131.
132.
133. /*
134. * 模块卸载函数，先unregister已经注册的设备，然后释放pool缓存申请的内存，最后释放设
135. */
136.
137. void snull_cleanup(void)
138. {
139. int i;
140.
141. for (i = 0; i < 2; i++) {
142. if (snull_devs[i]) {
143. unregister_netdev(snull_devs[i]);
144. snull_teardown_pool(snull_devs[i]);
145. free_netdev(snull_devs[i]);
146. }
147. }
148. return;
149. }
150.
151. /*模块初始化，初始化的只有一个工作：分配一个设备结构并注册它*/
152. int snull_init_module(void)
153. {
154. int result, i, ret = -ENOMEM;
155.
156. /*中断函数指针，因是否使用NAPI而指向不同的中断函数*/
157. snull_interrupt = use_napi ? snull_napi_interrupt : snull_regular_interrupt;
158.
159. /*
160. * 分配两个设备，网络设备都是用struct net_device来描述，alloc_netdev分配设备，第三个参数是
161. * 对struct net_device结构成员进行初始化的函数，对于以太网来说，可以把alloc_netdev/snull_init
162. * 两个函数变为一个，alloc_etherdev，它会自动调用以太网的初始化函数ether_setup，因为以太网的初
163. * 始化函数工作都是近乎一样的 */
164. snull_devs[0] = alloc_netdev(sizeof(struct snull_priv), "sn%d",
165. snull_init);
166. snull_devs[1] = alloc_netdev(sizeof(struct snull_priv), "sn%d",
167. snull_init);
168. /*分配失败*/
169. if (snull_devs[0] == NULL || snull_devs[1] == NULL)
170. goto out;
171.
172. ret = -ENODEV;
173. /*向内核注册网络设备，这样，设备就可以被使用了*/
174. for (i = 0; i < 2; i++)
175. if ((result = register_netdev(snull_devs[i])))
176. printk("snull: error %i registering device \"%s\"\n",
177. result, snull_devs[i]->name);
178. else
179. ret = 0;
180. out:
181. if (ret)
182. snull_cleanup();
183. return ret;
184. }
185.
186.
187. module_init(snull_init_module);
188. module_exit(snull_cleanup);[/
转载参考：http://blog.chinaunix.net/uid/24488136/cid-2897-list-1.html
侵删