PF_RING实现分析

内核版本：Linux 2.6.30.9

PF_RING版本：4.1.0

最近看了一个PF_RING的实现，看了个大概，发上来大家讨论讨论，共同学习。

一、什么是PF_RING
PF_RING是一个第三方的内核数据包捕获接口，类似于libpcap，它的官方网址是： http://www.ntop.org/PF_RING.html

二、为什么需要PF_RING
一切为了效率，按照其官方网站上的测试数据，在Linux平台之上，其效率至少高于libpcap 50% - 60%，甚至是一倍。更好的是，PF_RING提供了一个修改版本的libpcap，使之建立在PF_RING接口之上。这样，原来使用libpcap的程序，就可以自然过渡了。

三、声明
1、这不是“零拷贝”，研究“零拷贝”的估计要失望，如果继续看下去的话；
2、这不是包截获接口，如果需要拦截、修改内核数据包，请转向Netfilter；
3、本文只分析了PF_RING最基础的部份。关于DNA、TNAPI，BPF等内容不包含在内。

四、源码的获取
svn co  https://svn.ntop.org/svn/ntop/trunk/PF_RING/  

最近好像全流行svn了。

五、编译和使用
接口分为两部份，一个是内核模块，一个是用户态的库
cd my_pf_ring_goes_here 
cd kernel 
make 
sudo insmod ./pf_ring.ko 
cd ../userland 
make 

在源码目录中，关于用户态的库有使用的现成的例子，很容易依葫芦画瓢。后文也会提到用户态库的实现的简单分析，可以两相比照，很容易上手。而且源码目录中有一个PDF文档，有详细的API介绍，建议使用前阅读。

六、实现分析初步
1、核心思路
A、在内核队列层注册Hook，获取数据帧。
B、在内核创建一个环形队列(这也是叫RING的原因)，用于存储数据，并使用mmap映射到用户空间。这样，避免用户态的系统调用，也是提高性能的关键所在。
C、创建了一个新的套接字类型PF_RING，用户态通过它与内核通信。

2、模块初始化
模块源码只有一个文件，在目录树kernel/pf_ring.c，嗯，还有一个头文件，在kernel/linux下

1. static int __init ring_init(void)
   
2. {
   
3.   int i, rc;
   
4. 
   
5.   printk("[PF_RING] Welcome to PF_RING %s ($Revision: 4012 $)\n"
   
6.          "(C) 2004-09 L.Deri <[email]deri@ntop.org[/email]>\n", RING_VERSION);
   
7.         
   
8.         //注册名为PF_RING的新协议
   
9.   if((rc = proto_register(&ring_proto, 0)) != 0)
   
10.     return(rc);

复制代码

ring_proto的定义为

1. #if(LINUX_VERSION_CODE > KERNEL_VERSION(2,6,11))
   
2. static struct proto ring_proto = {
   
3.   .name = "PF_RING",
   
4.   .owner = THIS_MODULE,
   
5.   .obj_size = sizeof(struct ring_sock),
   
6. };
   
7. #endif

复制代码

初始化四个链表，它们的作用，后文会分析到：

1.         //初始化四个链表
   
2.   INIT_LIST_HEAD(&ring_table);                                        /* List of all ring sockets. */
   
3.   INIT_LIST_HEAD(&ring_cluster_list);                        /* List of all clusters */
   
4.   INIT_LIST_HEAD(&ring_aware_device_list);                /* List of all devices on which PF_RING has been registered */
   
5.   INIT_LIST_HEAD(&ring_dna_devices_list);                /* List of all dna (direct nic access) devices */

复制代码

device_ring_list是一个指针数组，它的每一个元素对应一个网络设备，后文也会分析它的使用：

1. /*
   
2.   For each device, pf_ring keeps a list of the number of
   
3.   available ring socket slots. So that a caller knows in advance whether
   
4.   there are slots available (for rings bound to such device)
   
5.   that can potentially host the packet
   
6. */
   
7.   for (i = 0; i < MAX_NUM_DEVICES; i++)
   
8.     INIT_LIST_HEAD(&device_ring_list[i]);

复制代码

1.         //为新协议注册sock
   
2.   sock_register(&ring_family_ops);

复制代码

ring_family_ops定义为

1. static struct net_proto_family ring_family_ops = {
   
2.   .family = PF_RING,
   
3.   .create = ring_create,
   
4.   .owner = THIS_MODULE,
   
5. };

复制代码

这样，当用户空间创建PF_RING时，例如，

1. fd = socket(PF_RING, SOCK_RAW, htons(ETH_P_ALL));

复制代码

ring_create将会被调用

1.   //注册通知链表  
   
2.   register_netdevice_notifier(&ring_netdev_notifier);
   
3. 
   
4.   /* 工作模式语法检查 */
   
5.   if(transparent_mode > driver2pf_ring_non_transparent)
   
6.     transparent_mode = standard_linux_path;

复制代码

PF_RING一共有三种工作模式：

1. typedef enum {
   
2.   standard_linux_path = 0, /* Business as usual */
   
3.   driver2pf_ring_transparent = 1, /* Packets are still delivered to the kernel */
   
4.   driver2pf_ring_non_transparent = 2 /* Packets not delivered to the kernel */
   
5. } direct2pf_ring;

复制代码

第一种最简单，这里仅分析第一种

1.         //输出工作信息参数
   
2.   printk("[PF_RING] Ring slots       %d\n", num_slots);
   
3.   printk("[PF_RING] Slot version     %d\n",
   
4.          RING_FLOWSLOT_VERSION);
   
5.   printk("[PF_RING] Capture TX       %s\n",
   
6.          enable_tx_capture ? "Yes [RX+TX]" : "No [RX only]");
   
7.   printk("[PF_RING] Transparent Mode %d\n",
   
8.          transparent_mode);
   
9.   printk("[PF_RING] IP Defragment    %s\n",
   
10.          enable_ip_defrag ? "Yes" : "No");
    
11.   printk("[PF_RING] Initialized correctly\n");

复制代码

num_slots为槽位总数，系统采用数组来实现双向环形队列，它也就代表数组的最大元素。
版本信息：不用多说了。不过我的版本在2.6.18及以下都没有编译成功，后来使用2.6.30.9搞定之。
enable_tx_capture：是否启用发送时的数据捕获，对于大多数应用而言，都是在接收时处理。
enable_ip_defrag：为用户提供一个接口，是否在捕获最重组IP分片。

1.         //创建/proc目录
   
2.   ring_proc_init();
   
3.   
   
4.   //注册设备句柄
   
5.   register_device_handler();
   
6. 
   
7.   pfring_enabled = 1;                //工作标志
   
8.   return 0;
   
9. }

