PF_RING模块初始化（五）

旧城等待， 2022-09-30 09:44 111阅读 0赞

Linux2.6的内核后对模块机制更加重视了，因为模块可以很方便的添加到内核，也可以很方便的从内核移除，对于驱动程序来说是一个很方便的事情，当需要该模块的时候采用insmod插入到内核，不需要时可以采用rmmod从内核很方便的删除，这样可以避免内核由于外设驱动程序的增多还不断庞大，[Linux][]和windows的一个区别就是linux的内核和应用程序是可以定制的，这样用户可以根据自己的需要进行配置，减少不必要的东西，加快内核的效率，提高运行的速度，当然这样比较windows来说，对用户的水平要求更高了，必须安装一个软件，有许多依赖，一般的用户还搞不定。

模块要能很方便的添加到内核和从内核很方便的删除，就必须有初始化的函数和退出的函数，就好像我们main函数及windows的DriverEntry函数一样，初始化函数就是第一个运行的函数，我们讲到内核，首先必须讲解初始化的函数，也可以说是一个宏吧。Linux调用insmod时，其实通过一个宏module\_init进行模块的初始化，而rmmod通过调用module\_exit从内核将模块删除。一般模块必须包含的头文件如下：

\#include <linux/init.h>

\#include <linux/module.h>

包含init.h的目的是指定初始化和清除函数，包含module.h就是包含装载模块需要的符号和函数的定义。

下面开始讲解PF\_RING的模块初始化函数及退出函数吧，还是回到源码，以源码说话，讲解的更加清楚。

PF\_RING的初始化函数就是ring\_init，源码如下：

staticint \_\_init ring\_init(void)

static structnet\_device any\_dev, none\_dev;

int i;

\#if(LINUX\_VERSION\_CODE> KERNEL\_VERSION(2,6,11))

int rc;

\#endif

// PF\_RING只有在2.6.11以后的内核才能正常使用

printk("\[PF\_RING\] Welcome to PF\_RING %s($Revision: %s$)\\n"

RING\_VERSION, SVN\_REV);

//printk为内核打印语句函数，相当于应用程序中的printf函数一样；

\#if(LINUX\_VERSION\_CODE> KERNEL\_VERSION(2,6,11))

if((rc = proto\_register(&ring\_proto, 0))!= 0)

return(rc);

\#endif

// 如果内核版本大于2.6.11的话，调用proto\_register函数，该函数作用是注册PF\_RING新协议，下面的INIT\_LIST\_HEAD的作用是初始化4个链表；

INIT\_LIST\_HEAD(&ring\_table);

INIT\_LIST\_HEAD(&ring\_cluster\_list);

INIT\_LIST\_HEAD(&ring\_aware\_device\_list);

INIT\_LIST\_HEAD(&ring\_dna\_devices\_list);

for(i = 0; i < MAX\_NUM\_DEVICES; i++)

INIT\_LIST\_HEAD(&device\_ring\_list\[i\]);

/\* MAX\_NUM\_DEVICES在pf\_ring.h中定义，其值256，

INIT\_LIST\_HEAD(&device\_ring\_list\[i\])的作用是初始化256个链表，在看看device\_ring\_list这个结构，同样在pf\_ring.h定义，其实它就是一个数组，定义如下：

/\*For each device, pf\_ring keeps a list of the number of

available ring socketslots. So that a caller knows in advance whether

there are slots available(for rings bound to such device)

that can potentially hostthe packet

\*/

static struct list\_head device\_ring\_list\[MAX\_NUM\_DEVICES\];

\*/

init\_ring\_readers();

/\* init\_ring\_readers函数定义如下：

