1.NetLink机制
NetLink是一种基于应用层跟内核态的通信机制，其特点是一种异步全双工的通信方式，支持内核态主动发起通信的机制。该机制提供了一组特殊的API接口,用户态则通过socket API调用。内核发送的数据再应用层接收后会保存在接收进程socket的缓存中，再由接受进程处理。
2.NetLink通信示意图:
3.驱动文件ko文件的初始化与停止使用方式:
/* 模块入口函数 */
static int __init my_ko_init(void) {
/**
doing
*/
printk("I am init self ko !!!");
return 0;
}
/* 模块退出函数 */
static void __exit my_ko_exit(void) {
// 注销netlink协议
printk("I am exit self ko !!!");
return;
}
module_init(my_ko_init)
module_exit(my_ko__exit)
MODULE_AUTHOR("my_self_ko");
MODULE_DESCRIPTION("self ko study");
MODULE_LICENSE("GPL");注：自定义的ko文件使用,按照如上图的模版标准来进行实现对应的功能，该模版是初始化跟退出还原方法，通过module_init,module_exit,两个函数进行插入加载跟卸载还原内核态信息（避免出现内核崩溃。
makefile：
obj-m += my_self_ko.o
all:
make -C /lib/modules/$(shell uname -r)/build/ M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build/ M=$(PWD) clean4.用户态创建NetLink套接字通信
4.1 netlink_kernel_create函数
用于创建一个内核态的netlink的socket服务。该函数对应的参数在不同的版本之间是不同的设定:
头文件:linux/netlink.h
netlink_kernel_create(struct net *net, int unit, struct netlink_kernel_cfg *cfg)
a. LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)的函数参数定义:
netlink_kernel_create(NETLINK_SELF_MODULE,0,netlink_kernel_rcv,THIS_MODULE);
b. KERNEL_VERSION(2,6,24)< LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0)
netlink_kernel_create(&init_net, NETLINK_SELF_MODULE,0, netlink_kernel_rcv, NULL, THIS_MODULE);
c. LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)
struct netlink_kernel_cfg cfg = {
.input = netlink_kernel_rcv,
};
netlink_kernel_create(&init_net, NETLINK_SELF_MODULE,0, &cfg);以上为内核驱动ko文件内创建netlink的方法,netlink_kernel_rcv自定义的回调处理函数。
netlink_kernel_create函数：
返回值: sock 对象指针.
参数1: init_net,系统内部定义的类型，默认使用即可.
参数2:自定义的通信消息类型，根据实际定义,但是避免跟系统冲以及不要超过系统范围。
参数3:默认设置0
参数4:设置系统消息回调函数,不同版本该接口有差异性，如上代码。
具体的方式通过客户端主动链接,双向通信。例如:
内核ko驱动代码:
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/netlink.h>
#include <net/netlink.h>
#define NETLINK_TEST 17
struct sock *nl_sk = NULL;
static void hello_nl_recv_msg(struct sk_buff *skb)
{
struct nlmsghdr *nlh;
int pid;
struct sk_buff *skb_out;
int msg_size;
char *msg = "Hello from kernel";
int res;
printk(KERN_INFO "Entering: %s\n", __FUNCTION__);
msg_size = strlen(msg);
nlh = (struct nlmsghdr *)skb->data;
printk(KERN_INFO "Netlink received msg payload:%s\n", (char *)nlmsg_data(nlh));
pid = nlh->nlmsg_pid; /*pid of sending process */
skb_out = nlmsg_new(msg_size, 0);
if (!skb_out) {
printk(KERN_ERR "Failed to allocate new skb\n");
return;
}
nlh = nlmsg_put(skb_out, 0, 0, NLMSG_DONE, msg_size, 0);
NETLINK_CB(skb_out).dst_group = 0; /* not in mcast group */
strncpy(nlmsg_data(nlh), msg, msg_size);
res = nlmsg_unicast(nl_sk, skb_out, pid);
if (res < 0)
printk(KERN_INFO "Error while sending bak to user\n");
}
static int __init hello_init(void)
{
printk("Entering: %s\n", __FUNCTION__);
nl_sk = netlink_kernel_create(&init_net, NETLINK_TEST, 0, hello_nl_recv_msg, NULL, THIS_MODULE);
if (!nl_sk) {
printk(KERN_ALERT "Error creating socket.\n");
return -10;
}
return 0;
}
static void __exit hello_exit(void)
{
printk(KERN_INFO "exiting hello module\n");
netlink_kernel_release(nl_sk);
}
module_init(hello_init);
module_exit(hello_exit);
客户端:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#define NETLINK_TEST 17
struct sockaddr_nl src_addr, dest_addr;
struct nlmsghdr *nlh = NULL;
struct iovec iov;
struct msghdr msg;
int main()
{
int sock_fd;
sock_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_TEST);
if(sock_fd < 0)
return -1;
memset(&src_addr, 0, sizeof(src_addr));
src_addr.nl_family = AF_NETLINK;
src_addr.nl_pid = getpid();
bind(sock_fd, (struct sockaddr*)&src_addr, sizeof(src_addr));
memset(&dest_addr, 0, sizeof(dest_addr));
dest_addr.nl_family = AF_NETLINK;
dest_addr.nl_pid = 0; // For Linux Kernel
dest_addr.nl_groups = 0; // unicast
nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(1024));
memset(nlh, 0, NLMSG_SPACE(1024));
nlh->nlmsg_len = NLMSG_SPACE(1024);
nlh->nlmsg_pid = getpid();
nlh->nlmsg_flags = 0;
strcpy(NLMSG_DATA(nlh), "Hello from user space!");
iov.iov_base = (void *)nlh;
iov.iov_len = nlh->nlmsg_len;
msg.msg_name = (void *)&dest_addr;
msg.msg_namelen = sizeof(dest_addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
printf("Sending message to kernel\n");
sendmsg(sock_fd, &msg, 0);
printf("Waiting for message from kernel\n");
memset(nlh, 0, NLMSG_SPACE(1024));
recvmsg(sock_fd, &msg, 0);
printf("Received message: %s\n", NLMSG_DATA(nlh));
close(sock_fd);
return 0;
}上述代码中自定义通信类型,不可以跟系统重复,否则会导致写入ko文件失败.如下:
注:驱动文件ko插入内核NetLink启动失败导致内核ko驱动不可用：
如调用失败,最可能原因，第二个参数NETLINK_TEST_MODULE错误,可能已经被系统占用。需 要重新更换该类型参数。可以通过: cat /proc/net/netlink 查看当前使用的内核类型，自我使用是 否跟内核冲突,修改即可。另外应用层也需同步修改NETLINK_TEST_MODULE ,如下所示:
nlsock = netlink_kernel_create(&init_net, NETLINK_TEST_MODULE, &cfg);注:自定义的文件,是不会主动从内核卸载的，当前系统使用的可以通过lsmod ｜grep 自定义ko文件名,查看当前的引用计数,只有当引用计数为0时，才可以卸载该驱动文件。可以使用rmmod 驱动文件名。