复制代码

register_device_handler注册了一个协议，用于数据包的获取：

1. /* Protocol hook */
   
2. static struct packet_type prot_hook;
   
3. 
   
4. void register_device_handler(void) {
   
5.         //只有在第一种模式下，才用这种方式接收数据
   
6.   if(transparent_mode != standard_linux_path) return;
   
7. 
   
8.   prot_hook.func = packet_rcv;
   
9.   prot_hook.type = htons(ETH_P_ALL);
   
10.   dev_add_pack(&prot_hook);
    
11. }
    
12. 
    
13. void register_device_handler(void) {
    
14.   if(transparent_mode != standard_linux_path) return;
    
15. 
    
16.   prot_hook.func = packet_rcv;
    
17.   prot_hook.type = htons(ETH_P_ALL);
    
18.   dev_add_pack(&prot_hook);
    
19. }

复制代码

2、创建套接字
Linux的套按字的内核接口，使用了两个重要的数据结构：
struct socket和struct sock，这本来并没有什么，不过令人常常迷惑的是，前者常常被缩写为sock，即：
struct socket *sock;
这样，“sock”就容易造成混淆了。还好，后者常常被缩写为sk……
我这里写sock指前者，sk指后者，如果不小心写混了，请参考上下文区分  。

关于这两个结构的含义，使用等等，可以参考相关资料以获取详细信息，如《Linux情景分析》。我的个人网站 www.skynet.org.cn 上也分析了Linux socket的实现。可以参考。这里关于socket的进一步信息，就不详细分析了。

这里的创建套接字，内核已经在系统调用过程中，准备好了sock，主要就是分析sk，并为sk指定一系列的操作函数，如bind、mmap、poll等等。
如前所述，套接字的创建，是通过调用ring_create函数来完成的：

1. static int ring_create(
   
2. #if(LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
   
3.                        struct net *net,
   
4. #endif
   
5.                        struct socket *sock, int protocol)
   
