linux内核之内核与ring3的通信

现在使用NETLINK进行内核与上层应用之间的通信，我们不说别的了，直接上代码把：

内核空间的：

//内核端
#include <linux/init.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <net/sock.h>
#include <net/netlink.h>
#define NETLINK_TEST 25
#define MAX_MSGSIZE 1024
int err;
struct sock *nl_sk = NULL;
void nl_data_ready(struct sk_buff *__skb)
 {
     printk("nl_data_ready has been called %s\n") ;
     struct sk_buff *skb;
     struct nlmsghdr *nlh;
     char str[100];          
     skb = skb_get (__skb);
     if(skb->len >= NLMSG_SPACE(0))
     {
         nlh = nlmsg_hdr(skb);
		 //这一部分，我们也可以看分明了NLMSG_DATA，是越过了消息头部，移动到了消息体位置
         memcpy(str, NLMSG_DATA(nlh), sizeof(str));
		 //将消息体内容复制到了str当中，然后输出
         printk("Message received:%s\n",str) ;
    }
 }
// Initialize netlink
int netlink_init(void)
{
	 struct netlink_kernel_cfg cfg = {  
        .input =  nl_data_ready,  
    }; 	
	//cfg只需要设定回调函数，该函数在每次有消息传递给内核的时候自动调用
	nl_sk = netlink_kernel_create(&init_net, NETLINK_TEST, &cfg);
	if(!nl_sk){
	printk(KERN_ERR "my_net_link: create netlink socket error.\n");
        return 1;
    }
    printk("my_net_link_3: create netlink socket ok.\n");
    return 0;
}
//当然在该驱动卸载的时候，进行自动调用sock_release
static void netlink_exit(void)
{
    if(nl_sk != NULL){
        sock_release(nl_sk->sk_socket);
    }
    printk("my_net_link: self module exited\n");
}
module_init(netlink_init);
module_exit(netlink_exit);

内核空间的Makefile

obj-m := main.o
all:
	make -C /lib/modules/`uname -r`/build SUBDIRS=$(PWD) modules 
clean:
	make -C /lib/modules/`uname -r`/build SUBDIRS=$(PWD) clean    

PS:

这里，在内核空间主要也就一部分，就是netlink_kernel_create，在这个函数中注册回调函数，该回调函数在有应用使用netlink向 内核发送消息时自动调用

nlmsg_hdr获取netlink的数据包中netlink_header的头部地址

NLMSG_DATA 的作用就是根据netlink的头部地址，进行消息头部的偏移，然后进行获取消息体，真正消息体的地址

用户空间的源代码：

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <sys/types.h>  
#include <sys/socket.h>  
#include <asm/types.h>  
#include <linux/socket.h>  
#include <linux/netlink.h> 
#include <unistd.h>  
#include<errno.h>
#define USER_NETLINK_CMD    25  
#define MAXMSGLEN           1024    
typedef enum error_e {  
    NET_ERROR,  
    NET_OK,  
    NET_PARAM,  
    NET_MEM,  
    NET_SOCK,  
} netlink_err;  
  
typedef enum module_e {  
    HELLO_CMD = 1,  
} netlink_module;  
  
typedef enum type_e {  
    HELLO_SET,  
    HELLO_GET,  
} netlink_type;  
  
typedef struct usr_sock_h {  
    int sock;  
    struct sockaddr_nl dest;  
    struct sockaddr_nl src;  
} netlink_sock;  
  
int netlink_sock_init(netlink_sock *netlink_s, int module, int protocol);  
int netlink_sock_deinit(netlink_sock *netlink_s);  
int netlink_send(netlink_sock *netlink_s, int type, char *sbuf, int slen, char *rbuf, int *rlen);    
int netlink_sock_init(netlink_sock *netlink_s, int module, int protocol)  
{  
	// 创建套接字，需要注意的是第二个参数要么是SOCK_RAW 或者是SOCK_DGRAM
    netlink_s->sock = socket(PF_NETLINK, SOCK_RAW, protocol);  
    if(netlink_s->sock < 0)  
        return NET_SOCK;  
	// 在发送过程中我们需要进行发送方源地址的填充
    memset(&netlink_s->src, 0 ,sizeof(netlink_s->src)); 
	// nl_family必须是AF_NETLINK
    netlink_s->src.nl_family = AF_NETLINK;  
	// nl_pid 应该是getpid()，也就是发送方的pid
    netlink_s->src.nl_pid = module;  
    netlink_s->src.nl_groups = 0;  
	//将sockfd也即netlink_s->sock与特定地址，也即进程号进行绑定
    if(bind(netlink_s->sock, (struct sockaddr *)&netlink_s->src, sizeof(netlink_s->src)) < 0)  
        return NET_SOCK;    	
    netlink_s->dest.nl_family = AF_NETLINK;  
	//设定目的地址，也即nl_pid是目的进程号，如果是0的话，那么表示目的进程是内核
    netlink_s->dest.nl_pid = 0; 
	//不加入任何组播
    netlink_s->dest.nl_groups = 0;  
    return NET_OK;  
}  
  
