Chinaunix首页 | 论坛 | 博客

plainer

首页　| 　博文目录　| 　关于我

wzzushx

  • 博客访问： 807872
  • 博文数量： 247
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 501
  • 用 户 组： 普通用户
  • 注册时间： 2013-07-12 21:53
个人简介

系统未建立

文章分类

全部博文（247）

文章存档

2021年（1）

2020年（3）

2019年（5）

2018年（3）

2017年（44）

2016年（75）

2015年（52）

2014年（63）

2013年（1）

我的朋友
最近访客
推荐博文
相关博文
Linux内核netlink简介

分类： LINUX

2021-01-05 18:32:50

原文地址：Linux内核netlink简介 作者：vv1133

netlink是一种用于用户空间进程与内核间通信的方法，也可以用于用户进程之间的通信（IPC）。
netlink和ioctl比较相似，都能从用户空间向内核空间通信，但netlink是一种异步通信机制，而ioctl是同步通信机制。且ioctl不能从内核向用户空间发送消息。

下面我们结合实例来进一步了解netlink。我们的例子是用户态发送一串数据给内核态，内核接收到后，返回"I am from kernel!"给用户态程序。

内核态（以内核版本3.13为例）

先来了解下内核中netlink相关的数据结构和函数。

使用netlink_kernel_create()函数创建内核套接字服务，函数类型：
  1. static inline struct sock *netlink_kernel_create(struct net *net, int unit, struct netlink_kernel_cfg *cfg);
函数返回创建的struct sock对象指针。struct sock (定义在include\linux\net.h) 结构是内核网络系统中最常见的结构之一。它的使用基本贯穿L2,L3,L4层，而且是各层之间的一个联系，无论发送还是接收的数据包都要被存到sock结构中的缓冲队列中。
函数参数net是网络命名空间，如果没自定义网络命名空间的话，就使用内核默认的init_net。
unit是netlink类型，内核已经定义了21个(在include/uapi/linux/netlink.h中)，如果要增加我们自己的netlink类型，就必须定义新的值，但要注意，新的值必须小于MAX_LINKS（32）
cfg是netlink的配置信息。该结构体定义如下：
  1. struct netlink_kernel_cfg {
  2.         unsigned int groups;
  3.         unsigned int flags;
  4.         void (*input)(struct sk_buff *skb);
  5.         struct mutex *cb_mutex;
  6.         int (*bind)(struct net *net, int group);
  7.         void (*unbind)(struct net *net, int group);
  8.         bool (*compare)(struct net *net, struct sock *sk);
  9. };
其中最重要的是input域，该函数用于处理用户空间发送到内核方向的数据。内核接收到数据包后，会传给input函数。

