用户空间和内核空间通讯之【Netlink 下】

太过爱你忘了你带给我的痛 2022-08-07 12:49 257阅读 0赞

关于Netlink多播机制的用法

在上一篇博文中我们所遇到的情况都是用户空间作为消息进程的发起者，Netlink还支持内核作为消息的发送方的情况。这一般用于内核主动向用户空间报告一些内核状态，例如我们在用户空间看到的USB的热插拔事件的通告就是这样的应用。

先说一下我们的目标，内核线程每个一秒钟往一个多播组里发送一条消息，然后用户空间所以加入了该组的进程都会收到这样的消息，并将消息内容打印出来。

Netlink地址结构体中的nl\_groups是32位，也就是说每种Netlink协议最多支持32个多播组。如何理解这里所说的每种Netlink协议？在</usr/include/linux/netlink.h>里预定义的如下协议都是Netlink协议簇的具体协议，还有我们添加的NETLINK\_TEST也是一种Netlink协议。

点击(此处)折叠或打开

1.  \#define NETLINK\_ROUTE 0 /\* Routing/device hook \*/  
    
2.  \#define NETLINK\_UNUSED 1 /\* Unused number \*/  
    
3.  \#define NETLINK\_USERSOCK 2 /\* Reserved for user mode socket protocols \*/  
    
4.  \#define NETLINK\_FIREWALL 3 /\* Firewalling hook \*/  
    
5.  \#define NETLINK\_INET\_DIAG 4 /\* INET socket monitoring \*/  
    
6.  \#define NETLINK\_NFLOG 5 /\* netfilter/iptables ULOG \*/  
    
7.  \#define NETLINK\_XFRM 6 /\* ipsec \*/  
    
8.  \#define NETLINK\_SELINUX 7 /\* SELinux event notifications \*/  
    
9.  \#define NETLINK\_ISCSI 8 /\* Open\-iSCSI \*/  
    
10. \#define NETLINK\_AUDIT 9 /\* auditing \*/  
    
11. \#define NETLINK\_FIB\_LOOKUP 10  
    
12. \#define NETLINK\_CONNECTOR 11  
    
13. \#define NETLINK\_NETFILTER 12 /\* netfilter subsystem \*/  
    
14. \#define NETLINK\_IP6\_FW 13  
    
15. \#define NETLINK\_DNRTMSG 14 /\* DECnet routing messages \*/  
    
16. \#define NETLINK\_KOBJECT\_UEVENT 15 /\* Kernel messages to userspace \*/  
    
17. \#define NETLINK\_GENERIC 16  
    
18. /\* leave room for NETLINK\_DM (DM Events) \*/  
    
19. \#define NETLINK\_SCSITRANSPORT 18 /\* SCSI Transports \*/  
    
20. \#define NETLINK\_ECRYPTFS 19  
    
21. **\#define NETLINK\_TEST 20 /\* 用户添加的自定义协议 \*/**

在我们自己添加的NETLINK\_TEST协议里，同样地，最多允许我们设置32个多播组，每个多播组用1个比特表示，所以不同的多播组不可能出现重复。你可以根据自己的实际需求，决定哪个多播组是用来做什么的。用户空间的进程如果对某个多播组感兴趣，那么它就加入到该组中，当内核空间的进程往该组发送多播消息时，所有已经加入到该多播组的用户进程都会收到该消息。

再回到我们Netlink地址结构体里的nl\_groups成员，它是多播组的地址掩码，注意是***掩码***不是多播组的组号。如何根据多播组号取得多播组号的掩码呢？在af\_netlink.c中有个函数：

点击(此处)折叠或打开

1.  static u32 netlink\_group\_mask(u32 group)  
    
2.  \{   
    
3.  return group ? 1  << (group \- 1)  : 0;  
    
4.  \}

也就是说，在用户空间的代码里，如果我们要加入到多播组1，需要设置nl\_groups设置为1；多播组2的掩码为2；多播组3的掩码为4，依次类推。为0表示我们不希望加入任何多播组。理解这一点很重要。所以我们可以在用户空间也定义一个类似于netlink\_group\_mask()的功能函数，完成从多播组号到多播组掩码的转换。最终用户空间的代码如下：

点击(此处)折叠或打开