int netlink_send(netlink_sock *netlink_s, int type, char *sbuf, int slen, char *rbuf, int *rlen)  
{  
	//必须初始化为0，如果没有初始化的话，可能no buffer avaliable
    struct msghdr msg={0};  
    struct nlmsghdr *nlhdr = NULL;  
    struct iovec iov;  
    int ret;    
	//申请空间，该空间应该由两部分，一部分是由消息头部组成，另一部分则是消息本身
    nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAXMSGLEN));  
    if(NULL == nlhdr)  
        return NET_MEM;    
	// NLMSG_DATA表示的是越过消息头部，移动到消息体位置的指针
    memcpy(NLMSG_DATA(nlhdr), sbuf,slen); 
	//这一部分当然就是设置消息头部，或者说发送方的地址
    nlhdr->nlmsg_len = NLMSG_SPACE(slen);  
    nlhdr->nlmsg_pid = netlink_s->src.nl_pid;  
    nlhdr->nlmsg_type = type;  
    nlhdr->nlmsg_flags = 0;    
    iov.iov_base = (void *)nlhdr; //发送内容，其中包括发送源地址 NLMSG_DATA(nlhdr)之后才是真正的内容
    iov.iov_len = nlhdr->nlmsg_len;   
	//发送的目的地址dest的pid是0，表示发送到内核
    msg.msg_name = (void *)&(netlink_s->dest);  
    msg.msg_namelen = sizeof(netlink_s->dest);  
    msg.msg_iov = &iov;  
    msg.msg_iovlen = 1;    
    ret = sendmsg(netlink_s->sock, &msg, 0);  
    if(ret < 0)  
    {  
        printf("Send fail %s\n",strerror(errno));  
        goto error;  
    }   
	free(nlhdr);
    return NET_OK;    
error:  
    free(nlhdr);  
    return NET_SOCK;  
}  
int netlink_sock_deinit(netlink_sock *netlink_s)  
{  
    close(netlink_s->sock);  
    memset(netlink_s, 0, sizeof(netlink_sock));  
    return NET_OK;  
}  
int parse_ret(int ret)  
{  
 switch(ret)  
{  
  case NET_OK:  
       return ret;  
  case NET_ERROR:  
       printf("error\n");  
       goto exit_p;  
  case NET_MEM:  
       printf("Memory error:%s\n",strerror(errno));  
       goto exit_p;  
  case NET_PARAM:  
       printf("Param error:%s\n",strerror(errno));  
       goto exit_p;  
  case NET_SOCK:  
       printf("Socket error:%s\n",strerror(errno));  
       goto exit_p;  
  default:break;  
}  
 exit_p:  
     return NET_ERROR;  
 } 
   
 int main(int argc, char **argv)  
 {  
     netlink_sock h_sock;  
     char rbuf[1024];  
     char sbuf[1024];  
     int ret, type, slen = 0, rlen = 0;     
     ret = netlink_sock_init(&h_sock,getpid(), USER_NETLINK_CMD);  
     if(NET_OK != parse_ret(ret))  
         goto exit_p;     
     bzero(&rbuf, sizeof(rbuf));  
     bzero(&sbuf, sizeof(sbuf));    
     type = HELLO_SET;             
     strcpy(sbuf,"this is from ring3"); 
     slen = strlen(sbuf);  
     ret = netlink_send(&h_sock, type, sbuf, slen, rbuf, &rlen);   
     if(ret ==NET_OK)  
     {           
         printf("send succefully:%s\n", sbuf);  
     }      
 exit_p:  
     netlink_sock_deinit(&h_sock);  
     return 0;  
 }  

PS:

     这一部分，要做的三件事，其一

    1.创建套接字，但必须注意的是SOCK_RAW或者是SOCK_DGRAM

     2.bind操作，也即将当前进程的PID和创建的套接字进行绑定，根据这个套接字进行消息的发送和接收

     3.使用sendmsg函数进行消息的发送，这里面需要注意的是我们在发送过程中，消息的构造

      msg.msg_name:指明的是发送地址

      msg.msg_namelen:指明的是发送地址的长度

      而msg.iov_base:指的是发送内容，然而该部分主要由两部分组成，一部分是消息头部，一部分是消息体，消息头部中指明的是发送方的地址

      也即iov_base中把消息头部和消息体放在一起，进行发送