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 01,目的地址第三octet 01,设备snX编辑01,这样做的理由是: 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 , 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. }
|