netlink从内核往用户态发消息的一个例子

    参考了netlink学习的一篇博文，讲得简单明了，地址如下：netlink socket编程之why & how。但是不大清楚此博文基于的内核版本是什么，和我现在实际项目中的内核版本函数参数有出入，以下的例子是在linux 3.4rt版本上写的netlink通信程序，从具体项目中摘录，有些函数是平台特有的。

    内核向用户态发送消息，传送一组数据，用户态接收到数据。
   
    内核态程序：

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <net/sock.h>
#include <linux/netlink.h>

//linux 3.4rt

#define SSK_NETLINK_MONITOR (25)


static struct sock *g_monitor_nl_sk;


/*
通过在应用层SSK中用ret = HAL_sysSetMonitorFd(getpid())调用将ssk的进程id传送到kernel中。
VOS_RET_E HAL_sysSetMonitorFd(UINT32 pid)
{
    return hal_sysBoardIoctl(BOARD_IOCTL_SET_MONITOR_FD, 0, "", 0, pid, "");
}
//kernel ioctl接收sskpid
static int board_ioctl( struct inode *inode, struct file *flip,
                       unsigned int command, unsigned long arg )
{
    case BOARD_IOCTL_SET_MONITOR_FD:
    if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0) {

       g_monitor_nl_pid = ctrlParms.offset;
       printk(KERN_INFO "monitor task is initialized pid= %d \n",g_monitor_nl_pid);
    }
    break;
}*/
static int g_monitor_nl_pid = 0 ;

typedef enum
{
    HAL_BTN_NAME_RESET,
    HAL_BTN_NAME_WLAN,
    HAL_BTN_NAME_WPS,
    HAL_BTN_NAME_TURN,
    HAL_BTN_NAME_PWROFFALLLED, /* Spark.Lei added on 2013-10-14 */
    HAL_BTN_NAME_END
} HAL_BTN_NAME_E;

typedef struct
{
    HAL_BTN_NAME_E name;
    unsigned int duration;
} HAL_BTN_MSG_BODY_T;



/*functionto receive message from usersapce
 * Currently we dont expect any messages fromm userspace
 */
void kerSysRecvFrmMonitorTask(struct sk_buff *skb)
{

   /*process the message here*/
   printk(KERN_WARNING "unexpected skb received at %s \n",__FUNCTION__);
   kfree_skb(skb);
   return;
}

void kerSysInitMonitorSocket( void )
{
   g_monitor_nl_sk = netlink_kernel_create(&init_net, NETLINK_BRCM_MONITOR, 0, kerSysRecvFrmMonitorTask, NULL, THIS_MODULE);

   if(!g_monitor_nl_sk)
   {
      printk(KERN_ERR "Failed to create a netlink socket for monitor\n");
      return;
   }

}

void kerSysSendtoMonitorTask(int msgType, char *msgData, int msgDataLen)
{

   struct sk_buff *skb = NULL;
   struct nlmsghdr *nl_msgHdr = NULL;
   unsigned int payloadLen =sizeof(struct nlmsghdr);

   if(!g_monitor_nl_pid)
   {
      //printk(KERN_INFO "message received before monitor task is initialized type %d  %s \n",msgType,__FUNCTION__);
      return;
   }

   if(msgData && (msgDataLen > MAX_PAYLOAD_LEN))
   {
      printk(KERN_ERR "invalid message len in %s",__FUNCTION__);
      return;
   }

   payloadLen += msgDataLen;
   payloadLen = NLMSG_SPACE(payloadLen);

   /*Alloc skb ,this check helps to call the fucntion from interrupt context */

   if(in_atomic())
   {
      skb = alloc_skb(payloadLen, GFP_ATOMIC);
   }
   else
   {
      skb = alloc_skb(payloadLen, GFP_KERNEL);
   }

   if(!skb)
   {
      printk(KERN_ERR "failed to alloc skb in %s",__FUNCTION__);
      return;
   }

   nl_msgHdr = (struct nlmsghdr *)skb->data;
   nl_msgHdr->nlmsg_type = msgType;
   nl_msgHdr->nlmsg_pid=0;/*from kernel */
   nl_msgHdr->nlmsg_len = payloadLen;
   nl_msgHdr->nlmsg_flags =0;

   if(msgData)
   {
      memcpy(NLMSG_DATA(nl_msgHdr),msgData,msgDataLen);
   }

   NETLINK_CB(skb).pid = 0; /*from kernel */

   skb->len = payloadLen;

   netlink_unicast(g_monitor_nl_sk, skb, g_monitor_nl_pid, MSG_DONTWAIT);
   return;
}

void kerSysCleanupMonitorSocket(void)
{
   g_monitor_nl_pid = 0 ;
   sock_release(g_monitor_nl_sk->sk_socket);
}


main()
{
    HAL_BTN_MSG_BODY_T btn_msg;

    btn_msg.name = HAL_BTN_NAME_WLAN;
    btn_msg.duration = 0;

    kerSysInitMonitorSocket();
    kerSysSendtoMonitorTask(MSG_NETLINK_BTN_DOWN, (char *)&btn_msg, sizeof(btn_msg));

    kerSysCleanupMonitorSocket();

}

    用户态接收程序：

#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <string.h>
#include <asm/types.h>
#include <linux/netlink.h>
#include <linux/socket.h>


#define SSK_NETLINK_MONITOR (25)

static int sg_kernelMonitorFd = UTIL_INVALID_FD;