6. {
   
7.   struct sock *sk;
   
8.   struct ring_opt *pfr;
   
9.   int err;
   
10. 
    
11. #if defined(RING_DEBUG)
    
12.   printk("[PF_RING] ring_create()\n");
    
13. #endif
    
14. 
    
15.   /* 权限验证 ? */
    
16.   if(!capable(CAP_NET_ADMIN))
    
17.     return -EPERM;
    
18. 
    
19.   //协议簇验证
    
20.   if(sock->type != SOCK_RAW)
    
21.     return -ESOCKTNOSUPPORT;
    
22. 
    
23.   //协议验证
    
24.   if(protocol != htons(ETH_P_ALL))
    
25.     return -EPROTONOSUPPORT;
    
26. 
    
27.   err = -ENOMEM;
    
28. 
    
29.   // 分配sk
    
30.   // options are.
    
31. #if(LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11))
    
32.   sk = sk_alloc(PF_RING, GFP_KERNEL, 1, NULL);
    
33. #else
    
34. #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
    
35.     // BD: API changed in 2.6.12, ref:
    
36.     // [url]http://svn.clkao.org/svnweb/linux/revision/?rev=28201[/url]
    
37.     sk = sk_alloc(PF_RING, GFP_ATOMIC, &ring_proto, 1);
    
38. #else
    
39.     sk = sk_alloc(net, PF_INET, GFP_KERNEL, &ring_proto);
    
40. #endif
    
41. #endif
    
42. 
    
43.   //分配失败
    
44.   if(sk == NULL)
    
45.     goto out;
    
46.   
    
47.   //这里很重要，设定sock的ops，即对应用户态的bind、connect诸如此类操作的动作
    
48.   sock->ops = &ring_ops;
    
49. 
    
50.   //初始化sock结构(即sk)各成员，并设定与套接字socket(即sock)的关联
    
51.   sock_init_data(sock, sk);
    
52. #if(LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11))
    
53.   sk_set_owner(sk, THIS_MODULE);
    
54. #endif
    
55. 
    
56.   err = -ENOMEM;
    
57. 
    
58. #define ring_sk_datatype(__sk) ((struct ring_opt *)__sk)
    
59. #define ring_sk(__sk) ((__sk)->sk_protinfo)
    
60. 
    
61. //作者喜欢用小写的宏
    
62. //这里分配一个struct ring_opt结构，这个结构比较重要，其记录了ring的选项信息。
    
63. 在sk中，使用sk_protinfo成员指向之，这样就建立了sock->sk->ring_opt的关联。可以通过套接字很容易获取Ring的信息。
    
64.   ring_sk(sk) = ring_sk_datatype(kmalloc(sizeof(*pfr), GFP_KERNEL));
    
65.   //分配失败
    
66.   if(!(pfr = ring_sk(sk))) {
    
67.     sk_free(sk);
    
68.     goto out;
    
69.   }
    
70. 
    
71.   //初始化各成员
    
72.   memset(pfr, 0, sizeof(*pfr));
    
73. //激活标志
    
74.   pfr->ring_active = 0;        /* We activate as soon as somebody waits for packets */
    
75.   //通道ID
    
76.   pfr->channel_id = RING_ANY_CHANNEL;
    
77.   //RING的每个槽位的桶的大小，其用来存储捕获的数据帧，这个值，用户态也可以使用setsocketopt来调整
    
78.   pfr->bucket_len = DEFAULT_BUCKET_LEN;
    
79. //过滤器hash桶
    
80.   pfr->handle_hash_rule = handle_filtering_hash_bucket;
    
81.   //初始化等待队列
    
82.   init_waitqueue_head(&pfr->ring_slots_waitqueue);
    
83.   //初始化RING的锁
    
84.   rwlock_init(&pfr->ring_index_lock);
    
85.   rwlock_init(&pfr->ring_rules_lock);
    
86.   //初始化使用计数器
    
87.   atomic_set(&pfr->num_ring_users, 0);
    
88.   INIT_LIST_HEAD(&pfr->rules);
    
89.   //设定协议簇
    
90.   sk->sk_family = PF_RING;
    
91. //设定sk的destuct函数
    
92.   sk->sk_destruct = ring_sock_destruct;
    
93. 
    
94.   //sk入队
    
95.   ring_insert(sk);
    
96. 
    
97. #if defined(RING_DEBUG)
    
98.   printk("[PF_RING] ring_create() - created\n");
    
99. #endif
    
100. 
     
101.   return(0);
     
102. out:
     
103.   return err;

复制代码

在模块初始化中，初始化过四个链表。其中一个是ring_table，ring_insert将刚刚创建的套接字插入其中。其封装引进了一个struct ring_element 结构：

1. /*
   
2. * ring_insert()
   
3. *
   
4. * store the sk in a new element and add it
   
5. * to the head of the list.
   
6. */
   
7. static inline void ring_insert(struct sock *sk)
   
8. {
   
9.   struct ring_element *next;
   
10.   struct ring_opt *pfr;
    
11. 
    
12. #if defined(RING_DEBUG)
    
13.   printk("[PF_RING] ring_insert()\n");
    
14. #endif
    
15. 
    
16. //分配element
    
17.   next = kmalloc(sizeof(struct ring_element), GFP_ATOMIC);
    
18.   if(next != NULL) {
    
19.     //记录sk
    
20.     next->sk = sk;
    
21.     write_lock_bh(&ring_mgmt_lock);
    
22.     //入队
    
23.     list_add(&next->list, &ring_table);
    
24.     write_unlock_bh(&ring_mgmt_lock);
    
25.   } else {
    
26.     if(net_ratelimit())
    
27.       printk("[PF_RING] net_ratelimit() failure\n");
    
28.   }
    
29. 
    
30.   //累计使用计数器
    
31.   ring_table_size++;
    
32.   //ring_proc_add(ring_sk(sk));
    
33.   //记录进程PID
    
34.   pfr = (struct ring_opt *)ring_sk(sk);
    
35.   pfr->ring_pid = current->pid;
    
36. }

复制代码

3 、分配队列空间
用户态在创建了套接字后，接下来就调用bind函数，绑定套接字，而PF_RING实际做的就是为RING分配相应的空间。也就是说，一个套接字，都有一个与之对应的RING。这样，有多个进程同时使用PF_RING，也没有问题:

1.                 sa.sa_family   = PF_RING;
   
2.                 snprintf(sa.sa_data, sizeof(sa.sa_data), "%s", device_name);
   
3.                 rc = bind(ring->fd, (struct sockaddr *)&sa, sizeof(sa));

复制代码

因为前一步创建套接字时，为sk指定了其ops：

1. static struct proto_ops ring_ops = {
   
2.   .family = PF_RING,
   
3.   .owner = THIS_MODULE,
   
4. 
   
5.   /* Operations that make no sense on ring sockets. */
   
6.   .connect = sock_no_connect,
   
7.   .socketpair = sock_no_socketpair,
   
8.   .accept = sock_no_accept,
   
9.   .getname = sock_no_getname,
   
10.   .listen = sock_no_listen,
    
11.   .shutdown = sock_no_shutdown,
    
12.   .sendpage = sock_no_sendpage,
    
13.   .sendmsg = sock_no_sendmsg,
    
14. 
    
15.   /* Now the operations that really occur. */
    
16.   .release = ring_release,
    
17.   .bind = ring_bind,
    
18.   .mmap = ring_mmap,
    
19.   .poll = ring_poll,
    
20.   .setsockopt = ring_setsockopt,
    
21.   .getsockopt = ring_getsockopt,
    
22.   .ioctl = ring_ioctl,
    
23.   .recvmsg = ring_recvmsg,
    
24. };

复制代码

这样，当bing系统调用触发时，ring_bind函数将被调用：

1. * Bind to a device */
   
2. static int ring_bind(struct socket *sock, struct sockaddr *sa, int addr_len)
   
3. {
   
4.   struct sock *sk = sock->sk;
   
5.   struct net_device *dev = NULL;
   
6. 
   
7. #if defined(RING_DEBUG)
   
8.   printk("[PF_RING] ring_bind() called\n");
   
9. #endif
   
10. 
    
11.   /*
    
12.    *      Check legality
    
13.    */
    
14.   if(addr_len != sizeof(struct sockaddr))
    
15.     return -EINVAL;
    
16.   if(sa->sa_family != PF_RING)
    
17.     return -EINVAL;
    
18.   if(sa->sa_data == NULL)
    
19.     return -EINVAL;
    
20. 
    
21.   /* Safety check: add trailing zero if missing */
    
22.   sa->sa_data[sizeof(sa->sa_data) - 1] = '\0';
    
23. 
    
24. #if defined(RING_DEBUG)
    
25.   printk("[PF_RING] searching device %s\n", sa->sa_data);
    
26. #endif
    
27. 
    
28.   if((dev = __dev_get_by_name(
    
29. #if(LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
    
30.                                &init_net,
    
31. #endif
    
32.                                sa->sa_data)) == NULL) {
    
33. #if defined(RING_DEBUG)
    
34.     printk("[PF_RING] search failed\n");
    
35. #endif
    
36.     return(-EINVAL);
    
37.   } else
    
38.     return(packet_ring_bind(sk, dev));
    
39. }

复制代码

在做了一些必要的语法检查后，函数转向packet_ring_bind：

1. /*
   
2. * We create a ring for this socket and bind it to the specified device
   
3. */
   
4. static int packet_ring_bind(struct sock *sk, struct net_device *dev)
   
5. {
   
6.   u_int the_slot_len;
   
7.   u_int32_t tot_mem;
   
8.   struct ring_opt *pfr = ring_sk(sk);
   
9.   // struct page *page, *page_end;
   
10. 
    
11.   if(!dev)
    
12.     return(-1);
    
13. 
    
14. #if defined(RING_DEBUG)
    
15.   printk("[PF_RING] packet_ring_bind(%s) called\n", dev->name);
    
16. #endif
    
17. 
    
18.   /* **********************************************
    
19. 
    
20.    * *************************************
    
21.    * *                                   *
    
22.    * *        FlowSlotInfo               *
    
23.    * *                                   *
    
24.    * ************************************* <-+
    
25.    * *        FlowSlot                   *   |
    
26.    * *************************************   |
    
27.    * *        FlowSlot                   *   |
    
28.    * *************************************   +- num_slots
    
29.    * *        FlowSlot                   *   |
    
30.    * *************************************   |
    
31.    * *        FlowSlot                   *   |
    
32.    * ************************************* <-+
    
33.    *
    
34.    * ********************************************** */
    
35. 
    
36.         //计算每一个槽位所需的内存空间
    
37.   the_slot_len = sizeof(u_char)        /* flowSlot.slot_state */
    
38. #ifdef RING_MAGIC
    
39.     + sizeof(u_char)
    
40. #endif
    
41.     + sizeof(struct pfring_pkthdr)
    
42.     + pfr->bucket_len /* flowSlot.bucket */ ;
    
43. /*    
    
44.         对于槽位空间的计算，有意思的是
    
45. typedef struct flowSlot {
    
46. #ifdef RING_MAGIC
    
47.   u_char     magic;      /* It must alwasy be zero */
    
48. #endif
    
49.   u_char     slot_state; /* 0=empty, 1=full   */
    
50.   u_char     bucket;     /* bucket[bucketLen] */
    
51. } FlowSlot;
    
52. 对照结构定义和上面的计算公式：
    
53. 1、作者好像把magic和slog_state的顺序给搞反了，不过还好，它们都是u_char，对结果不影响
    
54. 2、bucket，桶的大小，这个桶就是拿来装要捕获的数据包了，虽然它在结构中定义是一个成员，事实上，
    
55. 它由两个部份组成，一个是包的首部信息，这个结构的定义同libpcap很接近。另一个才是包的空间。
    
56. */
    
57. 
    
58.         //总共的环形队列内存所需空间，包含一个队列控制信息FlowSlotInfo和若干个(由变量num_slots决定)槽位空间
    
59.   tot_mem = sizeof(FlowSlotInfo) + num_slots * the_slot_len;
    
60.   
    
61.   //确保按整数页分配，mmap也要求这样
    
62.   if(tot_mem % PAGE_SIZE)
    
63.     tot_mem += PAGE_SIZE - (tot_mem % PAGE_SIZE);
    
64. 
    
65.         //分配内存空间
    
66.   pfr->ring_memory = rvmalloc(tot_mem);
    
67. 
    
68.   if(pfr->ring_memory != NULL) {
    
69.     printk("[PF_RING] successfully allocated %lu bytes at 0x%08lx\n",
    
70.            (unsigned long)tot_mem, (unsigned long)pfr->ring_memory);
    
71.   } else {
    
72.     printk("[PF_RING] ERROR: not enough memory for ring\n");
    
73.     return(-1);
    
74.   }
    
75. 
    
76.   // memset(pfr->ring_memory, 0, tot_mem); // rvmalloc does the memset already
    
77.   //初始化各成员
    
78.         //内存指定，因为分配的内存开始部份是sizeof(FlowSlotInfo)，所以可以做这样的强制转换，很容易互相取值
    
79.   pfr->slots_info = (FlowSlotInfo *) pfr->ring_memory;
    
80.   //跳过控制信息，指向槽位指针.事实上，它就是一个一维数组了，可以计算出合适的索引值，取到数组(RING)中的任意槽位值
    
81.   pfr->ring_slots = (char *)(pfr->ring_memory + sizeof(FlowSlotInfo));
    
82. 
    
83.   //版本信息
    
84.   pfr->slots_info->version = RING_FLOWSLOT_VERSION;
    
85.   //登记单个槽的大小
    
86.   pfr->slots_info->slot_len = the_slot_len;
    
87.   //登记bucket大小，从前面特别注释的bucket的分配看，bucket_len这个大小并不代表bucket成员的实际大小——它不包含struct pfring_pkthdr
    
88.   pfr->slots_info->data_len = pfr->bucket_len;
    
89.   //登记实际分配到的槽位数量，这里不用num_slots，难道是怕rvmalloc偷吃？
    
90.   pfr->slots_info->tot_slots =
    
91.     (tot_mem - sizeof(FlowSlotInfo)) / the_slot_len;
    
92.   //登记实际分配的内存总数  
    
93.   pfr->slots_info->tot_mem = tot_mem;
    
94.   //采样速率？？
    
95.   pfr->slots_info->sample_rate = 1;
    
96. 
    
97.   printk("[PF_RING] allocated %d slots [slot_len=%d][tot_mem=%u]\n",
    
98.          pfr->slots_info->tot_slots, pfr->slots_info->slot_len,
    
99.          pfr->slots_info->tot_mem);
    
100. 
     
101. #ifdef RING_MAGIC
     
102.   {
     
103.     int i;
     
104. 
     
105.     for (i = 0; i < pfr->slots_info->tot_slots; i++) {
     
106.       unsigned long idx = i * pfr->slots_info->slot_len;
     
107.       FlowSlot *slot = (FlowSlot *) & pfr->ring_slots[idx];
     
108.       slot->magic = RING_MAGIC_VALUE;
     
109.       slot->slot_state = 0;
     
110.     }
     
111.   }
     
112. #endif
     
113.   //这些控制变量可以在环的入队操作中看到它们的作用
     
114.   pfr->sample_rate = 1;        /* No sampling */
     
115.   pfr->insert_page_id = 1, pfr->insert_slot_id = 0;
     
116.   pfr->rules_default_accept_policy = 1, pfr->num_filtering_rules = 0;
     
117.   ring_proc_add(ring_sk(sk), dev);
     
118. 
     
119.   //记录与之相应的设备信息，例如，如果在eth0上打开了5 个PF_RING, bind
     
120.   //被调用5次，分配了5个环形队列空间。eth0上随之分配5个elem，它们指向与
     
121.   //之对应的ring，然后根据设备索引号民全部加入至了device_ring_list
     
122.   //当有数据报文从指定接口进入时，可以很容易地在device_ring_list中找到相应的设备
     
123.   //然后再遍历链表，再找到与之相应的ring
     
124.   if(dev->ifindex < MAX_NUM_DEVICES) {
     
125.     device_ring_list_element *elem;
     
126. 
     
127.     /* printk("[PF_RING] Adding ring to device index %d\n", dev->ifindex); */
     
128. 
     
129.     elem = kmalloc(sizeof(device_ring_list_element), GFP_ATOMIC);
     
130.     if(elem != NULL) {
     
131.       elem->the_ring = pfr;
     
132.       INIT_LIST_HEAD(&elem->list);
     
133.       write_lock(&ring_list_lock);
     
134.       list_add(&elem->list, &device_ring_list[dev->ifindex]);
     
135.       write_unlock(&ring_list_lock);
     
136.       /* printk("[PF_RING] Added ring to device index %d\n", dev->ifindex); */
     
137.     }
     
138.   }
     
139. 
     
140.   /*
     
141.     IMPORTANT
     
142.     Leave this statement here as last one. In fact when
     
143.     the ring_netdev != NULL the socket is ready to be used.
     
144.   */
     
145.   pfr->ring_netdev = dev;
     
146. 
     
147.   return(0);
     
148. }

