|
上一节说到proc文件系统，这是用户态和内核态通信的一种方法，本节将要说到另外一种通信的方法，该方法相比于其他的内核和用户通信有时在于：
Netlink相对于其他的通信机制具有以下优点：
1.使用Netlink通过自定义一种新的协议并加入协议族即可通过socket API使用Netlink协议完成数据交换，而ioctl和proc文件系统均需要通过程序加入相应的设备或文件。
2.Netlink使用socket缓存队列，是一种异步通信机制，而ioctl是同步通信机制，如果传输的数据量较大，会影响系统性能。
3.Netlink支持多播，属于一个Netlink组的模块和进程都能获得该多播消息。
4.Netlink允许内核发起会话，而ioctl和系统调用只能由用户空间进程发起。
建立netlink会话如下：
1.在内核使用netlink_kernel_create()创建套接字，指明接受函数。
2.在用户态创建套接字，并将进程ID发送至内核空间。
3.内核接受函数收到用户空间进程ID。
4.用户空间与内核空间可以通信。
需要详细描述的内容太多，下面直接给一个例子算了，以后有时间在细说，
下面是内核部分代码：
#include <linux/init.h>
#include <linux/module.h>
#include <linux/version.h> //LINUX_VERSION_CODE
#include <net/sock.h> //struct sock *
#include <linux/netlink.h> //netlink_kernel_create()
#include <linux/sched.h>
#include "netlink_k.h"
static struct sock *nlfd;
static int pid;
int netlink_deliver(uint16_t type, void *data, unsigned short dlen)
{
int ret, len;
char *old_tail;
struct sk_buff *skb = NULL;
struct nlmsghdr *nlh = NULL;
if (0 == pid) {
return 0;
}
len = NLMSG_SPACE(dlen + sizeof(unsigned short));
skb = alloc_skb(len, GFP_ATOMIC);
if (NULL == skb) {
printk(KERN_ALERT"alloc skb failed!\n");
goto nlmsg_failure;
}
old_tail = (char *)skb->tail;
nlh = NLMSG_PUT(skb, 0, 0, type, len - sizeof(*nlh));
memcpy((char *)NLMSG_DATA(nlh), &dlen, sizeof(unsigned short));
memcpy((char *)NLMSG_DATA(nlh) + sizeof(unsigned short), data, dlen);
nlh->nlmsg_len = (char *)skb->tail - (char *)old_tail;
NETLINK_CB(skb).dst_group = 0;
printk(KERN_ALERT"Send: data: %s, dlen = %d, nlh->nlmsg_len: %d\n", (char*)data, (int)dlen, nlh->nlmsg_len);
ret = netlink_unicast(nlfd, skb, pid, MSG_DONTWAIT);
return ret;
nlmsg_failure:
if(skb)
kfree_skb(skb);
return -1;
}
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
void nlsock_receive_process(struct sock *sk, int len)
{
struct sk_buff *skb = NULL;
struct nlmsghdr *nlh = NULL;
char info[] = "Haha, welcome to Kernel!";
unsigned char data[MAX_PACKET];
unsigned short dlen;
while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
nlh = (struct nlmsghdr *)skb->data;
#else
void nlsock_receive_process(struct sk_buff *skb)
{
struct nlmsghdr *nlh = NULL;
char info[] = "Haha, welcome to Kernel!";
unsigned char *data = NULL;
unsigned short dlen;
nlh = nlmsg_hdr(skb);
#endif
printk(KERN_ALERT"===%s===\n", __func__);
pid = nlh->nlmsg_pid;
memcpy(&dlen, (char *)NLMSG_DATA(nlh), sizeof(unsigned short));
printk(KERN_ALERT"dlen: %d\n", dlen);
data = (char *)NLMSG_DATA(nlh) + sizeof(unsigned short);
//sln_dump_pkt(NLMSG_DATA(nlh), 100);
printk(KERN_ALERT"Receive netlink data: %s, nlh->nlmsg_len = %d\n",
data, nlh->nlmsg_len);
netlink_deliver(NL_FRAMEIO, info, strlen(info));
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
}
#endif
}
static int __init nlk_init(void)
{
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
nlfd = netlink_kernel_create(NL_FRAMEIO,
0,
nlsock_receive_process,
THIS_MODULE);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,5)
struct netlink_kernel_cfg cfg = {
.input = nlsock_receive_process,
};
nlfd = netlink_kernel_create(&init_net,
NL_FRAMEIO,
THIS_MODULE,
&cfg);
#else
nlfd = netlink_kernel_create(&init_net,
NL_FRAMEIO,
0,
nlsock_receive_process,
NULL,
THIS_MODULE);
#endif
printk(KERN_ALERT"===%s===\n", __func__);
if (NULL == nlfd) {
printk(KERN_ALERT"Can't create netlink sock!\n");
return -1;
}
return 0;
}
static void __exit nlk_exit(void)
{
printk(KERN_ALERT"===%s===\n", __func__);
if (NULL != nlfd) {
netlink_kernel_release(nlfd);
nlfd = NULL;
}
}
module_init(nlk_init);
module_exit(nlk_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("sln");
下面是用户态部分代码：
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <linux/netlink.h>
#include <linux/socket.h>
#include "netlink_u.h"
struct sockaddr_nl local_addr, dest_addr;
int sockfd;
int bcm_netlink_init(void)
{
sockfd = socket(PF_NETLINK, SOCK_RAW, NL_FRAMEIO);
if (sockfd < 0) {
fprintf(stderr, "sockfd: %s\n", strerror(errno));
return -1;
}
memset(&local_addr, 0, sizeof(local_addr));
local_addr.nl_family = AF_NETLINK;
local_addr.nl_pid = getpid(); /* self pid */
local_addr.nl_groups = 0; /* not in mcast groups */
if (bind(sockfd, (struct sockaddr *)&local_addr, sizeof(local_addr)) < 0) {
fprintf(stderr, "bind: %s\n", strerror(errno));
close(sockfd);
return -1;
}
memset(&dest_addr, 0, sizeof(dest_addr));
dest_addr.nl_family = AF_NETLINK;
dest_addr.nl_pid = 0; /* To Linux Kernel */
dest_addr.nl_groups = 0; /* unicast */
return 0;
}
int bcm_netlink_send(char *data, unsigned short dlen)
{
int len;
struct iovec iov;
struct msghdr msg;
struct nlmsghdr *nlh = NULL;
nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(dlen + sizeof(unsigned short)));
if (NULL == nlh) {
printf("malloc failed!\n");
return -1;
}
/* Fill the netlink message header */
memset(nlh, 0, sizeof(struct nlmsghdr));
// nlh->nlmsg_len = NLMSG_SPACE(MAX_PACKET);
nlh->nlmsg_len = NLMSG_SPACE(dlen + sizeof(unsigned short));
nlh->nlmsg_pid = getpid(); /* self pid */
nlh->nlmsg_flags = 0;
/* Fill in the netlink message payload */
memcpy(NLMSG_DATA(nlh), &dlen, sizeof(unsigned short));
memcpy((char *)NLMSG_DATA(nlh) + sizeof(unsigned short), data, dlen);
/*
* if not two line below, send will failure. Very IMPORTANT !
*/
memset(&iov, 0, sizeof(struct iovec));
memset(&msg, 0, sizeof(struct msghdr));
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;
while ((len = sendmsg(sockfd, &msg, 0)) < 0) {
if (errno == EINTR) {
continue;
}
fprintf(stderr, "sendmsg: %s, len = %d\n", strerror(errno), len);
return -1;
}
fprintf(stderr, "senddata: %s, sizeof(struct nlmsghdr) = %d, mydatalen: %d, sendlen = %d\n",
data, (int)sizeof(struct nlmsghdr), (int)dlen, len);
return 0;
}
int bcm_netlink_recv()
{
struct sockaddr_nl peer_addr;
struct nlmsghdr *nlh = NULL;
struct iovec iov;
int recvlen;
struct msghdr msg;
char *data = NULL;
unsigned short dlen;
nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(dlen + sizeof(unsigned short)));
if (NULL == nlh) {
printf("malloc failed!\n");
return -1;
}
/* Fill the netlink message header */
memset(nlh, 0, sizeof(struct nlmsghdr));
nlh->nlmsg_len = NLMSG_SPACE(MAX_PACKET);
nlh->nlmsg_pid = getpid(); /* self pid */
nlh->nlmsg_flags = 0;
/*
* if not two line below ,send will failure. Very IMPORTANT!
*/
memset(&iov, 0, sizeof(struct iovec));
memset(&msg, 0, sizeof(struct msghdr));
iov.iov_base = (void *)nlh;
iov.iov_len = nlh->nlmsg_len;
msg.msg_name = (void *)&peer_addr;
msg.msg_namelen = sizeof(peer_addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
/* A loop to read message from kernel */
for (;;) {
memset(nlh, 0, nlh->nlmsg_len);
if ((recvlen = recvmsg(sockfd, &msg, 0)) < 0) {
fprintf(stderr, "recvmsg: %s\n", strerror(errno));
continue;
}
memcpy(&dlen, (char *)NLMSG_DATA(nlh), sizeof(unsigned short));
data = (char *)NLMSG_DATA(nlh) + sizeof(unsigned short);
fprintf(stdout, "Received message payload: %s, recvlen: %d, dlen: %d\n",
data, recvlen, dlen);
}
}
int main(int argc, char* argv[])
{
int ret;
pthread_t pid;
char sendbuf[MAX_PACKET] = "info from user!";
ret = bcm_netlink_init();
if (ret < 0) {
goto err;
}
if (pthread_create(&pid, NULL, (void *)bcm_netlink_recv, NULL) < 0) {
fprintf(stderr, "Create receive thread failed!\n");
goto err;
}
for (;;) {
sleep(1);
bcm_netlink_send(sendbuf, strlen(sendbuf));
}
// pthread_join(pid, NULL);
err:
if (sockfd > 0) {
close(sockfd);
}
return 0;
}
|