switch_set_state/netlink/kmod

什么是Netlink

       关于Netlink的理解，需要把握几个关键点：

       1、面向数据报的无连接消息子系统

       2、基于通用的BSD Socket架构而实现

      关于第一点使我们很容易联想到UDP协议，能想到这一点就非常棒了。按着UDP协议来理解Netlink不是不无道理，只要你能触类旁通，做到“活学”，善于总结归纳、联想，最后实现知识迁移这就是学习的本质。Netlink可以实现内核->用户以及用户->内核的双向、异步的数据通信，同时它还支持两个用户进程之间、甚至两个内核子系统之间的数据通信。本文中，对后两者我们不予考虑，焦点集中在如何实现用户<->内核之间的数据通信。

      看到第二点脑海中是不是瞬间闪现了下面这张图片呢？如果是，则说明你确实有慧根；当然，不是也没关系，慧根可以慢慢长嘛，呵呵。

Netlink通信类型

      Netlink支持两种类型的通信方式：单播和多播。

      单播：经常用于一个用户进程和一个内核子系统之间1:1的数据通信。用户空间发送命令到内核，然后从内核接受命令的返回结果。

Netlink的消息格式

Netlink的消息头

      消息头定义在<include/linux/netlink.h>文件里，由结构体nlmsghdr表示：

nlmsg_seq：消息序列号。因为Netlink是面向数据报的，所以存在丢失数据的风险，但是Netlink提供了如何确保消息不丢失的机制，让程序开发人员根据其实际需求而实现。消息序列号一般和NLM_F_ACK类型的消息联合使用，如果用户的应用程序需要保证其发送的每条消息都成功被内核收到的话，那么它发送消息时需要用户程序自己设置序号，内核收到该消息后对提取其中的序列号，然后在发送给用户程序回应消息里设置同样的序列号。有点类似于TCP的响应和确认机制。

注意：当内核主动向用户空间发送广播消息时，消息中的该字段总是为0。

Netlink的消息体

Netlink提供的错误指示消息

    struct sockaddr_nl{}的详细定义和描述如下：

1. struct sockaddr_nl
   
2. {
   
3.     sa_family_t    nl_family;    /*该字段总是为AF_NETLINK    */
   
4.     unsigned short    nl_pad;        /* 目前未用到，填充为0*/
   
5.     __u32        nl_pid;        /* process pid    */
   
6.     __u32        nl_groups;    /* multicast groups mask */
   
7. };

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. 
    
12. #define MAX_PAYLOAD 1024 /*消息最大负载为1024字节*/
    
13. 
    
14. int main(int argc, char* argv[])
    
15. {
    
16.     struct sockaddr_nl dest_addr;
    
17.     struct nlmsghdr *nlh = NULL;
    
18.     struct iovec iov;
    
19.     int sock_fd=-1;
    
20.     struct msghdr msg;
21.         

1.     if(-1 == (sock_fd=socket(PF_NETLINK, SOCK_RAW,NETLINK_TEST))){ //创建套接字
   
2.             perror("can't create netlink socket!");
   
3.             return 1;
   
4.     }
   
5.     memset(&dest_addr, 0, sizeof(dest_addr));
   
6.     dest_addr.nl_family = AF_NETLINK;
   
7.     dest_addr.nl_pid = 0; /*我们的消息是发给内核的*/
   
8.     dest_addr.nl_groups = 0; /*在本示例中不存在使用该值的情况*/
9.         
10.     //将套接字和Netlink地址结构体进行绑定

1.     if(-1 == bind(sock_fd, (struct sockaddr*)&dest_addr, sizeof(dest_addr))){
   
2.           perror("can't bind sockfd with sockaddr_nl!");
   
3.           return 1;
   
4.     }
   
5. 
   
6.     if(NULL == (nlh=(struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD)))){
   
7.           perror("alloc mem failed!");
   
8.           return 1;
   
9.     }
   
10. 
    
11.     memset(nlh,0,MAX_PAYLOAD);
    
12.     /* 填充Netlink消息头部 */
    
13.     nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
    
14.     nlh->nlmsg_pid = 0;
    
15.     nlh->nlmsg_type = NLMSG_NOOP; //指明我们的Netlink是消息负载是一条空消息
    
16.     nlh->nlmsg_flags = 0;
    
17. 
    
18.     /*设置Netlink的消息内容，来自我们命令行输入的第一个参数*/
    