复制代码

这个函数中，最重要的三点：
1、整个空间的详细构成，作者画了一个简单的草图，清晰明了。
2、如果取得某个槽位。
3、device_ring_list链表的使用。

一些作者有详细注释的地方，我就不再重重了。

这一步进行完了后，就有一块内存了（系统将其看成一个数组），用来存储捕获的数据帧。接下来要做的事情。就是把它映射到用户态。

4、mmap操作
用户态的接下来调用：

1.                         ring->buffer = (char *)mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE,
   
2.                                 MAP_SHARED, ring->fd, 0);

复制代码

进行内存映射。
同样地，内核调用相应的ring_mmap进行处理。
Ring选项结构通过ring_sk宏与sk 建立关联

1. struct ring_opt *pfr = ring_sk(sk);

复制代码

pfr->ring_memory 即为分配的环形队列空间。所以，要mmap操作，实际上就是调用remap_pfn_range函数把pfr->ring_memory 映射到用户空间即可。这个函数的原型为：

1. /**
   
2. * remap_pfn_range - remap kernel memory to userspace
   
3. * @vma: user vma to map to
   
4. * @addr: target user address to start at
   
5. * @pfn: physical address of kernel memory
   
6. * @size: size of map area
   
7. * @prot: page protection flags for this mapping
   
8. *
   
9. *  Note: this is only safe if the mm semaphore is held when called.
   
10. */
    