inline voidinit\_ring\_readers(void) \{

atomic\_set(&num\_ring\_readers, 0);

atomic\_set(&ring\_stop, 0);

\*/

memset(&any\_dev, 0, sizeof(any\_dev));

//将any\_dev结构的内存置为0

strcpy(any\_dev.name, "any");

any\_dev.ifindex = MAX\_NUM\_IFIDX-1,any\_dev.type = ARPHRD\_ETHER;

memset(&any\_device\_element, 0,sizeof(any\_device\_element));

/\*

any\_device\_element结构体的定义如下：

typedef struct \{

pfring\_device\_typedevice\_type; /\* Device Type \*/

struct net\_device \*dev;

struct proc\_dir\_entry\*proc\_entry;

/\* Hardware Filters \*/

struct \{

u\_int16\_t num\_filters;

hw\_filtering\_device\_handler filter\_handlers;

\} hw\_filters;

struct list\_headdevice\_list;

\} ring\_device\_element;

static ring\_device\_element any\_device\_element, none\_device\_element;

\*/

any\_device\_element.dev = &any\_dev,any\_device\_element.device\_type = standard\_nic\_family;

memset(&none\_dev, 0, sizeof(none\_dev));

strcpy(none\_dev.name, "none");

none\_dev.ifindex = MAX\_NUM\_IFIDX-2;

memset(&none\_device\_element, 0,sizeof(none\_device\_element));

none\_device\_element.dev = &none\_dev,none\_device\_element.device\_type = standard\_nic\_family;

//创建/proc/net/pfring目录

ring\_proc\_init();

/\*

有必要好好研究下ring\_proc\_init，看怎样创建/proc目录呢，还是先看这个函数的源码吧。

static void ring\_proc\_init(void)

ring\_proc\_dir =proc\_mkdir("pf\_ring",

\#if(LINUX\_VERSION\_CODE >=KERNEL\_VERSION(2,6,24))

init\_net.                //如果版本大于2.6.24

\#endif

proc\_net);

//上面的proc\_mkdir的作用是建立一个pf\_ring的目录，/proc/net/pfring

if(ring\_proc\_dir) \{

\#if(LINUX\_VERSION\_CODE <KERNEL\_VERSION(2,6,30))

ring\_proc\_dir->owner = THIS\_MODULE;         //如果版本大于2.6.30

\#endif

ring\_proc\_dev\_dir = proc\_mkdir(PROC\_DEV, ring\_proc\_dir);

/\*proc\_mkdir的函数原型是怎样的呢，linux没有像vc中的msdn，只要借助google搜一下，struct proc\_dir\_entry\*proc\_mkdir(const char \*name, struct proc\_dir\_entry \*parent);

:类似于mkdir()函数，name是目录名，parent是要创建的目录的父目录名（若parent = NULL则创建在/proc目录下）。是不是创建一个目录/proc/net/pfring/dev,有待验证。

\*/

ring\_proc = create\_proc\_read\_entry(PROC\_INFO, 0 /\* read-only \*/,

ring\_proc\_dir,

ring\_proc\_get\_info, NULL);

/\*

**struct**proc\_dir\_entry\*create\_proc\_read\_entry (**constchar**\*name,mode\_tmode,**struct**proc\_dir\_entry\*base,read\_proc\_t\*read\_proc,**void**\*data);

说明：  
name : 要创建的文件名；  
mode : 文件掩码，为 0 则按照系统默认的掩码创建文件。  
base : 指定该文件所在的目录，如果为 NULL，则文件被创建在 /proc根目录下。  
read\_proc : 实现该文件的 read\_proc函数。也就是说，当我们读取 "name"这个文件时(如 cat /proc/myproc\_name)，读取请求会通过这个函数发送到驱动模块，然后在函数里处理的数据会写到 myproc\_name文件中。  
data : 内核忽略此参数，但会把它当作参数传递给 read\_proc这个自定义函数。

函数功能：在ring\_proc\_dir目录下创建一个PROC\_INFO的文件

对照函数实参和形参可以看出，该函数放在这里的作用了，当我们cat/proc/net/pfring/info时，通过ring\_proc\_get\_info函数将请求发送给驱动模块，然后将得到的结果保存在info文件中。

和create\_proc\_read\_entry类似的函数还有一个create\_proc\_entry函数，该函数的作用同样用来建立/proc文件，它比create\_proc\_read\_entry()更为底层，它的原型如下：

**struct**proc\_dir\_entry\*create\_proc\_entry (**constchar**\*name,mode\_tmode,**struct**proc\_dir\_entry\*parent);

它只有3个参数，和create\_proc\_read\_entry()一样，分别是name:文件名字，mode：掩码，parent：父目录；

\*/

ring\_proc\_plugins\_info =

create\_proc\_read\_entry(PROC\_PLUGINS\_INFO, 0 /\* read-only\*/,

ring\_proc\_dir,

ring\_proc\_get\_plugin\_info, NULL);

if(!ring\_proc || !ring\_proc\_plugins\_info)

printk("\[PF\_RING\] unable to register proc file\\n");

else \{

\#if(LINUX\_VERSION\_CODE <KERNEL\_VERSION(2,6,30))

ring\_proc->owner = THIS\_MODULE;

ring\_proc\_plugins\_info->owner =THIS\_MODULE;

\#endif

printk("\[PF\_RING\] registered/proc/net/pf\_ring/\\n");

\} else

printk("\[PF\_RING\] unable to create /proc/net/pf\_ring\\n");

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* \*/

\*/

// ring\_proc\_init();函数分析完了，从分析中可以看出该函数的作用是创建/proc/net/pfring/目录。

//注册新协议sock

sock\_register(&ring\_family\_ops);

/\*饭要一口一口的吃，程序要一行一行的看，下面轮到解析sock\_register函数了，呵呵，这个函数的作用是注册新协议sock，先看看这个函数的源码：首先解释一下实参：

static structnet\_proto\_family ring\_family\_ops = \{

.family = PF\_RING,

.create = ring\_create,

.owner = THIS\_MODULE,

\};

在include/linux/socket.h中找到这个结构体的定义；

struct net\_proto\_family \{  
int   family;                                                    // family为域编号，在本文中指的是PF\_RING  
int   (\*create)(struct socket \*sock, int protocol);  //内核实现socket系统调用的函数  
short   authentication;  
short   encryption;  
short   encrypt\_net;  
struct module \*owner;  //  
\};

当用户创建PF\_RING时， 如我们在Pfring.c文件中讲解pfring\_open\_consumer时，讲到创建了一个socket，然后bind，即 ring->fd = socket(PF\_RING, SOCK\_RAW, htons(ETH\_P\_ALL));

ring\_create函数通过调用sock\_create进行创建，sock\_create调用\_\_sock\_create。\_\_sock\_create要创建一个struct socket，这是一个普通BSD socket的结构体，其定义如下：  
struct socket \{  
socket\_state   state;  
unsigned long   flags;  
struct proto\_ops \*ops;  
struct fasync\_struct \*fasync\_list;  
struct file   \*file;  
struct sock   \*sk;  
wait\_queue\_head\_t wait;  
short    type;  
\};

sock\_register函数的源码在/net/socket.c中，定义如下：

int sock\_register(const structnet\_proto\_family \*ops)

interr;

if(ops->family >= NPROTO) \{

printk(KERN\_CRIT"protocol %d >= NPROTO(%d)\\n", ops->family,

NPROTO);

return-ENOBUFS;

spin\_lock(&net\_family\_lock);

if(net\_families\[ops->family\])

err= -EEXIST;

else\{

net\_families\[ops->family\]= ops;         //注册一个协议PF\_RING

err= 0;

spin\_unlock(&net\_family\_lock);

printk(KERN\_INFO“NET: Registered protocol family %d\\n”, ops->family);

returnerr;

思考题：为什么应用空间调用socket时，ring\_create会自动调用？

\*/

/\*注册通知链表 ，将ring\_netdev\_notifier按照优先级插入到链表 netdev\_chain中，这样因为每一个协议都调用register\_netdevice\_notifier函数注册了一个ring\_netdev\_notifier的结构体，而netdev\_chain的作用就是当外界调用相应的ioctl的时候通知这个链表上所有相关的设备（notifier\_call函数）;

\*/

//ring\_netdev\_notifier的定义如下：

/\* static struct notifier\_block ring\_netdev\_notifier = \{

.notifier\_call =ring\_notifier,     //pf\_ring.c中有函数源码

\};

struct notifier\_block类型，这个struct是在include/linux/notifier.h里面的：  
struct notifier\_block   
\{   
int (\*notifier\_call)(struct notifier\_block \*self, unsigned long, void \*);   
struct notifier\_block \*next;   
int priority;   
\};   
当系统调用notifier\_call时，就会调用ring\_notifier函数；  
而register\_netdevice\_notifier函数在net/core/dev.c里面，是这样的：   
int register\_netdevice\_notifier(struct notifier\_block \*nb)   
\{   
    return notifier\_chain\_register(&netdev\_chain, nb);   
\}   
  
而 notifier\_chain\_register函数在include/linux/notifier.h里面，是这样的:   
extern \_\_inline\_\_ intnotifier\_chain\_register(struct notifier\_block \*\*list, struct notifier\_block \*n)  
\{   
while(\*list)   
\{   
if(n->priority > (\*list)->priority)         //优先级判断  
break;   
list= &((\*list)->next);   
\}   
n->next = \*list;   
\*list=n;   
return 0;   
\}

这个函数的作用是将按照n的优先级将n插入到链表中的对应位置；

\*/

/\* Sanity check \*/

if(transparent\_mode > driver2pf\_ring\_non\_transparent)

transparent\_mode = standard\_linux\_path;

//工作模式有3种，感兴趣可以去看pf\_ring的文档

typedef enum \{

standard\_linux\_path =0, /\* Business as usual \*/

driver2pf\_ring\_transparent= 1, /\* Packets are still delivered to the kernel \*/

driver2pf\_ring\_non\_transparent= 2 /\* Packets not delivered to the kernel \*/

\} direct2pf\_ring;

printk("\[PF\_RING\] Min \# ring slots%d\\n", min\_num\_slots);

printk("\[PF\_RING\] Slot version     %d\\n",

RING\_FLOWSLOT\_VERSION);

printk("\[PF\_RING\] Capture TX       %s\\n",

enable\_tx\_capture ? "Yes \[RX+TX\]" :"No \[RX only\]");

printk("\[PF\_RING\] Transparent Mode%d\\n",

transparent\_mode);

printk("\[PF\_RING\] IP Defragment    %s\\n",

enable\_ip\_defrag ? "Yes" :"No");

printk("\[PF\_RING\] Initializedcorrectly\\n");

/\*

上面这一连串的printk函数的作用是打印PF\_RING的一些信息，比如是槽位总数，我的版本为4096个槽位，Slot版本号，是否使能enable\_tx\_capture，如果使能的话，能够同时捕获发送数据包和接收数据包，Transparent Mode有3种模式,0，1，2，具体这里就不说了，可以看PF\_RING的文档，里面讲的很详细了。Ip Defragment，是否支持ip分段。

\*/

/\*

void register\_device\_handler(void) \{

if(transparent\_mode !=standard\_linux\_path) return;

/\*如果不是第一种模式，直接返回，所以register\_device\_handler()第2种模式和第3种模式时，这个函数是不会调用的\*/

prot\_hook.func =packet\_rcv;           //packet 包接收hook函数，只在第一种模式下有用;

prot\_hook.type =htons(ETH\_P\_ALL);

dev\_add\_pack(&prot\_hook);               //将prot\_hook的结构插入链表;

SOCK\_PACKET的实现就是用dev\_add\_pack()；dev\_add\_pack函数在/net/core/dev.c中定义；

void dev\_add\_pack(struct packet\_type \*pt)

int hash;

spin\_lock\_bh(&ptype\_lock);

if (pt->type ==htons(ETH\_P\_ALL))

list\_add\_rcu(&pt->list,&ptype\_all);

else \{

hash =ntohs(pt->type) & PTYPE\_HASH\_MASK;

list\_add\_rcu(&pt->list, &ptype\_base\[hash\]);

spin\_unlock\_bh(&ptype\_lock);

EXPORT\_SYMBOL(dev\_add\_pack);

在goolge上搜list\_add\_rcu的函数原型定义如下（include/list.h），版本不是我的2.6.35，估先分析下下面这个的作用，就是将一个在链表中插入一个新的节点：

static inline void \_\_list\_add\_rcu(structlist\_head \* new,   
struct list\_head \* prev, struct list\_head \* next)   
\{   
new->next = next;   
new->prev = prev;   
smp\_wmb();               //执行完前面2句才能执行后面两句  
next->prev = new;   
prev->next = new;   
\}

既然和我的内核不一致，那么没办法，只有在2.6.35中搜这个函数了。在include/linux/rculist.h

18 static inline void __list_add_rcu(struct list_head *new,

19                 struct list_head *prev, struct list_head *next)

20 {

21         new->next = next;

22         new->prev = prev;

23         rcu_assign_pointer(prev->next, new);

24         next->prev = new;

25 }

43 static inline void list_add_rcu(struct list_head *new, struct list_head *head)

44 {

45         __list_add_rcu(new, head, head->next);