19.     strcpy(NLMSG_DATA(nlh), argv[1]);
    
20. 
    
21.     /*这个是模板，暂时不用纠结为什么要这样用。有时间详细讲解socket时再说*/
    
22.     memset(&iov, 0, sizeof(iov));
    
23.     iov.iov_base = (void *)nlh;
    
24.     iov.iov_len = nlh->nlmsg_len;
    
25.     memset(&msg, 0, sizeof(msg));
    
26.     msg.msg_iov = &iov;
    
27.     msg.msg_iovlen = 1;
    
28. 
    
29.     sendmsg(sock_fd, &msg, 0); //通过Netlink socket向内核发送消息
30. 
    
31.     /* 关闭netlink套接字 */
    
32.     close(sock_fd);
    
33.     free(nlh);
    
34.     return 0;
    
35. }

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 <linux/netlink.h>
   
10. 
    
11. MODULE_LICENSE("GPL");
    
12. MODULE_AUTHOR("Koorey King");
    
13. 
    
14. struct sock *nl_sk = NULL;
    
15. static void nl_data_ready (struct sock *sk, int len)
    
16. {
    
17.     struct sk_buff *skb;
    
18.     struct nlmsghdr *nlh = NULL;
    
19. 
    
20.     while((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL)
    
21.     {
    
22.           nlh = (struct nlmsghdr *)skb->data;
    
23.           printk("%s: received netlink message payload: %s \n", __FUNCTION__,(char*)NLMSG_DATA(nlh));
    
24.           kfree_skb(skb);
    
25.     }
    
26.     printk("recvied finished!\n");
    
27. }
    
28. 
    
29. static int __init myinit_module()
    
30. {
    
31.     printk("my netlink in\n");
    
32.     nl_sk =netlink_kernel_create(NETLINK_TEST,0,nl_data_ready,THIS_MODULE);
    
33.     return 0;
    
34. }
    
35. 
    
36. static void __exit mycleanup_module()
    
37. {
    
38.     printk("my netlink out!\n");
    
39.     sock_release(nl_sk->sk_socket);
    
40. }
    
41. 
    
42. module_init(myinit_module);
    
43. module_exit(mycleanup_module);

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. 
    
12. #define MAX_PAYLOAD 1024 /*消息最大负载为1024字节*/
    
13. 
    
14. int main(int argc, char* argv[])
    
15. {
    
16.     struct sockaddr_nl dest_addr;
    
17.     struct nlmsghdr *nlh = NULL;
    
18.     struct iovec iov;
    
19.     int sock_fd=-1;
    
20.     struct msghdr msg;
    
21. 
    
22.     if(-1 == (sock_fd=socket(PF_NETLINK, SOCK_RAW,NETLINK_TEST))){
    
23.           perror("can't create netlink socket!");
    
24.           return 1;
    
25.     }
    
26.     memset(&dest_addr, 0, sizeof(dest_addr));
    
27.     dest_addr.nl_family = AF_NETLINK;
    
28.     dest_addr.nl_pid = 0; /*我们的消息是发给内核的*/
    
29.     dest_addr.nl_groups = 0; /*在本示例中不存在使用该值的情况*/
    
30. 
    
31.     if(-1 == bind(sock_fd, (struct sockaddr*)&dest_addr, sizeof(dest_addr))){
    
32.           perror("can't bind sockfd with sockaddr_nl!");
    
33.           return 1;
    
34.     }
    
35.     if(NULL == (nlh=(struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD)))){
    
36.           perror("alloc mem failed!");
    
37.           return 1;
    
38.     }
    
39.     
40.     memset(nlh,0,MAX_PAYLOAD);
    
41.     /* 填充Netlink消息头部 */
    
42.     nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
    
43.     nlh->nlmsg_pid = getpid();//我们希望得到内核回应，所以得告诉内核我们ID号
    
44.     nlh->nlmsg_type = NLMSG_NOOP; //指明我们的Netlink是消息负载是一条空消息
    
45.     nlh->nlmsg_flags = 0;
    
46. 
    
47.     /*设置Netlink的消息内容，来自我们命令行输入的第一个参数*/
    
48.     strcpy(NLMSG_DATA(nlh), argv[1]);
    
49. 
    
50.     /*这个是模板，暂时不用纠结为什么要这样用。*/
    
51.     memset(&iov, 0, sizeof(iov));
    
52.     iov.iov_base = (void *)nlh;
    
53.     iov.iov_len = nlh->nlmsg_len;
    
54.     memset(&msg, 0, sizeof(msg));
    
55.     msg.msg_iov = &iov;
    
56.     msg.msg_iovlen = 1;
    
57. 
    
58.     sendmsg(sock_fd, &msg, 0); //通过Netlink socket向内核发送消息
59. 
    
60.     //接收内核消息的消息
    
61.     printf("waiting message from kernel!\n");
    
62.     memset((char*)NLMSG_DATA(nlh),0,1024);
    
63.     recvmsg(sock_fd,&msg,0);
    
64.     printf("Got response: %s\n",NLMSG_DATA(nlh));
    
65. 
    
66.     /* 关闭netlink套接字 */
    
67.     close(sock_fd);
    
68.     free(nlh);
    
69.     return 0;
    
70. }

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> /*该文头文件里包含了linux/netlink.h，因为我们要用到net/netlink.h中的某些API函数，nlmsg_pug()*/
   