11. int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr,
    
12.                     unsigned long pfn, unsigned long size, pgprot_t prot)
    
13. {

复制代码

关于remap_pfn_range函数的进一步说明，可以参考LDD3，上面有详细说明和现成的例子。

1. static int ring_mmap(struct file *file,
   
2.                      struct socket *sock, struct vm_area_struct *vma)
   
3. {
   
4.   struct sock *sk = sock->sk;
   
5.   struct ring_opt *pfr = ring_sk(sk);                //取得pfr指针，也就是相应取得环形队列的内存空间地址指针
   
6.   int rc;
   
7.   unsigned long size = (unsigned long)(vma->vm_end - vma->vm_start);
   
8. 
   
9.   if(size % PAGE_SIZE) {
   
10. #if defined(RING_DEBUG)
    
11.     printk("[PF_RING] ring_mmap() failed: "
    
12.            "len is not multiple of PAGE_SIZE\n");
    
13. #endif
    
14.     return(-EINVAL);
    
15.   }
    
16. #if defined(RING_DEBUG)
    
17.   printk("[PF_RING] ring_mmap() called, size: %ld bytes\n", size);
    
18. #endif
    
19. 
    
20.   if((pfr->dna_device == NULL) && (pfr->ring_memory == NULL)) {
    
21. #if defined(RING_DEBUG)
    
22.     printk("[PF_RING] ring_mmap() failed: "
    
23.            "mapping area to an unbound socket\n");
    
24. #endif
    
25.     return -EINVAL;
    
26.   }
    
27. 
    
28.   //dns设备为空，即没有使用dns技术
    
29.   if(pfr->dna_device == NULL) {
    
30.     /* if userspace tries to mmap beyond end of our buffer, fail */
    
31.     //映射空间超限
    
32.     if(size > pfr->slots_info->tot_mem) {
    
33. #if defined(RING_DEBUG)
    
34.       printk("[PF_RING] ring_mmap() failed: "
    
35.              "area too large [%ld > %d]\n",
    
36.              size, pfr->slots_info->tot_mem);
    
37. #endif
    
38.       return(-EINVAL);
    
39.     }
    
40. #if defined(RING_DEBUG)
    
41.     printk("[PF_RING] mmap [slot_len=%d]"
    
42.            "[tot_slots=%d] for ring on device %s\n",
    
43.            pfr->slots_info->slot_len, pfr->slots_info->tot_slots,
    
44.            pfr->ring_netdev->name);
    
45. #endif
    
46.         //进行内存映射
    
47.     if((rc =
    
48.          do_memory_mmap(vma, size, pfr->ring_memory, VM_LOCKED,
    
49.                         0)) < 0)
    
50.       return(rc);
    
51.   } else {
    
52.     /* DNA Device */
    
53.     if(pfr->dna_device == NULL)
    
54.       return(-EAGAIN);
    
55. 
    
56.     switch (pfr->mmap_count) {
    
57.     case 0:
    
58.       if((rc = do_memory_mmap(vma, size,
    
59.                                (void *)pfr->dna_device->
    
60.                                packet_memory, VM_LOCKED,
    
61.                                1)) < 0)
    
62.         return(rc);
    
63.       break;
    
64. 
    
65.     case 1:
    
66.       if((rc = do_memory_mmap(vma, size,
    
67.                                (void *)pfr->dna_device->
    
68.                                descr_packet_memory, VM_LOCKED,
    
69.                                1)) < 0)
    
70.         return(rc);
    
71.       break;
    
72. 
    
73.     case 2:
    
74.       if((rc = do_memory_mmap(vma, size,
    
75.                                (void *)pfr->dna_device->
    
76.                                phys_card_memory,
    
77.                                (VM_RESERVED | VM_IO), 2)) < 0)
    
78.         return(rc);
    
79.       break;
    
80. 
    
81.     default:
    
82.       return(-EAGAIN);
    
83.     }
    
84. 
    
85.     pfr->mmap_count++;
    
86.   }
    
87. 
    
88. #if defined(RING_DEBUG)
    
89.   printk("[PF_RING] ring_mmap succeeded\n");
    
90. #endif
    
91. 
    
92.   return 0;
    
93. }

复制代码

实际上的内存映射工作，是由do_memory_mmap来完成的，这个函数实际上基本就是remap_pfn_range的包裹函数。
不过因为系统支持dna等技术，相应的mode参数有些变化，这里只分析了最基本的方法：mode == 0

1. static int do_memory_mmap(struct vm_area_struct *vma,
   
2.                           unsigned long size, char *ptr, u_int flags, int mode)
   
3. {
   
4.   unsigned long start;
   
5.   unsigned long page;
   
6. 
   
7.   /* we do not want to have this area swapped out, lock it */
   
8.   vma->vm_flags |= flags;
   
9.   start = vma->vm_start;
   
10. 
    
11.   while (size > 0) {
    
12.     int rc;
    
13. 
    
14.     if(mode == 0) {
    
15. #if(LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11))
    
16.           //根据地址，计算要映射的页帧
    
17.       page = vmalloc_to_pfn(ptr);
    
18.       //进行内存映射
    
19.       rc = remap_pfn_range(vma, start, page, PAGE_SIZE,
    
20.                            PAGE_SHARED);
    
21. #else
    
22.       page = vmalloc_to_page(ptr);
    
23.       page = kvirt_to_pa(ptr);
    
24.       rc = remap_page_range(vma, start, page, PAGE_SIZE,
    
25.                             PAGE_SHARED);
    
26. #endif
    
27.     } else if(mode == 1) {
    
28.       rc = remap_pfn_range(vma, start,
    
29.                            __pa(ptr) >> PAGE_SHIFT,
    
30.                            PAGE_SIZE, PAGE_SHARED);
    
31.     } else {
    
32.       rc = remap_pfn_range(vma, start,
    
33.                            ((unsigned long)ptr) >> PAGE_SHIFT,
    
34.                            PAGE_SIZE, PAGE_SHARED);
    
35.     }
    
36. 
    
37.     if(rc) {
    
38. #if defined(RING_DEBUG)
    
39.       printk("[PF_RING] remap_pfn_range() failed\n");
    
40. #endif
    
41.       return(-EAGAIN);
    
42.     }
    
43. 
    
44.     start += PAGE_SIZE;
    
45.     ptr += PAGE_SIZE;
    
46.     if(size > PAGE_SIZE) {
    
47.       size -= PAGE_SIZE;
    
48.     } else {
    
49.       size = 0;
    
50.     }
    
51.   }
    
52. 
    
53.   return(0);
    
54. }

复制代码

嗯，跳过了太多的细节，不过其mmap最核心的东东已经呈现出来。
如果要共享内核与用户空间内存，这倒是个现成的可借鉴的例子。

5、数据包的入队操作

做到这一步，准备工作基本上就完成了。因为PF_RING在初始化中，注册了prot_hook。其func指针指向packet_rcv函数：
当数据报文进入Linux网络协议栈队列时，netif_receive_skb会遍历这些注册的Hook：

1. int netif_receive_skb(struct sk_buff *skb)
   
2. {
   
3.         list_for_each_entry_rcu(ptype, &ptype_all, list) {
   
4.                 if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
   
5.                     ptype->dev == orig_dev) {
   
6.                         if (pt_prev)
   
7.                                 ret = deliver_skb(skb, pt_prev, orig_dev);
   
8.                         pt_prev = ptype;
   
9.                 }
   
10.         }
    
11. }