VOS_RET_E HAL_sysSetMonitorFd(UINT32 pid)
{
    return hal_sysBoardIoctl(BOARD_IOCTL_SET_MONITOR_FD, 0, "", 0, pid, "");
}


/* opens a netlink socket and intiliaze it to recieve messages from
 * kernel for protocol SSK_NETLINK_MONITOR
 */
static VOS_RET_E ssk_initKernelMonitorFd(void)
{
    VOS_RET_E ret = VOS_RET_SUCCESS;
    struct sockaddr_nl addr;

    sg_kernelMonitorFd = socket(AF_NETLINK, SOCK_RAW, SSK_NETLINK_MONITOR);
    if (sg_kernelMonitorFd < 0)
    {
        vosLog_error("Could not open netlink socket for kernel monitor");
        return VOS_RET_INTERNAL_ERROR;
    }
    else
    {
        vosLog_debug("sg_kernelMonitorFd=%d", sg_kernelMonitorFd);
    }

    addr.nl_family = AF_NETLINK;
    addr.nl_pid = getpid();
    addr.nl_groups = 0;

    if (bind(sg_kernelMonitorFd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    {
        vosLog_error("Could not bind netlink socket for kernel monitor");
        close(sg_kernelMonitorFd);
        sg_kernelMonitorFd = UTIL_INVALID_FD;
        return VOS_RET_INTERNAL_ERROR;
    }

    /*send the pid of ssk to kernel,so that it can send events */
    ret = HAL_sysSetMonitorFd(getpid());
    if (ret == VOS_RET_SUCCESS)
    {
        vosLog_debug("registered fd %d with kernel monitor", sg_kernelMonitorFd);
    }
    else
    {
        vosLog_error("failed to register fd %d with kernel monitor, ret=%d", sg_kernelMonitorFd, ret);
        close(sg_kernelMonitorFd);
        sg_kernelMonitorFd = UTIL_INVALID_FD;
    }

    return ret;
}




/** Receive and process messages sent from kernel on netlink sockets
  *
  */
static void ssk_processKernelMonitor(void)
{
    int recvLen = 0;
    char buf[4096] = {0};
    struct iovec iov = {buf, sizeof(buf)};
    struct sockaddr_nl nl_srcAddr;
    struct msghdr msg;
    struct nlmsghdr *nl_msgHdr = NULL;
    VOS_RET_E ret = VOS_RET_SUCCESS;
    UBOOL8 isLinkUp = 0;

    memset(&msg, 0, sizeof(struct msghdr));
    msg.msg_name = (void *)&nl_srcAddr;
    msg.msg_namelen = sizeof(nl_srcAddr);
    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;

    vosLog_debug("Enter\n");

    recvLen = recvmsg(sg_kernelMonitorFd, &msg, 0);
    if (recvLen < 0)
    {
        if (errno == EWOULDBLOCK || errno == EAGAIN)
        {
            return;
        }

        /* Anything else is an error */
        vosLog_error("read_netlink: Error recvmsg: %d\n", recvLen);
        perror("read_netlink: Error: ");
        return;
    }

    if (recvLen == 0)
    {
        vosLog_error("read_netlink: EOF\n");
    }

    /* There can be  more than one message per recvmsg */
    for (nl_msgHdr = (struct nlmsghdr *)buf;
            NLMSG_OK(nl_msgHdr, (unsigned int)recvLen);
            nl_msgHdr = NLMSG_NEXT(nl_msgHdr, recvLen))
    {
        /* Finish reading */
        if (nl_msgHdr->nlmsg_type == NLMSG_DONE)
        {
            return;
        }

        /* Message is some kind of error */
        if (nl_msgHdr->nlmsg_type == NLMSG_ERROR)
        {
            vosLog_error("read_netlink: Message is an error \n");
            return; // Error
        }

        /*Currently we expect messages only from kernel, make sure
         * the message is from kernel
         */
        if (nl_msgHdr->nlmsg_pid != 0)
        {
            vosLog_error("netlink message source(%d)is not kernel", nl_msgHdr->nlmsg_pid);
            return;
        }

        vosLog_debug("ssk receive kernel msg type:0x%x",nl_msgHdr->nlmsg_type);

        switch (nl_msgHdr->nlmsg_type)
        {
            case MSG_NETLINK_ADD_RT_NOTIFY:
            {
                vosLog_error("received MSG_NETLINK_ADD_RT_NOTIFY");
                //vosLog_debug("received MSG_NETLINK_ADD_RT_NOTIFY");
                unsigned int ipaddr = *(unsigned int *)(nl_msgHdr + 1);
                printf("\nip addr int = %x",ipaddr);

                UTIL_DO_SYSTEM_ACTION("route add %d.%d.%d.%d dev br1", ((unsigned char*)&ipaddr)[0],((unsigned char*)&ipaddr)[1],((unsigned char*)&ipaddr)[2],((unsigned char*)&ipaddr)[3]);
                break;
            }

            default:
                vosLog_error(" Unknown netlink nlmsg_type %d\n",
                         nl_msgHdr->nlmsg_type);
                break;
        }
    }

    vosLog_debug("Exit\n");
    return;
}


void main(void)
{
    ssk_initKernelMonitorFd();
    while(1)
    {
        if (FD_ISSET(sg_kernelMonitorFd, &readFds))
        {
            ssk_processKernelMonitor();
        }
    }
    if (sg_kernelMonitorFd != UTIL_INVALID_FD)
    {
        close(sg_kernelMonitorFd);
    }
}