1.  \#include <sys/stat.h>  
    
2.  \#include <unistd.h>  
    
3.  \#include <stdio.h>  
    
4.  \#include <stdlib.h>  
    
5.  \#include <sys/socket.h>  
    
6.  \#include <sys/types.h>  
    
7.  \#include <string.h>  
    
8.  \#include <asm/types.h>  
    
9.  \#include <linux/netlink.h>  
    
10. \#include <linux/socket.h>  
    
11. \#include <errno.h>  
    
12.   
    
13. \#define MAX\_PAYLOAD 1024 // Netlink消息的最大载荷的长度  
    
14.   
    
15. **unsigned int netlink\_group\_mask(unsigned int group)**  
    
16. **\{**  
    
17.  **return group ? 1 << (group - 1) : 0;**  
    
18. **\}**  
    
19.   
    
20. int main(int argc, char\* argv\[\])  
    
21. \{   
    
22. struct sockaddr\_nl src\_addr;  
    
23. struct nlmsghdr \*nlh  = NULL;  
    
24. struct iovec iov;  
    
25. struct msghdr msg;  
    
26. int sock\_fd, retval;  
    
27.   
    
28. // 创建Socket  
    
29. sock\_fd = socket(PF\_NETLINK, SOCK\_RAW, NETLINK\_TEST);  
    
30. if(sock\_fd ==  \-1)\{   
    
31. printf("error getting socket: %s", strerror(errno));  
    
32. return \-1;  
    
33. \}  
    
34.   
    
35. memset(&src\_addr, 0, sizeof(src\_addr));  
    
36. src\_addr.nl\_family  = PF\_NETLINK;  
    
37. **src\_addr.nl\_pid = 0;**  // 表示我们要从内核接收多播消息。注意：该字段为0有双重意义，另一个意义是表示我们发送的数据的目的地址是内核。  
    
38. **src\_addr.nl\_groups**  = netlink\_group\_mask(atoi(argv\[1\])); // 多播组的掩码，组号来自我们执行程序时输入的第一个参数  
    
39.   
    
40. // 因为我们要加入到一个多播组，所以必须调用bind()。  
    
41. retval = bind(sock\_fd, (struct sockaddr\*)&src\_addr, sizeof(src\_addr));  
    
42. if(retval < 0)\{   
    
43. printf("bind failed: %s", strerror(errno));  
    
44. close(sock\_fd);  
    
45. return \-1;  
    
46. \}  
    
47.   
    
48. // 为接收Netlink消息申请存储空间  
    
49. nlh = (struct nlmsghdr \*)malloc(NLMSG\_SPACE(MAX\_PAYLOAD));  
    
50. if(!nlh)\{   
    
51. printf("malloc nlmsghdr error!\\n");  
    
52. close(sock\_fd);  
    
53. return \-1;  
    
54. \}  
    
55.   
    
56. memset(nlh, 0, NLMSG\_SPACE(MAX\_PAYLOAD));  
    
57. iov.iov\_base  = (void \*)nlh;  
    
58. iov.iov\_len  = NLMSG\_SPACE(MAX\_PAYLOAD);  
    
59.   
    
60. memset(&msg, 0, sizeof(msg));  
    
61. msg.msg\_iov  = &iov;  
    
62. msg.msg\_iovlen  = 1;  
    
63.   
    
64. // 从内核接收消息  
    
65. printf("waitinf for...\\n");  
    
66. recvmsg(sock\_fd, &msg, 0);  
    
67. printf("Received message: %s \\n", NLMSG\_DATA(nlh));  
    
68.   
    
69. close(sock\_fd);  
    
70.   
    
71. return 0;  
    
72. \}

可以看到，用户空间的程序基本没什么变化，唯一需要格外注意的就是Netlink地址结构体中的nl\_groups的设置。由于对它的解释很少，加之没有有效的文档，所以我也是一边看源码，一边在网上搜集资料。有分析不当之处，还请大家帮我指出。

内核空间我们添加了内核线程和内核线程同步方法completion的使用。内核空间修改后的代码如下：

点击(此处)折叠或打开

1.  \#include <linux/kernel.h>  
    
2.  \#include <linux/module.h>  
    
3.  \#include <linux/skbuff.h>  
    
4.  \#include <linux/init.h>  
    