复制代码

相应的Hook函数得到调用：

1. static inline int deliver_skb(struct sk_buff *skb,
   
2.                               struct packet_type *pt_prev,
   
3.                               struct net_device *orig_dev)
   
4. {
   
5.         atomic_inc(&skb->users);        //注意，这里引用计数器被增加了
   
6.         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
   
7. }

复制代码

packet_rcv随之执行环形队列的入队操作：

1. static int packet_rcv(struct sk_buff *skb, struct net_device *dev,
   
2.                       struct packet_type *pt, struct net_device *orig_dev)
   
3. {
   
4.   int rc;
   
5. 
   
6.   //忽略本地环回报文
   
7.   if(skb->pkt_type != PACKET_LOOPBACK) {
   
8.           //进一步转向，最后一个参数直接使用-1，从上下文来看，写为RING_ANY_CHANNEL(其实也是-1)似乎可读性更强，
   
9.           //这里表示，如果从packet_rcv进入队列，由通道ID是“未指定的”，由skb_ring_handler来处理
   
10.     rc = skb_ring_handler(skb,
    
11.                           (skb->pkt_type == PACKET_OUTGOING) ? 0 : 1,
    
12.                           1, -1 /* unknown channel */);
    
13. 
    
14.   } else
    
15.     rc = 0;
    
16. 
    
17.   kfree_skb(skb);                                //所以，这里要做相应的减少
    
18.   return(rc);
    
19. }

复制代码

static int skb_ring_handler(struct sk_buff *skb,                                //要捕获的数据包
                            u_char recv_packet,                                                                //数据流方向，>0表示是进入(接收)方向
                            u_char real_skb /* 1=real skb, 0=faked skb */ ,
                            short channel_id)                                                                //通道ID
{
  struct sock *skElement;
  int rc = 0, is_ip_pkt;
  struct list_head *ptr;
  struct pfring_pkthdr hdr;
  int displ;
  struct sk_buff *skk = NULL;
  struct sk_buff *orig_skb = skb;

#ifdef PROFILING
  uint64_t rdt = _rdtsc(), rdt1, rdt2;
#endif

  //skb合法检查，包括数据流的方向
  if((!skb)                /* Invalid skb */
      ||((!enable_tx_capture) && (!recv_packet))) {
    /*
      An outgoing packet is about to be sent out
      but we decided not to handle transmitted
      packets.
    */
    return(0);
  }
#if defined(RING_DEBUG)
  if(1) {
    struct timeval tv;

    skb_get_timestamp(skb, &tv);
    printk
      ("[PF_RING] skb_ring_handler() [skb=%p][%u.%u][len=%d][dev=%s][csum=%u]\n",
       skb, (unsigned int)tv.tv_sec, (unsigned int)tv.tv_usec,
       skb->len,
       skb->dev->name == NULL ? "<NULL>" : skb->dev->name,
       skb->csum);
  }
#endif

        //如果通道ID未指定，根据进入的报文设备索引，设定之
#if(LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21))
  if(channel_id == RING_ANY_CHANNEL /* Unknown channel */ )
    channel_id = skb->iif;        /* Might have been set by the driver */
#endif

#if defined (RING_DEBUG)
  /* printk("[PF_RING] channel_id=%d\n", channel_id); */
#endif

#ifdef PROFILING
  rdt1 = _rdtsc();
#endif

  if(recv_packet) {
    /* Hack for identifying a packet received by the e1000 */
    if(real_skb)
      displ = SKB_DISPLACEMENT;
    else
      displ = 0;        /* Received by the e1000 wrapper */
  } else
    displ = 0;
        
  //解析数据报文，并判断是否为IP报文
  is_ip_pkt = parse_pkt(skb, displ, &hdr);

  //分片处理,是一个可选的功能项，事实上，对大多数包捕获工具而言，它们好像都不使用底层库来完成这一功能
  /* (de)Fragmentation < fusco@ntop.org > */
  if(enable_ip_defrag
      && real_skb && is_ip_pkt && recv_packet && (ring_table_size > 0)) {
    } else {
#if defined (RING_DEBUG)
        printk("[PF_RING] Do not seems to be a fragmented ip_pkt[iphdr=%p]\n",
               iphdr);
#endif
      }
    }
  }

  //按惯例，在报文的捕获首部信息中记录捕获的时间戳
  /* BD - API changed for time keeping */