来看代码：
  1. #include <linux/init.h>
  2. #include <linux/module.h>
  3. #include <linux/timer.h>
  4. #include <linux/time.h>
  5. #include <linux/types.h>
  6. #include <net/sock.h>
  7. #include <net/netlink.h>
  8. #include <linux/string.h>

  10. #define NETLINK_TEST 25
  11. #define MAX_MSGSIZE 1024

  13. struct sock *nl_sk = NULL;

  15. void send_msg(char *message, int pid)
  16. {
  17.         struct sk_buff *skb;
  18.         struct nlmsghdr *nlh;
  19.         int len = NLMSG_SPACE(MAX_MSGSIZE);

  21.         if (!message || !nl_sk) {
  22.                 return;
  23.         }
  24.         printk(KERN_INFO "pid:%d\n", pid);
  25.         skb = alloc_skb(len, GFP_KERNEL);
  26.         if (!skb) {
  27.                 printk(KERN_ERR "send_msg:alloc_skb error\n");
  28.                 return;
  29.         }
  30.         nlh = nlmsg_put(skb, 0, 0, 0, MAX_MSGSIZE, 0);
  31.         NETLINK_CB(skb).portid = 0;
  32.         NETLINK_CB(skb).dst_group = 0;
  33.         strcpy(NLMSG_DATA(nlh), message);
  34.         printk(KERN_INFO "my_net_link:send message '%s'.\n",(char *)NLMSG_DATA(nlh));
  35.         netlink_unicast(nl_sk, skb, pid, MSG_DONTWAIT);
  36. }

  38. void recv_nlmsg(struct sk_buff *skb)
  39. {
  40.         int pid;
  41.         struct nlmsghdr *nlh = nlmsg_hdr(skb);

  43.         if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len)
  44.                 return;

  46.         printk(KERN_INFO "Message received:%s\n", (char*)NLMSG_DATA(nlh));
  47.         pid = nlh->nlmsg_pid;
  48.         send_msg("I am from kernel!", pid);
  49. }

  51. struct netlink_kernel_cfg nl_kernel_cfg = {
  52.         .groups = 0,
  53.         .flags = 0,
  54.         .input = recv_nlmsg,
  55.         .cb_mutex = NULL,
  56.         .bind = NULL,
  57.         .compare = NULL,
  58. };

  60. int netlink_init(void)
  61. {
  62.         nl_sk = netlink_kernel_create(&init_net, NETLINK_TEST, &nl_kernel_cfg);
  63.         if (!nl_sk) {
  64.                 printk(KERN_ERR "my_net_link: create netlink socket error.\n");
  65.                 return 1;
  66.         }
  67.         printk(KERN_INFO "netlink_init: create netlink socket ok.\n");
  68.         return 0;
  69. }

  71. static void netlink_exit(void)
  72. {
  73.         if (nl_sk != NULL)
  74.                 sock_release(nl_sk->sk_socket);

  76.         printk(KERN_INFO "my_net_link: self module exited\n");
  77. }

  79. module_init(netlink_init);
  80. module_exit(netlink_exit);
  81. MODULE_AUTHOR("vv1133");
  82. MODULE_LICENSE("GPL");

程序中，加载模块时，调用netlink_kernel_create()创建套接字。卸载模块时，调用sock_release()释放套接字。
netlink数据包处理函数是recv_nlmsg()，首先通过nlmsg_hdr()函数获取到netlink报头，netlink的消息报头由include/uapi/linux/netlink.h中的nlmsghdr定义：
  1. struct nlmsghdr
  2. {
  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 PID */
  8. };

我们通过NLMSG_DATA获取netlink的payload并打印出来。注意，netlink的payload一般使用TLV格式，即“类型-长度-值”，但这里我们只传递一个固定的字符串，简单起见就不用这个格式了。然后，通过alloc_skb()函数创建一个新的skb，并用nlmsg_put()函数填入netlink结构，填充要发送的字符串。最后调用netlink_unicast()发送数据。

用户态

对于用户态的程序，netlink通信与一般的socket通信类似。只是要用sendmsg()和recvmsg()代替send()/write()和recv()/read()
具体步骤如下：

1. 创建套接字
用户空间使用系统调用socket()创建netlink套接字，需要将域名设置成AF_NETLINK，类型必须是SOCK_RAW或SOCK_DGRAM，协议设置成我们的自定义netlink协议NETLINK_TEST。

2. 将本地套接字与源地址绑定
由于在netlink报头里要设置端口号，我们必须使用bind()函数将指定的端口与socket绑定。

3. 初始化msghdr
a. 设置目的地址信息
  1. dest_addr.nl_family = AF_NETLINK;
  2. dest_addr.nl_pid = 0;
  3. dest_addr.nl_groups = 0;
b. 填充netlink报头，即nlmsghdr结构体
  1. nlh = nlmsg_hdr(skb);
  2. nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
  3. nlh->nlmsg_pid = getpid();
  4. nlh->nlmsg_flags = 0;
c. 将缓冲区向量iovec与消息进行绑定，指向消息头。
  1. iov.iov_base = (void *)nlh;
  2. iov.iov_len = NLMSG_SPACE(MAX_PAYLOAD);
d. 填充msghdr结构体
  1. struct msghdr msg;
  2. msg.msg_name = (void *)&dest_addr;
  3. msg.msg_namelen = sizeof(dest_addr);
  4. msg.msg_iov = &iov;
  5. msg.msg_iovlen = 1;