5.  \#include <linux/ip.h>  
    
6.  \#include <linux/types.h>  
    
7.  \#include <linux/sched.h>  
    
8.  \#include <net/sock.h>  
    
9.  \#include <net/netlink.h>  
    
10.   
    
11. MODULE\_LICENSE("GPL");  
    
12. MODULE\_AUTHOR("Koorey King");  
    
13.   
    
14. struct sock \*nl\_sk  = NULL;  
    
15. **static struct task\_struct \*mythread = NULL; //内核线程对象**  
    
16.   
    
17. //向用户空间发送消息的接口  
    
18. void sendnlmsg(char  \*message/\*,int dstPID\*/)  
    
19. \{   
    
20. struct sk\_buff \*skb;  
    
21. struct nlmsghdr \*nlh;  
    
22. int len = NLMSG\_SPACE(MAX\_MSGSIZE);  
    
23. int slen = 0;  
    
24.   
    
25. if(!message ||  !nl\_sk)\{   
    
26. return;  
    
27. \}  
    
28.   
    
29. // 为新的 sk\_buffer申请空间  
    
30. skb = alloc\_skb(len, GFP\_KERNEL);  
    
31. if(!skb)\{   
    
32. printk(KERN\_ERR  "my\_net\_link: alloc\_skb Error./n");  
    
33. return;  
    
34. \}  
    
35.   
    
36. slen = strlen(message)\+1;  
    
37.   
    
38. //用nlmsg\_put()来设置netlink消息头部  
    
39. nlh = nlmsg\_put(skb, 0, 0, 0, MAX\_MSGSIZE, 0);  
    
40.   
    
41.  // 设置Netlink的控制块里的相关信息  
    
42. NETLINK\_CB(skb).pid = 0;  // 消息发送者的id标识，如果是内核发的则置0  
    
43. **NETLINK\_CB(skb).dst\_group = 5; //多播组号为5，但置成0好像也可以。**  
    
44.   
    
45. message\[slen\] = '\\0';  
    
46. memcpy(NLMSG\_DATA(nlh), message, slen\+1);  
    
47.   
    
48. //通过netlink\_unicast()将消息发送用户空间由dstPID所指定了进程号的进程  
    
49. **//netlink\_unicast(nl\_sk,skb,dstPID,0);**  
    
50. **netlink\_broadcast(nl\_sk, skb, 0,5, GFP\_KERNEL);** //发送多播消息到多播组5，这里我故意没有用1之类的“常见”值，目的就是为了证明我们上面提到的多播组号和多播组号掩码之间的对应关系  
    
51. printk("send OK!\\n");  
    
52. return;  
    
53. \}  
    
54.   
    
55. **//每隔1秒钟发送一条“I am from kernel!”消息，共发10个报文**  
    
56. **static int sending\_thread(void \*data)**
57. **\{**  
    
58.  **int i = 10;**  
    
59.  **struct completion cmpl;**  
    
60.  **while(i--)\{**  
    
61.  **init\_completion(&cmpl);**  
    
62.  **wait\_for\_completion\_timeout(&cmpl, 1 \* HZ);**  
    
63.  **sendnlmsg("I am from kernel!");**  
    
64.  **\}**  
    
65.  **printk("sending thread exited!");**  
    
66.  **return 0;**  
    
67. **\}**  
    
68.   
    
69. static int \_\_init myinit\_module()  
    
70. \{   
    
71. printk("my netlink in\\n");  
    
72. nl\_sk = netlink\_kernel\_create(NETLINK\_TEST,0,NULL,THIS\_MODULE);  
    
73.   
    
74. if(!nl\_sk)\{   
    
75. printk(KERN\_ERR  "my\_net\_link: create netlink socket error.\\n");  
    
76. return 1;  
    
77. \}  
    
78.   
    
79. printk("my netlink: create netlink socket ok.\\n");  
    
80. **mythread = kthread\_run(*sending\_thread*,NULL,"thread\_sender");**  
    
81. return 0;  
    
82. \}  
    
83.   
    
84. static void \_\_exit mycleanup\_module()  
    
85. \{   
    
86. if(nl\_sk !=  NULL)\{   
    
87. sock\_release(nl\_sk\->sk\_socket);  
    
88. \}  
    
89. printk("my netlink out!\\n");  
    
90. \}  
    
