linux学习笔记：netlink实践演练
内核和用户空间之间存在如下交互手段：
1.内核启动参数 2.模块参数与 3.sysfs、4.sysctl、5.系统调用、6.netlink、7.procfs、8.seq_file、9.debugfs 10.relayfs
另外 call_usermodehelper 可以从内核发起用户态的应用程序运行
其中netlink作为一种进程之间的通讯手段 ，和其他内核与用户空间的通讯手段比较，有很大的优势：
1. 新增通讯通道的灵活性：
netlink提供了一套完善的机制，用户既可以静态的增加通讯通道，也可以动态的创建通讯通道，这样用户可以很灵活的根据自己的需要来定制和开发。
2. 丰富的特性支持：
netlink可以支持异步双工， 其他机制只支持用户到内核单向的通道，或者只支持内核到用户的单向通道，netlink支持对称的双向通道。
同时neilink支持单点传输和多点传输，这些优势都是其他通讯机制所不具备的。
3. 传输效率比较高：
和其他用户向内核通讯手段一样，netlink也是借助某些系统调用接口实现的，并且netlink的目标数据接收操作是直接在软中断里面执行的，比有些在内核开辟线程接收数据的方式要快。
4. 易于扩展：
内核已为netlink提供的动态机制扩展，新增一个应用通道非常方便，只需要修改少量代码。
netlink充分体现了linux开发的宗旨：“提供机制而不是策略”,“do one thing and do it well”， 从内核版本的演进历程看来，同一类型的机制，linux提供的功能越来越强大，给用户的选择空间也是越来越丰富。
从学习的角度出发，这里使用静态方式新增了一个netlink通道，并实现了一个用户态和内核态通讯的双向通讯的样例，设计如下：
user kernel
| |
send -> "hello from usr"-> receive and print
| |
receive and print < -"hello from usr " <-send
| |
exit
如上图所述，由用户首先发起一个问候消息给内核，内核收到这个消息以后返回一个问候消息给用户， 以下通过代码来分析netlink的实现：
一、内核部分代码：
1. 头文件和静态申明
这里包含了必要的头文件， 新增了一个 netlink协议号，这个协议号和内核自定义的NETLINK_GENERIC是同一类型，应该定义在<linux/netlink.h>中，为了方便显示放到了这里。
新增内核源码文件 eknetlink.c :
/*kernel example code of netlink*/#include <linux/netlink.h>#include <linux/module.h>#include <linux/skbuff.h>#include <linux/init.h>#include <linux/netdevice.h>#include <linux/netfilter.h>#include <linux/spinlock.h>#include <linux/netlink.h>#include <net/sock.h>#include <net/flow.h>#define NETLINK_EXAMPLE31 /*新增netlink协议号*//*本netlink过滤类型*/enum nf_eknetlink_hooks { NF_EKNETLINK_IN, NF_EKNETLINK_OUT, NF_EKNETLINK_NUMHOOKS};#define TFR printk /*trace function routine*/static struct sock *eknl = NULL; /*模块内部全局的netlink套接字*/static DEFINE_MUTEX(eknl_mutex); /*多线程互斥， 必需，有可能多个用户进程(如多个shell窗口)同时向本模块发消息*/static void eknl_lock(void){ mutex_lock(&eknl_mutex);}static void eknl_unlock(void){ mutex_unlock(&eknl_mutex);}
2. 内核netlink初始化
1) .netlink_kernel_create 为 NETLINK_EXAMPLE协议创建了一个套接字。
2) &init_net 使用当前的网络命名空间。
3) eknetlink_rcv 使用这个处理用户发送过来的soket数据。
4) nf_register_hook 注册一个数据包过滤函数。
static int __init eknetlink_init(void){ int rv = 0; printk("example kernel netlink_init.\n"); eknl = netlink_kernel_create(&init_net, NETLINK_EXAMPLE, 0, eknetlink_rcv, NULL, THIS_MODULE); if (!eknl) { printk(KERN_ERR "cannot initialize nfnetlink!\n"); return -1; } rv = nf_register_hook(&eknl_ops); if (rv) { netlink_kernel_release(eknl); } return rv;}static void __exit eknetlink_exit(void){ printk("Removing example kernel NETLINK layer.\n"); netlink_kernel_release(eknl); return;}module_init(eknetlink_init);module_exit(eknetlink_exit);MODULE_AUTHOR("monan");MODULE_LICENSE("GPL");
3. 内核netlink消息接收函数
/*netlink是基于socket套接字实现的通讯，所以netlink接收到的原始数据是socket数据类型，由struct sk_buff定义，函数中的netlink_rcv_sk()会通过nlh = nlmsg_hdr(skb);解析sk_buff，获取socket数据中的netlink的数据(由struct nlmsghdr定义)，并交给eknetlink_rcv_msg，让我们自行处理netlink消息*/static void eknetlink_rcv(struct sk_buff *skb){ TFR("eknetlink_rcv enter.skb(0x%x)\n", (unsigned int) skb); eknl_lock(); netlink_rcv_skb(skb, &eknetlink_rcv_msg); eknl_unlock(); TFR("eknetlink_rcv exit.\n");}/*这里开始解析netlink数据：struct nlmsghdr *nlh */
static int eknetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh){ char* str_buf; int ret; TFR("eknetlink_rcv_msg enter.\n"); printk("nlmsg_len(%d) nlmsg_type(0x%x) nlmsg_flags(0x%x) nlmsg_seq(%d) nlmsg_pid(0x%x)\n", nlh->nlmsg_len, nlh->nlmsg_type, nlh->nlmsg_flags, nlh->nlmsg_seq, nlh->nlmsg_pid); /*对接收数据进行过滤处理*/ ret = NF_HOOK(AF_NETLINK, NF_EKNETLINK_IN, skb, NULL, NULL, eknetlink_okfn); if (NF_ACCEPT != ret) { printk("out NF_HOOK not accept (%d)!\n", ret); return -1; } /* netlink数据中的用户数据（这里即用户控件发来的"hello kernel"字符串），是netlink消息数据中消息头(struct nlmsghdr)后面紧接着的部分， 长度由struct nlmsghdr.nlmsg_len描述，如果只有消息头没有用户数据，则struct nlmsghdr.nlmsg_len 为0。 */ if (nlh->nlmsg_len > 0) { str_buf = kmalloc(nlh->nlmsg_len, GFP_KERNEL); memcpy(str_buf, NLMSG_DATA(nlh), nlh->nlmsg_len); str_buf[nlh->nlmsg_len - 1] = '\0'; printk("Message received(%d):%s\n", nlh->nlmsg_pid, str_buf) ; kfree(str_buf); /*nlh->nlmsg_pid是发送者的用户进程ID,传递，用于描述内核返回消息时的发送对象*/ if(!eknetlink_sendmsg("From kernel: hello user!", nlh->nlmsg_pid)){ printk("eknetlink_rcv_msg send fail. \n"); } } TFR("eknetlink_rcv_msg exit.\n"); return 0;}4. 内核netlink消息发送函数：
/* message: 要发送的消息字符串 pid :发送的目标，用户进程ID*/int eknetlink_sendmsg(char *message, int pid){ struct sk_buff *skb; struct nlmsghdr *nlh; int msize = 0; int ret; if(!message || !eknl) { return -1; } msize = strlen(message) + 1; /* nlmsg_new 会新申请一个socket buffer ，其大小为 socket消息头大小+ netlink 消息头大小+ 用户消息大小*/ skb = nlmsg_new(msize, GFP_KERNEL); if(!skb) { printk(KERN_ERR "eknetlink_sendnlmsg:alloc_skb_1 error\n"); return -1; } nlh = nlmsg_put(skb,0,0,0,msize,0); /*填充部分netlink消息头*/ NETLINK_CB(skb).pid = 0; /*描述发送者ID，这里发送者是内核，填0*/ NETLINK_CB(skb).dst_group = 0; memcpy(NLMSG_DATA(nlh), message, msize);/*填充用户区数据*/ printk("Message send '%s'.\n",(char *)NLMSG_DATA(nlh)); ret = NF_HOOK(AF_NETLINK, NF_EKNETLINK_OUT, skb, NULL, NULL, eknetlink_okfn); if (NF_ACCEPT != ret) { printk("out NF_HOOK not accept (%d)!\n", ret); return -1; } /*单播消息，目标用户态pid*/ /*需要特别注意的是: skb申请的空间会在这里面释放， 所以不能重复调用此接口发送同一个skb，会造成严重后果*/ return netlink_unicast(eknl, skb, pid, MSG_DONTWAIT); }
5. 内核netlink消息过滤：
netfilter 提供了一种过滤机制，上文在eknetlink_init 中 调用nf_register_hook注册了一个过滤钩子，即可以对收发消息进行截取或者过滤。
这个机制不是netlink独有的，是socket网络代码的一部分，但是也可以修改后被netlink借过来使用。
需要在本模块的消息接收和发送接口中主动调用NF_HOOK，这个钩子才能被执行。
查看宏 NF_HOOK 的定义可知：只有当eknl_hook()和eknetlink_okfn()都返回NF_ACCEPT，此消息包才会判定为允许接收。
static unsigned int eknl_hook(unsigned int hook, struct sk_buff *skb, const struct net_device *in, const struct net_device *out, int (*okfn)(struct sk_buff *)){ TFR("eknl_hook .\n"); return NF_ACCEPT; /*钩子回调，返回NF_ACCEPT表示数据允许接收*/}int eknetlink_okfn (struct sk_buff * skb){ TFR("eknetlink_okfn .skb(0x%x)\n", (unsigned int)skb); return NF_ACCEPT; /*钩子回调的回调，返回NF_ACCEPT表示数据允许接收，*/}static struct nf_hook_ops eknl_ops __read_mostly = { .hook = eknl_hook, .pf = AF_NETLINK, /*设定这个值的同时需要修改NFPROTO_NUMPROTO, 否则nf_register_hook访问nf_hooks会溢出，系统一直起不来。*/ .hooknum = NF_EKNETLINK_IN, .priority = 0, .owner = THIS_MODULE,};修改NFPROTO_NUMPROTO，在文件netfilter.h中：
enum {NFPROTO_UNSPEC = 0,NFPROTO_IPV4 = 2,NFPROTO_ARP = 3,NFPROTO_BRIDGE = 7,NFPROTO_IPV6 = 10,NFPROTO_DECNET = 12, NFPROTO_NETLINK = 16 , /*add for netlink study*/NFPROTO_NUMPROTO,};6. 新增编译脚本并编译内核：
Kconfig
config EKNETLINK tristate "Netlink study example." default n help Netlink example for study, this is kernel part , cooperation with net link usr example part.
Makefile
obj-$(CONFIG_EKNETLINK) += eknetlink.o
make menuconfig 打开eknetlink模块编译
make -j4 编译内核
至此内核的netlink新增通道接收和发送流程描述完成，接下来记录用户态的netlink新增通道实现。
二、用户部分代码：
在用户态新增源码文件
external/netlink/eunetlink.c
1) 头文件和静态申明
/*user example code for netlink study*/#include <asm/types.h>#include <sys/socket.h>#include <unistd.h>#include <err.h>#include <stdio.h>#include <netinet/in.h>#include <linux/netlink.h>#include <linux/rtnetlink.h>
enum { EUNETLINK_MSG_OPEN = NLMSG_MIN_TYPE, /*比NLMSG_MIN_TYPE 小的类型是系统保留的，不能使用， 否则消息在内核回调中会被netlink_rcv_skb过滤，eknetlink_rcv_msg得不到调用*/ EUNETLINK_MSG_CLOSE}EUNETLINK_MSG;
#define NETLINK_EXAMPLE 31 /*新增netlink协议类型，和内核态的定义保持一致*/
2) 用户态主函数
int main(int argc, char *argv[]){ int nlsk = eunetlink_open(); /*打开一个netlink 套接字*/ int ret; if (nlsk<0) { err(1,"netlink"); return -1; } printf("eunetlink open socket = 0x%x\n", nlsk); ret = eunetlink_send(nlsk); /*向内核发送"hello"消息*/ printf("eunetlink send ret = 0x%x\n", ret); eunetlink_recv(nlsk); /*等待接收内核返回的消息*/ close(nlsk); /*关闭netlink 套接字*/ return 0;}
3）用户态消息发送接口
int eunetlink_send(int nlsk){ char buffer[] = "From user : hello kernel!"; struct nlmsghdr* nlhdr; struct iovec iov; /* 用于把多个消息通过一次系统调用来发送*/ struct msghdr msg; struct sockaddr_nl nladdr; /*必须，消息头数据清零，否则会包含错误的数据，发送失败*/ memset(&msg, 0 ,sizeof(struct msghdr)); memset(&nladdr, 0 ,sizeof(struct sockaddr_nl)); nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(strlen(buffer) + 1)); strcpy(NLMSG_DATA(nlhdr),buffer); /*填充待发送的消息体*/ nlhdr->nlmsg_len = NLMSG_LENGTH(strlen(buffer) + 1); nlhdr->nlmsg_pid = getpid(); /*发送者进程ID，内核代码会根据这个ID返回消息*/ nlhdr->nlmsg_flags = NLM_F_REQUEST; /*必须,不设置的话，内核中netlink_rcv_skb() 会过滤此消息，不会调用户回调*/ nlhdr->nlmsg_type = EUNETLINK_MSG_OPEN; /*必须,不设置的话，内核中netlink_rcv_skb() 会过滤此消息，不会调用户回调*/ /*填充目标地址结构体*/ nladdr.nl_family = AF_NETLINK; nladdr.nl_pid = 0; /*目标地址是内核，所以这里需要填0*/ nladdr.nl_groups = 0; printf("Message Send :%s\n",buffer); #if 0 /*使用struct iovec iov[]数组 和 sendmsg可以实现一次调用发送多个消息请求*/ iov.iov_base = (void *)nlhdr; iov.iov_len = nlhdr->nlmsg_len; msg.msg_iov = &iov; msg.msg_iovlen = 1; msg.msg_name = (void *)&(nladdr); msg.msg_namelen = sizeof(nladdr); return sendmsg(nlsk, &msg, 0); #else /*发送单个个请求*/ return sendto(nlsk, nlhdr, nlhdr->nlmsg_len, 0, (struct sockaddr*)&nladdr, sizeof(nladdr));#endif }4）用户态消息接收
int eunetlink_recv(int sock){ struct sockaddr_nl nladdr; struct msghdr msg; struct iovec iov[1]; struct nlmsghdr * nlh; char buffer[65536]; /*临时buffer，用于接收内核发过来的数据*/ int len; /*填充待接收消息结构体*/ msg.msg_name = (void *)&(nladdr); /*设定接收的发送源地址*/ msg.msg_namelen = sizeof(nladdr); /*设定临时缓冲*/ iov[0].iov_base = (void *)buffer; iov[0].iov_len = sizeof(buffer); msg.msg_iov = iov; msg.msg_iovlen = sizeof(iov)/sizeof(iov[0]); /*允许多个临时缓冲*/ len = recvmsg(sock, &msg, 0); /*阻塞等待接收数(除非特别设定，socket都是阻塞式接收)*/ if (len < 0) { printf("recvmsg error: %d", len); return len; } /*遍历接收到的消息数据，进行处理 NLMSG_OK会判断数据是不是已经结束 NLMSG_NEXT 会修改nlh和len的值，使之指向buffer中的下一个netlink消息 */ for (nlh = (struct nlmsghdr *)buffer; NLMSG_OK(nlh, len); nlh = NLMSG_NEXT(nlh, len)) { if (nlh->nlmsg_type == NLMSG_ERROR) { // Do some error handling. puts("eunetlink_recv: NLMSG_ERROR"); return 0; } /*处理有效的用户数据*/ if (nlh->nlmsg_len > 0) { char *str_buf = malloc(nlh->nlmsg_len); memcpy(str_buf, NLMSG_DATA(nlh), nlh->nlmsg_len); str_buf[nlh->nlmsg_len - 1] = '\0'; printf("Message received:%s\n",str_buf) ; free(str_buf); } } return 0;}5）新增编译脚本并编译用户应用程序
新增external/netlink/Android.mk
LOCAL_PATH := $(call my-dir)include $(CLEAR_VARS)LOCAL_MODULE_TAGS := optionalLOCAL_MODULE := eunetlinkLOCAL_SRC_FILES := $(call all-subdir-c-files)include $(BUILD_EXECUTABLE)
编译用户程序:
mmm external/netlink/
打包system.img:
make snod
三、运行和调试
1）。运行android的goldfish模拟器，使用新编译出来的内核:
emulator -kernel (YOUR_KERNEL_PATH)/arch/arm/boot/zImage -shell
运行用户测试程序：
eunetlink
正确执行会显示如下信息：
本篇代码的内核态打印：
2）调试用户态
运行： strace eunetlink
会显示所有用户态的系统调用路径和返回值，并且会把入参展开显示，这个对调试很有用：
这里截取其中本文代码相关的部分：
四、总结
netlink提供了一种很好很强大的的用户与内核之间的通讯机制，本文通过静态的新增一个netlink协议类型，并使用这个新的netlink类型实现用户态和内核态的双向通讯，对linux的netlink通讯方式有了一个初步的认识。
动态申请 netlink通道机制在genetlink.c中实现，是对NETLINK_GENERIC协议的上层封装， 可以参考内核代码net\tipc\netlink.c中的对他的应用，这个文件实现比较简单，可以作为很好的样例。
说明：本文所含代码的运行环境为 android提供的 goldfish 模拟器平台， Linux 内核版本为 2.6.29
参考文档：
android-goldfish-2.6.29 code
《Linux内核设计与实现》(Linux Kernel Development)第3版 》
Linux 用户态与内核态的交互——netlink 篇：http://bbs.chinaunix.net/thread-2162796-1-1.html
《Linux 系统内核空间与用户空间通信的实现与分析》 陈鑫 http://www-128.ibm.com/developerworks/cn/linux/l-netlink/?ca=dwcn-newsletter-linux
《在 Linux 下用户空间与内核空间数据交换的方式》 杨燚 http://www-128.ibm.com/developerworks/cn/linux/l-kerns-usrs/