Linux内核netlink机制 - 连接器（Netlink Connector）

目录
简介：

一、Connector数据结构和 API
1、数据结构体
1.1 消息头结构体
1.2 连接器id结构体
1.3 netlink参数结构体
2、注册callback
3、卸载callback
4、发送消息
二、参考示例
1、用户态使用连接器
2、内核态使用连接器

---

简介：

---

        连接器是一种用户态与内核态的通讯方式，本质上，连接器是一种netlink，它的 netlink 协议号为 NETLINK_CONNECTOR，与一般的 netlink 相比，它提供了更容易的使用接口。现在，稳定内核有两个连接器应用实例，一个是历程变乱连接器，另一个是 CIFS 文件体系。连接器实今世码在内核的 driver/connector 目录中。用户可以配置内核菜单选择是否启用连接器。
        任何内核模块要想使用连接器，必须先注册一个标识 ID 和 回调函数，当连接器收到 netlink 消息后，会根据消息对应的标识 ID 调用相应该 ID 的回调函数。

连接器体系框架如图：

一、Connector数据结构和 API

---

1、数据结构体

---

1.1 消息头结构体

1. /* include/uapi/linux/netlink.h */
2. struct nlmsghdr {
3.         __u32                nlmsg_len;        /* Length of message including header */
4.         __u16                nlmsg_type;        /* Message content */
5.         __u16                nlmsg_flags;        /* Additional flags */
6.         __u32                nlmsg_seq;        /* Sequence number */
7.         __u32                nlmsg_pid;        /* Sending process port ID */
8. };

复制代码

       
1.2 连接器id结构体

        struct cb_id 是连接器实例的标识 ID，它用于确定 netlink 消息与回调函数的对应关系。当连接器接收到标识 ID 为 {idx，val} 的 netlink 消息时，注册的回调函数 void (*callback) (void *) 将被调用。该回调函数的参数为结构 struct cn_msg 的指针

1. /* include/uapi/linux/connector.h */
2. struct cb_id {
3.         __u32 idx;
4.         __u32 val;
5. };
7. struct cn_msg {
8.         struct cb_id id;
10.         __u32 seq;
11.         __u32 ack;
13.         __u16 len;                /* Length of the following data */
14.         __u16 flags;
15.         __u8 data[0];
16. };

复制代码

1.3 netlink参数结构体

1. /* 源码路径：include/linux/netlink.h */
2. struct netlink_skb_parms {
3.         struct scm_creds        creds;                /* Skb credentials        */
4.         __u32                        portid;
5.         __u32                        dst_group;
6.         __u32                        flags;
7.         struct sock                *sk;
8.         bool                        nsid_is_set;
9.         int                        nsid;
10. };

复制代码

2、注册callback

---

接口函数 cn_add_callback 用于向连接器注册新的连接器实例以及相应的回调函数

1. int cn_add_callback(struct cb_id *id, const char *name,
2.                     void (*callback)(struct cn_msg *,
3.                                      struct netlink_skb_parms *))

复制代码

功能：向连接器注册新的连接器实例，当收到标识ID则callback函数被调用
参数：

• id ：注册的标识 ID；
  
• name ：连接器回调函数的符号名；
  
• callback ：回调函数
  

3、卸载callback

---

接口函数 cn_del_callback 用于卸载回调函数

1. void cn_del_callback(struct cb_id *id)

复制代码

功能：卸载callback函数
参数：

• id：卸载 cn_add_callback 时注册的 id；
  

4、发送消息

---

接口函数 cn_netlink_send 用于向指定的组发送消息（用于向用户态发送netlink消息），它可以在任何上下文安全地调用，但是，如果内存不足，大概会发送失败

1. int cn_netlink_send(struct cn_msg *msg, u32 portid, u32 __group, gfp_t gfp_mask)

复制代码

功能：向给定的组发送消息（向用户态发送netlink消息）
参数：

• msg：netlink 消息的消息头；
  
• __group：接收消息的组。如果它为 0，那么连接器将搜索全部注册的连接器用户，终极将发送给用户 ID 与在 msg 中的 ID 相同的组，但如果 __group 不为 0，消息将发送给 __group 指定的组；
  