10. 
    
11. MODULE_LICENSE("GPL");
    
12. MODULE_AUTHOR("Koorey King");
    
13. 
    
14. struct sock *nl_sk = NULL;
    
15. //向用户空间发送消息的接口
    
16. void sendnlmsg(char *message,int dstPID)
    
17. {
    
18.     struct sk_buff *skb;
    
19.     struct nlmsghdr *nlh;
    
20.     int len = NLMSG_SPACE(MAX_MSGSIZE);
    
21.     int slen = 0;
    
22. 
    
23.     if(!message || !nl_sk){
    
24.         return;
    
25.     }
    
26. 
    
27.     // 为新的 sk_buffer申请空间
    
28.     skb = alloc_skb(len, GFP_KERNEL);
    
29.     if(!skb){
    
30.         printk(KERN_ERR "my_net_link: alloc_skb Error./n");
    
31.         return;
    
32.     }
    
33. 
    
34.     slen = strlen(message)+1;
    
35. 
    
36.     //用nlmsg_put()来设置netlink消息头部
    
37.     nlh = nlmsg_put(skb, 0, 0, 0, MAX_MSGSIZE, 0);
    
38. 
    
39.     // 设置Netlink的控制块
    
40.     NETLINK_CB(skb).pid = 0; // 消息发送者的id标识，如果是内核发的则置0
    
41.     NETLINK_CB(skb).dst_group = 0; //如果目的组为内核或某一进程，该字段也置0
    
42. 
    
43.     message[slen] = '\0';
    
44.     memcpy(NLMSG_DATA(nlh), message, slen+1);
    
45. 
    
46.     //通过netlink_unicast()将消息发送用户空间由dstPID所指定了进程号的进程
    
47.     netlink_unicast(nl_sk,skb,dstPID,0);
    
48.     printk("send OK!\n");
    
49.     return;
    
50. }
    
51. 
    
52. static void nl_data_ready (struct sock *sk, int len)
    
53. {
    
54.     struct sk_buff *skb;
    
55.     struct nlmsghdr *nlh = NULL;
    
56. 
    
57.     while((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL)
    
58.     {
    
59.         nlh = (struct nlmsghdr *)skb->data;
    
60.         printk("%s: received netlink message payload: %s \n", __FUNCTION__,(char*)NLMSG_DATA(nlh));
    
61.         kfree_skb(skb);
    
62.         sendnlmsg("I see you",nlh->nlmsg_pid); //发送者的进程ID我们已经将其存储在了netlink消息头部里的nlmsg_pid字段里，所以这里可以拿来用。
63.     }
    
64.     printk("recvied finished!\n");
    
65. }
    
66. 
    
67. static int __init myinit_module()
    
68. {
    
69.     printk("my netlink in\n");
    
70.     nl_sk = netlink_kernel_create(NETLINK_TEST,0,nl_data_ready,THIS_MODULE);
    
71.     return 0;
    
72. }
    
73. 
    
74. static void __exit mycleanup_module()
    
75. {
    
76.     printk("my netlink out!\n");
    
77.     sock_release(nl_sk->sk_socket);
    
78. }
    
79. 
    
80. module_init(myinit_module);
    
81. module_exit(mycleanup_module);

1. static u32 netlink_group_mask(u32 group)
   
2. {
   
3.     return group ? 1 << (group - 1) : 0;
   
4. }

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. }

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);

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. }

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;