#if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
  if(skb->stamp.tv_sec == 0)
    do_gettimeofday(&skb->stamp);
  hdr.ts.tv_sec = skb->stamp.tv_sec, hdr.ts.tv_usec = skb->stamp.tv_usec;
#elif(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
  if(skb->tstamp.off_sec == 0)
    __net_timestamp(skb);
  hdr.ts.tv_sec = skb->tstamp.off_sec, hdr.ts.tv_usec =
    skb->tstamp.off_usec;
#else /* 2.6.22 and above */
  if(skb->tstamp.tv64 == 0)
    __net_timestamp(skb);
  hdr.ts = ktime_to_timeval(skb->tstamp);
#endif

  //除了时间，还有长度，熟悉libpcap的话，这些操作应该很眼熟
  hdr.len = hdr.caplen = skb->len + displ;

  /* Avoid the ring to be manipulated while playing with it */
  read_lock_bh(&ring_mgmt_lock);

  /* 前面在创建sk时，已经看过ring_insert的入队操作了，现在要检查它的成员
  * 它们的关系是，通过ring_table的成员，获取到element，它里面封装了sk，
  *通过ring_sk宏，就可以得到ring_opt指针
   */
  list_for_each(ptr, &ring_table) {
    struct ring_opt *pfr;
    struct ring_element *entry;

    entry = list_entry(ptr, struct ring_element, list);

    skElement = entry->sk;
    pfr = ring_sk(skElement);
        
        //看来要加入社团，条件还是满多的,pfr不能为空，未指定集群cluster_id，槽位不能为空，方向要正确，绑定的网络设备
        //得对上号
        //另一种可能就是对bonding的支持，如果设备是从属设备，则应校验其主设备
    if((pfr != NULL)
        && (pfr->cluster_id == 0 /* No cluster */ )
        && (pfr->ring_slots != NULL)
        && is_valid_skb_direction(pfr->direction, recv_packet)
        && ((pfr->ring_netdev == skb->dev)
            || ((skb->dev->flags & IFF_SLAVE)
                && (pfr->ring_netdev == skb->dev->master)))) {
      /* We've found the ring where the packet can be stored */
      /* 从新计算捕获帧长度，是因为可能因为巨型帧的出现——超过了桶能容纳的长度 */
      int old_caplen = hdr.caplen;        /* Keep old lenght */
      hdr.caplen = min(hdr.caplen, pfr->bucket_len);
      /* 入队操作 */
      add_skb_to_ring(skb, pfr, &hdr, is_ip_pkt, displ, channel_id);
      hdr.caplen = old_caplen;
      rc = 1;        /* Ring found: we've done our job */
    }
  }

  /* [2] Check socket clusters */
  list_for_each(ptr, &ring_cluster_list) {
    ring_cluster_element *cluster_ptr;
    struct ring_opt *pfr;

    cluster_ptr = list_entry(ptr, ring_cluster_element, list);

    if(cluster_ptr->cluster.num_cluster_elements > 0) {
      u_int skb_hash = hash_pkt_cluster(cluster_ptr, &hdr);

      skElement = cluster_ptr->cluster.sk[skb_hash];

      if(skElement != NULL) {
        pfr = ring_sk(skElement);

        if((pfr != NULL)
            && (pfr->ring_slots != NULL)
            && ((pfr->ring_netdev == skb->dev)
                || ((skb->dev->flags & IFF_SLAVE)
                    && (pfr->ring_netdev ==
                        skb->dev->master)))
            && is_valid_skb_direction(pfr->direction, recv_packet)
            ) {
          /* We've found the ring where the packet can be stored */
          add_skb_to_ring(skb, pfr, &hdr,
                          is_ip_pkt, displ,
                          channel_id);
          rc = 1;        /* Ring found: we've done our job */
        }
      }
    }
  }

  read_unlock_bh(&ring_mgmt_lock);

#ifdef PROFILING
  rdt1 = _rdtsc() - rdt1;
#endif

#ifdef PROFILING
  rdt2 = _rdtsc();
#endif

  /* Fragment handling */
  if(skk != NULL)
    kfree_skb(skk);

  if(rc == 1) {
    if(transparent_mode != driver2pf_ring_non_transparent) {
      rc = 0;
    } else {
      if(recv_packet && real_skb) {
#if defined(RING_DEBUG)
        printk("[PF_RING] kfree_skb()\n");
#endif

        kfree_skb(orig_skb);
      }
    }
  }
#ifdef PROFILING
  rdt2 = _rdtsc() - rdt2;
  rdt = _rdtsc() - rdt;

#if defined(RING_DEBUG)
  printk
    ("[PF_RING] # cycles: %d [lock costed %d %d%%][free costed %d %d%%]\n",
     (int)rdt, rdt - rdt1,
     (int)((float)((rdt - rdt1) * 100) / (float)rdt), rdt2,
     (int)((float)(rdt2 * 100) / (float)rdt));
#endif
#endif

  //printk("[PF_RING] Returned %d\n", rc);
  return(rc);                /*  0 = packet not handled */
}

上面跳过了对cluster(集群)的分析，PF_RING允许同时对多个接口捕获报文，而并不是一个。这就是集群。看一下它用户态的注释就一目了然了：

1.                         /* Syntax
   
2.                         ethX@1,5       channel 1 and 5
   
3.                         ethX@1-5       channel 1,2...5
   
4.                         ethX@1-3,5-7   channel 1,2,3,5,6,7
   
5.                         */

复制代码

进一步的入队操作，是通过add_skb_to_ring来完成的：

1. static int add_skb_to_ring(struct sk_buff *skb,
   
2.                            struct ring_opt *pfr,
   
3.                            struct pfring_pkthdr *hdr,
   
4.                            int is_ip_pkt, int displ, short channel_id)
   
5. {
   
6.       //add_skb_to_ring函数比较复杂，因为它要处理过滤器方面的问题。
   
7.       //关于PF_RING的过滤器，可以参考[url]http://luca.ntop.org/Blooms.pdf[/url]
   
8.       //获取更多内容。这里不做详细讨论了。或者留到下回分解吧。
   
9.       
   
10.       //最终入队操作，是通过调用dd_pkt_to_ring来实现的。
    
11.       add_pkt_to_ring(skb, pfr, hdr, displ, channel_id,
    
12.                       offset, mem);        
    
13. }

复制代码

1. static void add_pkt_to_ring(struct sk_buff *skb,
   
2.                             struct ring_opt *pfr,
   
3.                             struct pfring_pkthdr *hdr,
   
4.                             int displ, short channel_id,
   
5.                             int offset, void *plugin_mem)
   