• gfp_mask：页分配标志；
  

二、参考示例

ncp 为 Netlink Connector Process，即用户态我们需要开发的步调

1、用户态使用连接器

实现了用户态发送/接收连接器msg

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <sys/socket.h>
4. #include <string.h>
5. #include <linux/netlink.h>
7. /* CN_NETLINK_USERS 定义在 include/uapi/linux/connector.h */
8. #define CN_VIF_ID CN_NETLINK_USERS + 3
9. #define CN_VIF_VAL 0x5555
11. #define RX_BUF_SIZE                100                //接收buf size
12. #define MAX_PLOAD                100                //发送message内存size
14. typedef struct
15. {
16.     struct nlmsghdr hdr;
17.     char msg[RX_BUF_SIZE];
18. }RX_KERNEL_MSG;
20. static int nl_connector_send(int _skfd, char *_pBuf, int _len)
21. {
22.     static int seq = 0;
23.     int ret = -1;
24.     struct nlmsghdr *nlhdr;
25.     struct cn_msg *cnmsg;
27. /* 配置消息头 */
28.     nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PLOAD));        //申请buf
29.    
30.     //初始化头 nlmsghdr
31.     memset(nlhdr, 0, sizeof(struct nlmsghdr));
32.     nlhdr->nlmsg_len = NLMSG_SPACE(_len); //包括netlink消息头在内，整个消息长度
33.     nlhdr->nlmsg_flags = 0;            //消息标志
34.     nlhdr->nlmsg_type = NLMSG_DONE;    //消息类型
35.     nlhdr->nlmsg_seq = 0;              //消息报文的序列号
36.     nlhdr->nlmsg_pid = getpid();                //消息中加入本应用端口pid
38. /* 设置数据 */
39.     cnmsg = (struct cn_msg*)NLMSG_DATA(nlhdr);        //找到存放 cn_msg 的地址
40.     cnmsg->id.idx = CN_VIF_ID;
41.         cnmsg->id.val = CN_VIF_VAL;
42.         cnmsg->seq = seq++;
43.         cnmsg->ack = 0;
44.         memcpy(cnmsg->data, _pBuf, _len);        //这里要注意越界风险
45.         cnmsg->len = _len;
47. /* 发送数据 */
48.     ret = send(_skfd, nlhdr, nlhdr->nlmsg_len, 0);        //将message消息发送给内核
49.     if(!ret){
50.         perror("Failed to send:");
51.         exit(-1);
52.     }
54.     free((void *)nlhdr);
55.     return ret;
56. }
58. static int nl_connector_recv(int _skfd, char *_pBuf, int _len)
59. {
60.     int ret = -1;
61.     struct nlmsghdr *nlhdr_rx;
62.     char *pData;
64.     len = recv(_skfd, _pBuf, _len, 0);
65.     if (len == -1) {
66.                 log_e("recv buf failed\n");
67.                 // close(ksif->fd);
68.                 return -1;
69.         }
71.         nlhdr_rx = (struct nlmsghdr *)_pBuf;                                //msg头部分
72.     pData = (struct cn_msg *)NLMSG_DATA(nlhdr_rx);                //数据部分
73.     //判断msc头类型
74.         switch (nlhdr_rx->nlmsg_type) {
75.             case NLMSG_ERROR:
76.                     printf("Error message received.\n");
77.                     ret = 0;
78.                     break;
79.             case NLMSG_DONE:
80.                     ret = len;
81.                     if(data->id.idx != CN_VIF_ID || data->id.val != CN_VIF_VAL)
82.                             return 0;
83.                     printf("[%x.%x] [%08u.%08u] %dbytes\n", data->id.idx, data->id.val, data->seq, data->ack, data->len);
84.                     break;
85.             default:
86.                     break;
87.         }
89.     return ret;
90. }
92. int main(int argc, char* argv[])
93. {
94.     char *data = "This message is from user's space";
95.     char rx_buf[NL_SPACE(MAX_PLOAD)];
96.    
97.     //初始化
98.     struct sockaddr_nl l_local = {0};    //sockaddr_nl 是 netlink 使用的地址数据结构
99.     int skfd = -1;
100.     int seq = 0;
101.     int ret = -1;
103. /* 1.创建NETLINK socket */
104.     skfd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
105.     if(skfd < 0){
106.         printf("can not connect to kernel by netlink type %d\n", NETLINK_CONNECTOR);
107.         return -1;
108.     }
110.     //初始化 netlink 地址
111.     l_local.nl_family = AF_NETLINK;
112.     l_local.nl_pid = getpid();
113.     l_local.nl_groups = -1;        //请求组的位掩码，-1转为无符号32位的0xffffffff(表示都接收)
114.     if(bind(skfd, (struct sockaddr *)&l_local, sizeof(struct sockaddr_nl)) != 0){
115.         printf("bind() error\n");
116.         close(skfd);
117.         return -1;
118.     }
120. /* 2.发送数据 */
121.     nl_connector_send(skfd, (char *)data, sizeof(data));
123. /* 3.接收内核发来的信息 */
124.     nl_connector_recv(skfd, (char *)rx_buf, sizeof(rx_buf));
126.     printf("User Receive ACK from kernel:%s\r\n",(char *)info.msg);
127.     //内核和用户进行通信
129.     close(skfd);
130.     return 0;
131. }

