网卡驱动和队列层中的数据包接收Linux TCPIP协议栈笔记Word下载.docx

1、内核通过调用dma_map_single（struct device *dev,void *buffer,size_t size,enum dma_data_direction direction）建立映射关系。struct device *dev，描述一个设备；buffer：把哪个地址映射给设备；也就是某一个skb要映射全部，当然是做一个双向链表的循环即可；size：缓存大小；direction：映射方向谁传给谁：一般来说，是“双向”映射，数据在设备和内存之间双向流动；对于PCI设备而言（网卡一般是PCI的），通过另一个包裹函数pci_map_single，这样，就把buffer交给设备了！

2、设备可以直接从里边读/取数据。3、这一步由硬件完成；4、取消映射dma_unmap_single，对PCI而言，大多调用它的包裹函数pci_unmap_single，不取消的话，缓存控制权还在设备手里，要调用它，把主动权掌握在CPU手里因为我们已经接收到数据了，应该由CPU把数据交给上层网络栈；当然，不取消之前，通常要读一些状态位信息，诸如此类，一般是调用dma_sync_single_for_cpu（）让CPU在取消映射前，就可以访问DMA缓冲区中的内容。关于DMA映射的更多内容，可以参考Linux设备驱动程序“内存映射和DMA”章节相关内容！OK，有了这些知识，我们就可以来看e100的代码

3、了，它跟上面讲的步骤基本上一样的绕了这么多圈子，就是想绕到e100上面了，呵呵！在e100_open函数中，调用e100_up，我们前面分析它时，略过了一个重要的东东，就是环形缓冲区的建立，这一步，是通过e100_rx_alloc_list函数调用完成的：staticint e100_rx_alloc_list（struct nic *nic） 1. 2. struct rx *rx; 3. unsigned int i, count = nic-params.rfds.count;4. 5. nic-rx_to_use = nic-rx_to_clean = NULL;6. nic-ru_r

4、unning = RU_UNINITIALIZED;7. 8. /*结构struct rx用来描述一个缓冲区节点，这里分配了count个*/ 9. if（!（nic-rxs = kmalloc（sizeof（struct rx） * count, GFP_ATOMIC） 10. return -ENOMEM;11. memset（nic-rxs, 0, sizeof（struct rx） * count）;12. 13. /*虽然是连续分配的，不过还是遍历它，建立双向链表，然后为每一个rx的skb指针分员分配空间 14. skb用来描述内核中的一个数据包，呵呵，说到重点了*/ 15. for（

5、rx = nic-rxs, i = 0; i next = （i + 1 rxs;17. rx-prev = （i = 0） ?rxs + count - 1 : rx - 1;18. if（e100_rx_alloc_skb（nic, rx） /*分配缓存*/ 19. e100_rx_clean_list（nic）;20. return -ENOMEM;21. 22. 23. 24. nic-rx_to_clean = nic-25. nic-ru_running = RU_SUSPENDED;26. 27. return 0;28. static int e100_rx_alloc_lis

6、t（struct nic *nic）struct rx *rx;unsigned int i, count = nic-nic-/*结构struct rx用来描述一个缓冲区节点，这里分配了count个*/if（!rxs = kmalloc（sizeof（struct rx） * count, GFP_ATOMIC） return -ENOMEM;memset（nic-/*虽然是连续分配的，不过还是遍历它，建立双向链表，然后为每一个rx的skb指针分员分配空间skb用来描述内核中的一个数据包，呵呵，说到重点了*/for（rx = nic- rx+, i+） rx- rx- if（e100_rx_

7、alloc_skb（nic, rx） /*分配缓存*/e100_rx_clean_list（nic）;return -ENOMEM; nic-return 0;#define RFD_BUF_LEN （sizeof（struct rfd） + VLAN_ETH_FRAME_LEN） 1. staticinlineint e100_rx_alloc_skb（struct nic *nic, struct rx *rx） 2. 3. /*skb缓存的分配，是通过调用系统函数dev_alloc_skb来完成的，它同内核栈中通常调用alloc_skb的区别在于， 4. 它是原子的，所以，通常在中断上下