4. 调用sendmsg向内核发送消息，recvmsg从内核获取消息。

来看代码：
  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>

  13. #define MAX_PAYLOAD 1024
  14. #define NETLINK_TEST 25

  16. int main(int argc, char* argv[])
  17. {
  18.         int state;
  19.         struct sockaddr_nl src_addr, dest_addr;
  20.         struct nlmsghdr *nlh = NULL;
  21.         struct iovec iov;
  22.         struct msghdr msg;
  23.         int sock_fd, retval;
  24.         int state_smg = 0;

  26.         // Create a socket
  27.         sock_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_TEST);
  28.         if(sock_fd == -1){
  29.                 printf("error getting socket: %s", strerror(errno));
  30.                 return -1;
  31.         }

  33.         // To prepare binding
  34.         memset(&src_addr, 0, sizeof(src_addr));
  35.         src_addr.nl_family = AF_NETLINK;
  36.         src_addr.nl_pid = 100; //设置源端端口号
  37.         src_addr.nl_groups = 0;

  39.         //Bind
  40.         retval = bind(sock_fd, (struct sockaddr*)&src_addr, sizeof(src_addr));
  41.         if (retval < 0) {
  42.                 printf("bind failed: %s", strerror(errno));
  43.                 close(sock_fd);
  44.                 return -1;
  45.         }

  47.         // To orepare create mssage
  48.         nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD));
  49.         if (!nlh) {
  50.                 printf("malloc nlmsghdr error!\n");
  51.                 close(sock_fd);
  52.                 return -1;
  53.         }

  55.         memset(&dest_addr,0,sizeof(dest_addr));
  56.         dest_addr.nl_family = AF_NETLINK;
  57.         dest_addr.nl_pid = 0; //设置目的端口号
  58.         dest_addr.nl_groups = 0;
  59.         nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
  60.         nlh->nlmsg_pid = 100; //设置源端口
  61.         nlh->nlmsg_flags = 0;
  62.         strcpy(NLMSG_DATA(nlh), "Hello from client!"); //设置消息体
  63.         iov.iov_base = (void *)nlh;
  64.         iov.iov_len = NLMSG_SPACE(MAX_PAYLOAD);

  66.         //Create mssage
  67.         memset(&msg, 0, sizeof(msg));
  68.         msg.msg_name = (void *)&dest_addr;
  69.         msg.msg_namelen = sizeof(dest_addr);
  70.         msg.msg_iov = &iov;
  71.         msg.msg_iovlen = 1;

  73.         //send message
  74.         printf("state_smg\n");
  75.         state_smg = sendmsg(sock_fd,&msg,0);
  76.         if (state_smg == -1) {
  77.                 printf("get error sendmsg = %s\n",strerror(errno));
  78.         }
  79.         memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));

  81.         //receive message
  82.         printf("waiting received!\n");
  83.         state = recvmsg(sock_fd, &msg, 0);
  84.         if (state < 0) {
  85.                 printf("state<1");
  86.         }
  87.         printf("Received message: %s\n", (char*)NLMSG_DATA(nlh));

  89.         close(sock_fd);
  90.         return 0;
  91. }

运行程序：

加载模块
  1. # sudo insmod netl.ko

运行客户端程序
  1. # ./client
  2. state_smg
  3. waiting
  4. Received message: I am from

查看内核打印
  1. # dmesg
  2. [ 545.278040] my_net_link: self module exited
  3. [ 679.799672] PPP MPPE Compression module registered
  4. [ 4368.567435] netlink_init: create netlink socket ok.
  5. [ 4379.239327] Message received:Hello from
  6. [ 4379.239331] pid:100
  7. [ 4379.239333] my_net_link:send message 'I am from kernel!'.

卸载模块
  1. # sudo rmmod netl

文中的代码可以在下载。

阅读(2206) | 评论(0) | 转发(0) |
0

上一篇：Linux Wireless子系统初始化

下一篇：没有了

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6