复制代码

2、内核态使用连接器

实现内核态接收/发送连接器msg

1. #include <linux/kernel.h>
2. #include <linux/module.h>
3. #include <linux/types.h>
4. #include <linux/sched.h>
5. #include <net/sock.h>
6. #include <linux/netlink.h>
7. #include <linux/connector.h>
8. #include <uapi/linux/connector.h>
10. /* 连接器的唯一标识，连接器需要它来找到对应的连接器实例 */
11. #define CN_VIF_ID CN_NETLINK_USERS + 3
12. #define CN_VIF_VAL 0x5555
14. static struct cb_id g_cb_id = { CN_VIF_ID, CN_VIF_VAL };
16. /* cn 发送 */
17. static int cn_func_send(const uint8_t *_pBuf, size_t _len)
18. {
19.         struct cn_msg *m;
20.     static int seq_cnt = 0;
22.     m = kzalloc(sizeof(*m) + _len, GFP_ATOMIC);
23.         if (!m) {
24.                 printk("kzalloc cn_msg failed\n");
25.                 return 0;
26.         }
28.     m->id.idx = CN_VIF_ID;
29.     m->id.val = CN_VIF_VAL;
30.         m->seq = seq_cnt++;
31.         m->len = _len;
32.         memcpy(m + 1, _pBuf, m->len);
33.    
34. //#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,15,0)
35.         cn_netlink_send(m, 0, 0, GFP_ATOMIC);
36. //#else
37. //        cn_netlink_send(m, 0, GFP_ATOMIC);
38. //#endif
39.         kfree(m);
41.         return _len;
42. }
44. /* 接收回调函数 */
45. static void cn_func_callback(struct cn_msg *cn_msg, struct netlink_skb_parms *nsp)
46. {
47.     /* 打印接收到的数据和长度 */
48.         printk("kernel space Rx: data: %s, len: %d\n", cn_msg->data, cn_msg->len);
50.     /* 内核态应答数据 */
51.     cn_func_send("kernel space Tx: ACK", sizeof("kernel space Tx: ACK"));
52. }
54. int __init netlink_connector_init(void)
55. {
56.     int ret = -1;
58.     /* 注册 cn 接收回调函数 */
59.         ret = cn_add_callback(&g_cb_id, "cn_func", cn_func_callback);
60.         if(ret) {
61.                 pr_err("cn_add_callback cn_func failed\n");
62.                 return ret;
63.         }
65.     printk(KERN_DEBUG "netlink_connector_init!!\n");
66.         return ret;
67. }
69. void __exit netlink_connector_exit(void)
70. {
71.     cn_del_callback(&g_cb_id);
72.     printk(KERN_DEBUG "netlink_connector_exit!!\n");
73. }
75. module_init(netlink_connector_init);
76. module_exit(netlink_connector_exit);
77. MODULE_LICENSE("GPL");
78. MODULE_AUTHOR("dongao");

复制代码

驱动加载后查看结果：

1. $ cat /proc/net/connector
2. Name            ID
3. cn_func         14:21845

复制代码

---

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。