Chinaunix首页 | 论坛 | 博客

分类: LINUX

2010-11-05 14:27:04

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);[/


阅读(2755) | 评论(1) | 转发(3) |
给主人留下些什么吧!~~

chinaunix网友2010-11-05 16:49:58

很好的, 收藏了 推荐一个博客,提供很多免费软件编程电子书下载: http://free-ebooks.appspot.com