内核和用户空间之间存在如下交互手段:
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_EXAMPLE 31 /*新增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) 头文件和静态申明
<p style="margin-top: 0px; margin-bottom: 10px; padding-top: 0px; padding-bottom: 0px; text-indent: 28px;">/*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></p><p style="margin-top: 0px; margin-bottom: 10px; padding-top: 0px; padding-bottom: 0px; text-indent: 28px;">enum { EUNETLINK_MSG_OPEN = NLMSG_MIN_TYPE, /*比NLMSG_MIN_TYPE 小的类型是系统保留的,不能使用, 否则消息在内核回调中会被netlink_rcv_skb过滤,eknetlink_rcv_msg得不到调用*/ EUNETLINK_MSG_CLOSE }EUNETLINK_MSG;</p><p style="margin-top: 0px; margin-bottom: 10px; padding-top: 0px; padding-bottom: 0px; text-indent: 28px;">#define NETLINK_EXAMPLE 31 /*新增netlink协议类型,和内核态的定义保持一致*/ </p>
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 := optional LOCAL_MODULE := eunetlink LOCAL_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/