6. {
   
7.   char *ring_bucket;
   
8.   int idx;
   
9.   FlowSlot *theSlot;
   
10.   int32_t the_bit = 1 << channel_id;
    
11. 
    
12. #if defined(RING_DEBUG)
    
13.   printk("[PF_RING] --> add_pkt_to_ring(len=%d) [pfr->channel_id=%d][channel_id=%d]\n",
    
14.          hdr->len, pfr->channel_id, channel_id);
    
15. #endif
    
16. 
    
17.   //检查激活标志
    
18.   if(!pfr->ring_active)
    
19.     return;
    
20. 
    
21.   if((pfr->channel_id != RING_ANY_CHANNEL)
    
22.       && (channel_id != RING_ANY_CHANNEL)
    
23.       && ((pfr->channel_id & the_bit) != the_bit))
    
24.     return; /* Wrong channel */
    
25. 
    
26.   //写锁
    
27.   write_lock_bh(&pfr->ring_index_lock);
    
28.   //获取前一次插入的位置索引
    
29.   idx = pfr->slots_info->insert_idx;
    
30.   //调用get_insert_slot获取当前要捕获数据报文的合适的槽位
    
31.   //这里idx++后，指向了下一次插入的位置索引
    
32.   idx++, theSlot = get_insert_slot(pfr);
    
33.   //累计计数器
    
34.   pfr->slots_info->tot_pkts++;
    
35. 
    
36.   //没位子了，累计丢包计数器，返回之
    
37.   if((theSlot == NULL) || (theSlot->slot_state != 0)) {
    
38.     /* No room left */
    
39.     pfr->slots_info->tot_lost++;
    
40.     write_unlock_bh(&pfr->ring_index_lock);
    
41.     return;
    
42.   }
    
43. 
    
44.   //获取当前槽位的桶
    
45.   ring_bucket = &theSlot->bucket;
    
46. 
    
47.   //支持插件？？在最开始处记录插件信息？？
    
48.   if((plugin_mem != NULL) && (offset > 0))
    
49.     memcpy(&ring_bucket[sizeof(struct pfring_pkthdr)], plugin_mem, offset);  
    
50. 
    
51.   if(skb != NULL) {
    
52.           //重新计算捕获帧长度
    
53.     hdr->caplen = min(pfr->bucket_len - offset, hdr->caplen);
    
54. 
    
55.     if(hdr->caplen > 0) {
    
56. #if defined(RING_DEBUG)
    
57.       printk("[PF_RING] --> [caplen=%d][len=%d][displ=%d][parsed_header_len=%d][bucket_len=%d][sizeof=%d]\n",
    
58.          hdr->caplen, hdr->len, displ,
    
59.              hdr->parsed_header_len, pfr->bucket_len,
    
60.              sizeof(struct pfring_pkthdr));
    
61. #endif
    
62.       //拷贝捕获的数据报文，前面空了两个栏位：一个是pkthdr首部，一个是插件offset长度
    
63.       //这里经过了一次数据拷贝，对于完美主义者，这并不是一个好的方法。但是PF_RING定位于一个
    
64.       //通用的接口库，似乎只有这么做了。否则，追求“零拷贝”，为了避免这一次拷贝，只有逐个修改网卡驱动了。
    
65.       skb_copy_bits(skb, -displ,
    
66.                     &ring_bucket[sizeof(struct pfring_pkthdr) + offset], hdr->caplen);
    
67.     } else {
    
68.       if(hdr->parsed_header_len >= pfr->bucket_len) {
    
69.         static u_char print_once = 0;
    
70. 
    
71.         if(!print_once) {
    
72.           printk("[PF_RING] WARNING: the bucket len is [%d] shorter than the plugin parsed header [%d]\n",
    
73.              pfr->bucket_len, hdr->parsed_header_len);
    
74.           print_once = 1;
    
75.         }
    
76.       }
    
77.     }
    
78.   }
    
79. 
    
80.   //记录首部
    
81.   memcpy(ring_bucket, hdr, sizeof(struct pfring_pkthdr)); /* Copy extended packet header */
    
82. 
    
83.   //前面idx已经自加过了，判断是否队列已满，若满，归零，否则更新插入索引
    
84.   if(idx == pfr->slots_info->tot_slots)
    
85.     pfr->slots_info->insert_idx = 0;
    
86.   else
    
87.     pfr->slots_info->insert_idx = idx;
    
88. 
    
89. #if defined(RING_DEBUG)
    
90.   printk("[PF_RING] ==> insert_idx=%d\n", pfr->slots_info->insert_idx);
    
91. #endif
    
92. 
    
93.   //累计插入计数器
    
94.   pfr->slots_info->tot_insert++;
    
95.   //槽位就绪标记，用户空间可以来取了
    
96.   theSlot->slot_state = 1;
    
97.   write_unlock_bh(&pfr->ring_index_lock);
    
98. 
    
99.   //有的时候会出现，用户空间取不到的情况，如队列为空。这样，用户空间调用poll等待数据。这里做相应的唤醒处理
    
100.   /* wakeup in case of poll() */
     
101.   if(waitqueue_active(&pfr->ring_slots_waitqueue))
     
102.     wake_up_interruptible(&pfr->ring_slots_waitqueue);
     
103. }

复制代码

槽位的计算:

1. 在ring_bind函数中，分配空间后，使用ring_slots做为槽位指针。事实上，这里要计算槽位，就是通过索引号 * 槽位长度来得到：
   
2. static inline FlowSlot *get_insert_slot(struct ring_opt *pfr)
   
3. {
   
4.   if(pfr->ring_slots != NULL) {
   
5.     FlowSlot *slot =
   
6.       (FlowSlot *) & (pfr->
   
7.                       ring_slots[pfr->slots_info->insert_idx *
   
8.                                  pfr->slots_info->slot_len]);
   
9. #if defined(RING_DEBUG)
   
10.     printk
    
11.       ("[PF_RING] get_insert_slot(%d): returned slot [slot_state=%d]\n",
    
12.        pfr->slots_info->insert_idx, slot->slot_state);
    
13. #endif
    
14.     return(slot);
    
15.   } else {
    
16. #if defined(RING_DEBUG)
    
17.     printk("[PF_RING] get_insert_slot(%d): NULL slot\n",
    
18.            pfr->slots_info->insert_idx);
    
19. #endif
    
20.     return(NULL);
    
21.   }
    
22. }

复制代码