91.   
    
92. module\_init(myinit\_module);  
    
93. module\_exit(mycleanup\_module);

关于内核中netlink\_kernel\_create(int unit, unsigned int groups,…)函数里的第二个参数指的是我们内核进程最多能处理的多播组的个数，如果该值小于32，则默认按32处理，所以在调用netlink\_kernel\_create()函数时可以不用纠结第二个参数，一般将其置为0就可以了。

在skbuff\{\}结构体中，有个成员叫做"控制块"，源码对它的解释如下：

点击(此处)折叠或打开

1.  struct sk\_buff \{   
    
2.  /\* These two members must be first. \*/  
    
3.  struct sk\_buff \*next;  
    
4.  struct sk\_buff \*prev;  
    
5.  … …  
    
6.  /\*  
    
7.  \* This is the control buffer. It is free to use for every  
    
8.  \* layer. Please put your private variables there. If you  
    
9.  \* want to keep them across layers you have to do a skb\_clone()  
    
10. \* first. This is owned by whoever has the skb queued ATM.  
    
11. \*/  
    
12. **char cb\[48\];**  
    
13.   
    
14. … …
15. \}

当内核态的Netlink发送数据到用户空间时一般需要填充skbuff的控制块，填充的方式是通过强制类型转换，将其转换成struct netlink\_skb\_parms\{\}之后进行填充赋值的：

点击(此处)折叠或打开

1.  struct netlink\_skb\_parms  
    
2.  \{   
    
3.  struct ucred creds; /\* Skb credentials \*/  
    
4.  \_\_u32 pid;  
    
5.  \_\_u32 dst\_group;  
    
6.  kernel\_cap\_t eff\_cap;  
    
7.  \_\_u32 loginuid; /\* Login (audit) uid \*/  
    
8.  \_\_u32 sid; /\* SELinux security id \*/  
    
9.  \};

填充时的模板代码如下：

点击(此处)折叠或打开

1.  NETLINK\_CB(skb).pid=xx;  
    
2.  NETLINK\_CB(skb).dst\_group=xx;

这里要注意的是在Netlink协议簇里提到的skbuff的cb控制块里保存的是属于Netlink的私有信息。怎么讲，就是Netlink会用该控制块里的信息来完成它所提供的一些功能，只是完成Netlink功能所必需的一些私有数据。打个比方，以开车为例，开车的时候我们要做的就是打火、控制方向盘、适当地控制油门和刹车，车就开动了，这就是汽车提供给我们的“功能”。汽车的发动机，轮胎，传动轴，以及所用到的螺丝螺栓等都属于它的“私有”数据cb。汽车要运行起来这些东西是不可或缺的，但它们之间的协作和交互对用户来说又是透明的。就好比我们Netlink的私有控制结构struct netlink\_skb\_parms\{\}一样。

目前我们的例子中，将NETLINK\_CB(skb).dst\_group设置为相应的多播组号和0效果都是一样，用户空间都可以收到该多播消息，原因还不是很清楚，还请Netlink的大虾们帮我点拨点拨。

编译后重新运行，最后的测试结果如下：

[![23069658_135272259059cN.jpg][]][23069658_135272259059cN.jpg]

注意，这里一定要先执行insmod加载内核模块，然后再运行用户空间的程序。如果没有加载mynlkern.ko而直接执行./test 5在bind()系统调用时会报如下的错误：

*bind failed: No such file or directory*

因为网上有写文章在讲老版本Netlink的多播时用法时先执行了用户空间的程序，然后才加载内核模块，现在(2.6.21)已经行不通了，这一点请大家注意。

小结：通过这三篇博文我们对Netlink有了初步的认识，并且也可以开发基于Netlink的基本应用程序。但这只是冰山一角，要想写出高质量、高效率的软件模块还有些差距，特别是对Netlink本质的理解还需要提高一个层次，当然这其中牵扯到内核编程的很多基本功，如临界资源的互斥、线程安全性保护、用Netlink传递大数据时的处理等等都是开发人员需要考虑的问题。

完。

[23069658_135272259059cN.jpg]: http://blog.chinaunix.net/attachment/201211/12/23069658_135272259059cN.jpg