搭建內核態與用戶態通信機制

Netlink相對於其他的通信機制具有以下優點：

1. 使用Netlink通過自定義一種新的協議並加入協議族即可通過socket API使用Netlink協議完成數據交換，而ioctl和proc文件系統均需要通過程序加入相應的設備或文件。
2. Netlink使用socket緩存隊列，是一種異步通信機制，而ioctl是同步通信機制，如果傳輸的數據量較大，會影響系統性能。
3. Netlink支持多播，屬於一個Netlink組的模塊和進程都能獲得該多播消息。
4. Netlink允許內核發起會話，而ioctl和系統調用只能由用戶空間進程發起。

內核態代碼： 

#include <linux/module.h>
#include <linux/crypto.h>

#include <linux/sched.h>
#include <net/netlink.h>
#include <linux/security.h>
#include <net/net_namespace.h>
#include <linux/mutex.h>

#include <linux/kernel.h>
#include <linux/if.h>
#include <linux/timer.h>
#include <linux/netdevice.h>
#include <linux/inetdevice.h>
#include <linux/if_arp.h>
#include <linux/list.h>

#include <linux/string.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

#include "netlink_drv.h"

static struct sock *nlsk;

static int send_id_to_user(struct sock *ntsk, int pid, unsigned char id, int ret)
{
    struct sk_buff* pskb;
    struct nlmsghdr* nlhnew;
    struct nldata_chipid* pstdata;
	int err;

        
    pskb = nlmsg_new(sizeof(struct nldata_chipid), GFP_KERNEL);
    if (pskb == NULL) {
        printk( KERN_WARNING "send_id_to_user \r\n");
        return -ENOMEM;
    }

    nlhnew = nlmsg_put(pskb, 0, 0, NTLK_CHIPID, sizeof(pstdata), 0);
    if (nlhnew == NULL) {
        printk( KERN_WARNING "send_id_to_user \r\n");
        return -1;
    }
	
    pstdata = nlmsg_data(nlhnew);
	memset(pstdata, 0x0, sizeof(pstdata));
    pstdata->chipid = id;
    pstdata->ret = ret;
    nlmsg_end(pskb, nlhnew);
    
    err = netlink_unicast(ntsk, pskb, pid, MSG_DONTWAIT);
    if (err < 0) {
        printk( KERN_WARNING "send_id_to_user error:%d \r\n", err);
        return err;
    }
    return 0;
}

static void netlink_msg_rcv(struct sk_buff *skb)
{
    struct nlmsghdr *nlh;
    int type, i, errnum = 0; 

    nlh = nlmsg_hdr(skb);

    if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len) {
        printk( KERN_WARNING "netlink_msg_rcv error len \r\n");
        return;
    }

    type = nlh->nlmsg_type;
    if (type > NTLK_MAX) {
        printk( KERN_WARNING "netlink_msg_rcv rcv error type:%d\r\n", type);
        return;
    }
    switch(type) {
        /*type自定義，根據用戶態傳下來的type做相應處理，然後條用api將信息傳回用戶態 例如傳id*/
        char id；
        send_id_to_user(nlsk, pid, id, ret);
    }

    if (errnum != 0 ) {
        printk( KERN_WARNING "netlink_msg_rcv return :%d \r\n", errnum);
        return;
    }
    return;
}


static int __init netlink_init(void)
{
    printk("netlink_kernel init\n");
    struct netlink_kernel_cfg cfg = {
       .input  = netlink_msg_rcv,
    };
    nlsk = netlink_kernel_create(&init_net, 23, &cfg);
    if (!nlsk) {
        
        printk( "netlink_kernel_create return null\r\n");
        
        return -ENOMEM;
    }
        
    return 0;
}


static void __exit netlink_exit(void)
{
	 netlink_kernel_release(nlsk);
}


module_init(netlink_init);
module_exit(netlink_exit);
MODULE_LICENSE("GPL");

用戶態代碼：

#include <sys/socket.h>
#include <sys/time.h>
#include <linux/netlink.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>

struct id_userdata{
    struct nlmsghdr hdr;
    unsigned char id;
    unsigned int ret;
};

int user_netlink_init(void)
{
    int ifd;
    int iOpt = 1;
    struct sockaddr_nl addr;    
  
    ifd = socket(PF_NETLINK, SOCK_DGRAM, 23);
    if(ifd < 0) {
        printf("%s\n", strerror(errno));
         return -1;  
    }   

    setsockopt(ifd, SOL_SOCKET, SO_REUSEADDR, &iOpt, sizeof(iOpt));

    addr.nl_family = PF_NETLINK;  
    addr.nl_pad    = 0;  
    addr.nl_pid    = getpid();  
    addr.nl_groups = 0;  
    if(bind(ifd, (struct sockaddr*)&addr, sizeof(addr)) < 0){
        printf("bind < 0\n");
        close(ifd);
        return -2;  
    }  
    //set_nonblocking(ifd);
    return ifd;
}

int user_netlink_recv_data(int socketfd, void *data, int send_len, int recv_len)
{
    int ret;  
    int recvcount = 0;
    
    struct sockaddr_nl st_peer_addr;
    st_peer_addr.nl_family = AF_NETLINK;  
    st_peer_addr.nl_pad = 0;       /*always set to zero*/  
    st_peer_addr.nl_pid = 0;       /*kernel's pid is zero*/  
    st_peer_addr.nl_groups = 0;    /*multicast groups mask, if unicast set to zero*/  

    /*recv message */
    ret = sendto(socketfd, data, send_len, 0, (struct sockaddr*)&st_peer_addr, sizeof(st_peer_addr));  
    if(ret < 0) { 
        return -1;
    }
    struct timeval tv_out;
    tv_out.tv_sec = 3;
    tv_out.tv_usec = 0;
    setsockopt(socketfd,SOL_SOCKET,SO_RCVTIMEO,&tv_out, sizeof(tv_out));
    ret = recvfrom(socketfd, data, recv_len, 0 , NULL, NULL);
    return ret;
}



int id_get(unsigned char* chipid)
{
    int ret;
    int iskfd = 0;
    struct id_userdata stprdata;
    iskfd = user_netlink_init();
    if (iskfd <= 0) {
        return iskfd;
    }
    memset(&stprdata, 0x00, sizeof(stprdata));

    stprdata.hdr.nlmsg_len   = sizeof(stprdata);  //NLMSG_LENGTH(sizeof(netlink_notify_s))
    stprdata.hdr.nlmsg_flags = 0;                         
    stprdata.hdr.nlmsg_type  = NTLK_ID;       /*自定義的type*/                 
    stprdata.hdr.nlmsg_pid   = getpid();      /* set sender  PID*/  


    ret = user_netlink_recv_data(iskfd, &stprdata, sizeof(stprdata), sizeof(stprdata));
    if (ret > 0) {
        if (stprdata.ret != 0) {
            close(iskfd);
            return -3;
        }
        else{
            *chipid = stprdata.id;
        }	
    }
    else{
        close(iskfd);
        return -4;
    }
    close(iskfd);
    return 0;
}

注：23爲自定義協議類型，netlink.h頭文件中定義了MAX_LINKS 32，最打不能超過32內核態與用戶態代碼協議類型須一致，並且內核態代碼必須保證先加載成功，否則自定義的協議類型在用戶態創建socket會返回失敗；