8、文中使用*/ 5. if（!（rx-skb = dev_alloc_skb（RFD_BUF_LEN + NET_IP_ALIGN） 6. return -ENOMEM;8. /*初始化必要的成员 */ 9. rx-skb-dev = nic-netdev;10. skb_reserve（rx-skb, NET_IP_ALIGN）;11. /*这里在数据区之前，留了一块sizeof（struct rfd） 这么大的空间，该结构的 12. 一个重要作用，用来保存一些状态信息，比如，在接收数据之前，可以先通过 13. 它，来判断是否真有数据到达等，诸如此类*/ 14. memcpy（rx-data,

9、 &blank_rfd, sizeof（struct rfd）;15. /*这是最关键的一步，建立DMA映射，把每一个缓冲区rx-data都映射给了设备，缓存区节点 16. rx利用dma_addr保存了每一次映射的地址，这个地址后面会被用到*/ 17. rx-dma_addr = pci_map_single（nic-pdev, rx-data, 18. RFD_BUF_LEN, PCI_DMA_BIDIRECTIONAL）;19. 20. if（pci_dma_mapping_error（rx-dma_addr） 21. dev_kfree_skb_any（rx-skb）;22. rx-s

10、kb = 0;23. rx-dma_addr = 0;24. return -ENOMEM;25. 27. /* Link the RFD to end of RFA by linking previous RFD to 28. * this one, and clearing EL bit of previous. */ 29. if（rx-prev-skb） 30. struct rfd *prev_rfd = （struct rfd *）rx-data;31. /*put_unaligned（val，ptr）；用到把var放到ptr指针的地方，它能处理处理内存对齐的问题 32. prev

11、_rfd是在缓冲区开始处保存的一点空间，它的link成员，也保存了映射后的地址*/ 33. put_unaligned（cpu_to_le32（rx-dma_addr）, 34. （u32 *）&prev_rfd-link）;35. wmb（）;36. prev_rfd-command &= cpu_to_le16（cb_el）;37. pci_dma_sync_single_for_device（nic-dma_addr, 38. sizeof（struct rfd）, PCI_DMA_TODEVICE）;39. 40. 41. return 0;42. #define RFD_BUF_LE

12、N （sizeof（struct rfd） + VLAN_ETH_FRAME_LEN）static inline int e100_rx_alloc_skb（struct nic *nic, struct rx *rx）/*skb缓存的分配，是通过调用系统函数dev_alloc_skb来完成的，它同内核栈中通常调用alloc_skb的区别在于，它是原子的，所以，通常在中断上下文中使用*/if（!skb = dev_alloc_skb（RFD_BUF_LEN + NET_IP_ALIGN） return -ENOMEM;/*初始化必要的成员 */rx-skb_reserve（rx-/*这里在数据

13、区之前，留了一块sizeof（struct rfd） 这么大的空间，该结构的一个重要作用，用来保存一些状态信息，比如，在接收数据之前，可以先通过它，来判断是否真有数据到达等，诸如此类*/memcpy（rx-/*这是最关键的一步，建立DMA映射，把每一个缓冲区rx-data都映射给了设备，缓存区节点rx利用dma_addr保存了每一次映射的地址，这个地址后面会被用到*/rx-data, RFD_BUF_LEN, PCI_DMA_BIDIRECTIONAL）;if（pci_dma_mapping_error（rx-dma_addr） dev_kfree_skb_any（rx- return -EN

14、OMEM;/* Link the RFD to end of RFA by linking previous RFD to * this one, and clearing EL bit of previous. */if（rx-skb） struct rfd *prev_rfd = （struct rfd *）rx- /*put_unaligned（val，ptr）；用到把var放到ptr指针的地方，它能处理处理内存对齐的问题 prev_rfd是在缓冲区开始处保存的一点空间，它的link成员，也保存了映射后的地址*/ put_unaligned（cpu_to_le32（rx-dma_addr

