socket的创建（六）

素颜马尾好姑娘i 2022-09-30 09:44 153阅读 0赞

Socket的创建函数，在PF\_RING，创建sokcet的函数为ring\_create，当pfring.c中通过sokcet函数建立socket时，内核调用的ring\_create函数，ring\_create源码如下：

staticint ring\_create(

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

struct net \*net,

\#endif

struct socket \*sock, int protocol

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

, intkern

\#endif

)

struct sock \*sk;

struct pf\_ring\_socket \*pfr;

int err = -ENOMEM;

if(enable\_debug)

printk("\[PF\_RING\]ring\_create()\\n");

/\* Are you root, superuseror so ?  权限验证\*/

if(!capable(CAP\_NET\_ADMIN))

return -EPERM;

//协议簇验证

if(sock->type != SOCK\_RAW)

return -ESOCKTNOSUPPORT;

//协议验证

if(protocol != htons(ETH\_P\_ALL))

return -EPROTONOSUPPORT;

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

sk = sk\_alloc(PF\_RING, GFP\_KERNEL, 1, NULL);             //内核版本<2.6.11

\#else

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

// BD: API changed in2.6.12, ref:

//http://svn.clkao.org/svnweb/[Linux][]/revision/?rev=28201

sk = sk\_alloc(PF\_RING, GFP\_ATOMIC,&ring\_proto, 1); //内核版本 小于2.6.24

\#else

sk = sk\_alloc(net, PF\_INET, GFP\_KERNEL,&ring\_proto); //内核版本 大于2.6.24

//根据内核版本的不同，调用不同的sk\_alloc分配内存；

\#endif

//sk内存分配失败

if(sk == NULL)

goto out;

sock->ops = &ring\_ops;

/\*设定sock的ops，这样当用户采用bind，connect等函数时，内核对应相应的处理函数；下面看看ring\_ops结构体的定义；

static struct proto\_ops ring\_ops = \{

.family = PF\_RING,

.owner = THIS\_MODULE,

/\* Operations that make nosense on ring sockets. 这些操作在ring socket中没有使用\*/

.connect = sock\_no\_connect,

.socketpair =sock\_no\_socketpair,

.accept = sock\_no\_accept,

.getname = sock\_no\_getname,

.listen = sock\_no\_listen,

.shutdown =sock\_no\_shutdown,

.sendpage =sock\_no\_sendpage,

/\* Now the operations thatreally occur. 下面的函数在ring socket使用\*/

.release = ring\_release,

.bind = ring\_bind,

.mmap = ring\_mmap,

.poll = ring\_poll,

.setsockopt = ring\_setsockopt,

.getsockopt =ring\_getsockopt,

.ioctl = ring\_ioctl,

.recvmsg = ring\_recvmsg,

.sendmsg = ring\_sendmsg,

\};

也就是说当应用程序采用bind绑定时，内核是调用的ring\_bind函数，而应用程序调用mmap函数时，内核调用的是ring\_mmap函数；当应用程序调用setsockopt/getsockopt函数时，内核调用的是ring\_setsockopt/ring\_getsockopt；

思考题2：它们是怎么对应起来的呢，原理是怎样的？

可以参考linux内核情景分析，熟悉socket机制

\*/

sock\_init\_data(sock, sk);

// 初始化sock结构(即sk)各成员，并设定与套接字socket(即sock)的关联

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

sk\_set\_owner(sk, THIS\_MODULE);               //设置owner

\#endif

ring\_sk(sk) =ring\_sk\_datatype(kmalloc(sizeof(\*pfr), GFP\_KERNEL));

/\*ring\_sk和ring\_sk\_datatype是什么东东，是函数吗，没见过这么用的，难道是宏，一般也要使用大写啊，跟踪下源码。

\#define ring\_sk\_datatype(\_\_sk) ((struct pf\_ring\_socket \*)\_\_sk)

ring\_sk\_datatype(kmalloc(sizeof(\*pfr), GFP\_KERNEL))就是分配pf\_ring\_socket大小的内存，

\#define ring\_sk(\_\_sk) ((\_\_sk)->sk\_protinfo)

sk->sk\_protinfo指向pf\_ring\_socket大小的内存；

\*/

//内存分配失败

if(!(pfr = ring\_sk(sk))) \{

sk\_free(sk);

goto out;

//将pfr指向的内存清0，// pfr初始化各个成员

memset(pfr, 0, sizeof(\*pfr));

//激活标志

pfr->ring\_active = 0;  /\* We activate assoon as somebody waits for packets \*/

pfr->num\_rx\_channels =UNKNOWN\_NUM\_RX\_CHANNELS;

// 通道ID

pfr->channel\_id = RING\_ANY\_CHANNEL;

//RING的每个槽位的桶的大小,用户态也可以使用setsocketopt来调整

pfr->bucket\_len = DEFAULT\_BUCKET\_LEN;

pfr->poll\_num\_pkts\_watermark = 1; //DEFAULT\_MIN\_PKT\_QUEUED;

//过滤器hash

pfr->handle\_hash\_rule =handle\_sw\_filtering\_hash\_bucket;

pfr->add\_packet\_to\_ring =add\_packet\_to\_ring;

//初始化等待队列

init\_waitqueue\_head(&pfr->ring\_slots\_waitqueue);

//初始化RING的锁

rwlock\_init(&pfr->ring\_index\_lock);

rwlock\_init(&pfr->ring\_rules\_lock);

//初始化使用的用户

atomic\_set(&pfr->num\_ring\_users, 0);

INIT\_LIST\_HEAD(&pfr->sw\_filtering\_rules);

INIT\_LIST\_HEAD(&pfr->hw\_filtering\_rules);

//设定协议簇

sk->sk\_family = PF\_RING;

sk->sk\_destruct = ring\_sock\_destruct;

//将sk插入队列

ring\_insert(sk);

/\*

ring\_insert将刚刚创建的套接字插入ring\_table，源码如下：

static inline void ring\_insert(struct sock \*sk)

struct ring\_element \*next;

/\*

struct ring\_element \{

struct list\_head list;

/\*

list\_head的结构体定义如下：

structlist\_head \{

struct list\_head \*next, \*prev;

\*/

struct sock     \*sk;

\};

\*/

struct pf\_ring\_socket \*pfr;

if(enable\_debug)

printk("\[PF\_RING\]ring\_insert()\\n");

next = kmalloc(sizeof(struct ring\_element),GFP\_ATOMIC);

if(next != NULL) \{

next->sk = sk;

ring\_write\_lock();

list\_add(&next->list,&ring\_table);

/\*

static struct list\_headring\_table;   //呵呵，ring\_table是一个链表的表头

那么list\_add函数的作用就是在链表ring\_table的前面插入一个节点next->list

List\_add函数定义如下：

staticinline void list\_add(struct list\_head \*new,struct list\_head \*head)

\_\_list\_add(new, head, head->next);

其中\_list\_add定义如下：

\#ifndef CONFIG\_DEBUG\_LIST

static inlinevoid \_\_list\_add(struct list\_head \*new,

struct list\_head \*prev,

struct list\_head \*next)

next->prev = new;

new\->next = next;

new\->prev = prev;

prev->next = new;

\#else

extern void \_\_list\_add(struct list\_head \*new,

struct list\_head \*prev,

struct list\_head \*next);

\#endif

而\_list\_add函数根据是否定义CONFIG\_DEBUG\_LIST,有不同的实现，没有定义CONFIG\_DEBUG\_LIST,插入的方法是在链表的prev和next之间插入一个新的节点new，如果定义了CONFIG\_DEBUG\_LIST那么执行的函数不一样了。搜了一下，没有找到下面的那个\_list\_add，应该这个的作用和上面那个一样，插入一个节点。

\*/

ring\_write\_unlock();

\} else \{

if(net\_ratelimit())

printk("\[PF\_RING\]net\_ratelimit() failure\\n");

ring\_table\_size++;

pfr = (structpf\_ring\_socket \*)ring\_sk(sk);

pfr->ring\_pid =current->pid;

\*/

pfr->master\_ring = NULL;

pfr->ring\_netdev =&none\_device\_element; /\* Unbound socket \*/

pfr->sample\_rate = 1; /\* No sampling \*/

pfr->ring\_id = ring\_id\_serial++;

ring\_proc\_add(pfr);

if(enable\_debug)

printk("\[PF\_RING\] ring\_create():created\\n");

return(0);

out:

return err;

其中ring\_proc\_add函数定义如下，这个函数再前面的讲解中已经提到过了：

staticvoid ring\_proc\_add(struct pf\_ring\_socket \*pfr)

int debug = 0;

if(ring\_proc\_dir != NULL) \{

char name\[64\];

snprintf(name, sizeof(name),"%d-%s.%d", pfr->ring\_pid,

pfr->ring\_netdev->dev->name, pfr->ring\_id);

create\_proc\_read\_entry(name,0 /\* read-only \*/,

ring\_proc\_dir,

ring\_proc\_get\_info, pfr);

//create\_proc\_read\_entry函数的作用是创建一个目录

if(debug) printk("\[PF\_RING\] Added/proc/net/pf\_ring/%s\\n", name);

讲到这里了，有必要总结一下，ring\_create函数的作用，ring\_create函数通过调用sk\_alloc分配PF\_RING的sock结构，然后使用sock\_init\_data初始化sock，专门用于描述特定net簇的私有区域的sock->sk\_protinfo会被初始化为ring\_opt类型指针\*pfr，pfr包含了接收和插入数据包所需要的最基本的信息，有了pfr结构就有了PF\_RING的一切信息，最后将生成的sock插入到ring\_table。

[Linux]: http://lib.csdn.net/base/linux