15、）,（u32 *）& wmb（）; prev_rfd- pci_dma_sync_single_for_device（nic-dma_addr,sizeof（struct rfd）, PCI_DMA_TODEVICE）;return 0;e100_rx_alloc_list函数在一个循环中，建立了环形缓冲区，并调用e100_rx_alloc_skb为每个缓冲区分配了空间，并做了DMA映射。这样，我们就可以来看接收数据的过程了。前面我们讲过，中断函数中，调用netif_rx_schedule，表明使用轮询技术，系统会在未来某一时刻，调用设备的poll函数：int e100_poll（struct

16、 net_device *netdev, int *budget） 2. struct nic *nic = netdev_priv（netdev）;3. unsigned int work_to_do = min（netdev-quota, *budget）;4. unsigned int work_done = 0;5. int tx_cleaned;6. 7. e100_rx_clean（nic, &work_done, work_to_do）;8. tx_cleaned = e100_tx_clean（nic）;9. 10. /* If no Rx and Tx cleanup wor

17、k was done, exit polling mode. */ 11. if（!tx_cleaned & （work_done = 0） | !netif_running（netdev） 12. netif_rx_complete（netdev）;13. e100_enable_irq（nic）;14. return 0;15. 16. 17. *budget -= work_done;18. netdev-quota -= work_done;20. return 1;21. static int e100_poll（struct net_device *netdev, int *bud

18、get）struct nic *nic = netdev_priv（netdev）;unsigned int work_to_do = min（netdev-unsigned int work_done = 0;int tx_cleaned;e100_rx_clean（nic, &tx_cleaned = e100_tx_clean（nic）;/* If no Rx and Tx cleanup work was done, exit polling mode. */if（!netif_running（netdev） netif_rx_complete（netdev）; e100_enable

19、_irq（nic）; return 0;*budget -= work_done;netdev-return 1;目前，我们只关心rx，所以，e100_rx_clean函数就成了我们关注的对像，它用来从缓冲队列中接收全部数据（这或许是取名为clean的原因吧！）：void e100_rx_clean（struct nic *nic, unsigned int *work_done, 1. unsigned int work_to_do） 3. struct rx *rx;4. int restart_required = 0;5. struct rx *rx_to_start = NULL;7

20、. /* are we already rnr? then pay attention! this ensures that 8. * the state machine progression never allows a start with a 9. * partially cleaned list, avoiding a race between hardware 10. * and rx_to_clean when in NAPI mode */ 11. if（RU_SUSPENDED = nic-ru_running） 12. restart_required = 1;13. 14

21、. /* 函数最重要的工作，就是遍历环形缓冲区，接收数据*/ rx_to_clean;skb; rx = nic-rx_to_clean = rx-next） 16. int err = e100_rx_indicate（nic, rx, work_done, work_to_do）;17. if（-EAGAIN = err） 18. /* hit quota so have more work to do, restart once 19. * cleanup is complete */ 20. restart_required = 0;21. break;22. elseif（-ENOD

22、ATA = err） 23. break; /* No more to clean */ 24. 25. 26. /* save our starting point as the place well restart the receiver */ 27. if（restart_required） 28. rx_to_start = nic-29. 30. /* Alloc new skbs to refill list */ 31. for（rx = nic-rx_to_use; !rx-rx_to_use = rx-32. if（unlikely（e100_rx_alloc_skb（ni

23、c, rx） 33. break; /* Better luck next time （see watchdog） */ 34. 35. 36. if（restart_required） 37. / ack the rnr?38. writeb（stat_ack_rnr, &csr-scb.stat_ack）;39. e100_start_receiver（nic, rx_to_start）;40. if（work_done） 41. （*work_done）+;43. static inline void e100_rx_clean（struct nic *nic, unsigned int

24、 *work_done,unsigned int work_to_do）struct rx *rx;int restart_required = 0;struct rx *rx_to_start = NULL;/* are we already rnr? this ensures that * the state machine progression never allows a start with a * partially cleaned list, avoiding a race between hardware * and rx_to_clean when in NAPI mode */if（RU_SUSPENDED = nic-ru_running）restart_required = 1;/* 函数最重要的工作，就是遍历环形缓冲区，接收数据*/for（rx = nic-next）