linux下的netlink编程

最新推荐文章于 2024-07-29 11:07:06 发布
转载 最新推荐文章于 2024-07-29 11:07:06 发布 · 1.3k 阅读 · 3
文章标签：

#linux #buffer #socket #module #thread #null

本文详细介绍Linux内核中Netlink套接字的使用方法，包括单播和多播通信原理及应用实例，帮助读者理解内核与用户空间进程间的数据交换机制。

在 Linux 2.4 版以后版本的内核中，几乎全部的中断过程与用户态进程的通信都是使用 netlink 套接字实现的，同时还使用 netlink 实现了 ip queue 工具，但 ip queue 的使用有其局限性，不能自由地用于各种中断过程。内核的帮助文档和其他一些 Linux 相关文章都没有对 netlink 套接字在中断过程和用户空间通信的应用上作详细的说明，使得很多用户对此只有一个模糊的概念。

Unicast Communication between Kernel and Application
在下面的例子中,一个用户空间进程发送一个netlink消息给内核模块,内核模块应答一个消息给发送进程,这里是用户空间的代码:

#include  < sys / socket.h >
#include  < linux / netlink.h >
#define  MAX_PAYLOAD 1024  /* maximum payload size*/
struct  sockaddr_nl src_addr, dest_addr;
 struct  msghdr msg;
 struct  nlmsghdr  * nlh  =  NULL;
 struct  iovec iov;
 int  sock_fd;
 void  main()  {
 sock_fd  =  socket(PF_NETLINK, SOCK_RAW,NETLINK_TEST);
 memset( & src_addr,  0 ,  sizeof (src_addr));
 src__addr.nl_family  =  AF_NETLINK;      
 src_addr.nl_pid  =  getpid();   /*  self pid  */
 src_addr.nl_groups  =   0 ;   /*  not in mcast groups  */
 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(MAX_PAYLOAD));
  /*  Fill the netlink message header  */
 nlh -> nlmsg_len  =  NLMSG_SPACE(MAX_PAYLOAD);
 nlh -> nlmsg_pid  =  getpid();   /*  self pid  */
 nlh -> nlmsg_flags  =   0 ;
  /*  Fill in the netlink message payload  */
 strcpy(NLMSG_DATA(nlh),  " Hello you! " );
 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 ;
 sendmsg(fd,  & msg,  0 );
  /*  Read message from kernel  */
 memset(nlh,  0 , NLMSG_SPACE(MAX_PAYLOAD));
 recvmsg(fd,  & msg,  0 );
 printf( "  Received message payload: %s " , 
        NLMSG_DATA(nlh));
    
  /*  Close Netlink Socket  */
 close(sock_fd);
}     

这里是内核代码:

struct  sock  * nl_sk  =  NULL;
 void  nl_data_ready ( struct  sock  * sk,  int  len)
 {
  wake_up_interruptible(sk -> sleep);
}
void  netlink_test()  {
  struct  sk_buff  * skb  =  NULL;
  struct  nlmsghdr  * nlh  =  NULL;
  int  err;
 u32 pid;     
 nl_sk  =  netlink_kernel_create(NETLINK_TEST, 
                                   nl_data_ready);
  /*  wait for message coming down from user-space  */
 skb  =  skb_recv_datagram(nl_sk,  0 ,  0 ,  & err);
 nlh  =  ( struct  nlmsghdr  * )skb -> data;
 printk( " %s: received netlink message payload:%s " , 
        __FUNCTION__, NLMSG_DATA(nlh));
 pid  =  nlh -> nlmsg_pid;  /* pid of sending process  */
 NETLINK_CB(skb).groups  =   0 ;  /*  not in mcast group  */
 NETLINK_CB(skb).pid  =   0 ;       /*  from kernel  */
 NETLINK_CB(skb).dst_pid  =  pid;
 NETLINK_CB(skb).dst_groups  =   0 ;   /*  unicast  */
 netlink_unicast(nl_sk, skb, pid, MSG_DONTWAIT);
 sock_release(nl_sk -> socket);
}  

在内核模块被加载到内核,当我们运行用户程序,我们将看到下面的信息:

Received message payload: Hello you!

然后用dmesg我们可以看到内核输出:

netlink_test: received netlink message payload:
Hello you!

Multicast Communication between Kernel and Applications
这个例子中,两个应用程序在监听同一个netlink广播组.内核模块发送一个netlink消息给这个广播组,所用的应用程序都收到它,如下是用户程序代码:

#include  < sys / socket.h >
#include  < linux / netlink.h >
#define  MAX_PAYLOAD 1024  /* maximum payload size*/
struct  sockaddr_nl src_addr, dest_addr;
 struct  nlmsghdr  * nlh  =  NULL;
 struct  iovec iov;
 int  sock_fd;
 void  main()  {
 sock_fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_TEST);
 memset( & src_addr,  0 ,  sizeof (local_addr));
 src_addr.nl_family  =  AF_NETLINK;       
 src_addr.nl_pid  =  getpid();   /*  self pid  */
  /*  interested in group 1<<0  */   
 src_addr.nl_groups  =   1 ;
 bind(sock_fd, ( struct  sockaddr * ) & src_addr, 
       sizeof (src_addr));
 memset( & dest_addr,  0 ,  sizeof (dest_addr)); 
 nlh  =  ( struct  nlmsghdr  * )malloc(
                          NLMSG_SPACE(MAX_PAYLOAD));
 memset(nlh,  0 , NLMSG_SPACE(MAX_PAYLOAD));      
    
 iov.iov_base  =  ( void   * )nlh;
 iov.iov_len  =  NLMSG_SPACE(MAX_PAYLOAD);
 msg.msg_name  =  ( void   * ) & dest_addr;
 msg.msg_namelen  =   sizeof (dest_addr);
 msg.msg_iov  =   & iov;
 msg.msg_iovlen  =   1 ;
 printf( " Waiting for message from kernel " );
  /*  Read message from kernel  */
 recvmsg(fd,  & msg,  0 );
 printf( "  Received message payload: %s " , 
        NLMSG_DATA(nlh));
 close(sock_fd);
}   

 内核代码:

#define  MAX_PAYLOAD 1024 
struct  sock  * nl_sk  =  NULL;
 void  netlink_test()  {
 sturct sk_buff  * skb  =  NULL;
  struct  nlmsghdr  * nlh;
  int  err;
 nl_sk  =  netlink_kernel_create(NETLINK_TEST, 
                               nl_data_ready);
 skb = alloc_skb(NLMSG_SPACE(MAX_PAYLOAD),GFP_KERNEL);
 nlh  =  ( struct  nlmsghdr  * )skb -> data;
 nlh -> nlmsg_len  =  NLMSG_SPACE(MAX_PAYLOAD);
 nlh -> nlmsg_pid  =   0 ;   /*  from kernel  */
 nlh -> nlmsg_flags  =   0 ;
 strcpy(NLMSG_DATA(nlh),  " Greeting from kernel! " );
  /*  sender is in group 1<<0  */
 NETLINK_CB(skb).groups  =   1 ;
 NETLINK_CB(skb).pid  =   0 ;   /*  from kernel  */
 NETLINK_CB(skb).dst_pid  =   0 ;   /*  multicast  */
  /*  to mcast group 1<<0  */
 NETLINK_CB(skb).dst_groups  =   1 ;
  /* multicast the message to all listening processes */
 netlink_broadcast(nl_sk, skb,  0 ,  1 , GFP_KERNEL);
 sock_release(nl_sk -> socket);
}   

我们运行用户程序:

 
./nl_recv &
Waiting for message from kernel
./nl_recv &
Waiting for message from kernel
 
然后我们加载内核模块到内核空间,会看到如下信息::

Received message payload: Greeting from kernel!
Received message payload: Greeting from kernel!

以下是一个简单的测试内核事件的应用程序：

#define  MAX_PAYLOAD        1024
struct  sockaddr_nl    src_addr, dest_addr;
 char   * KernelMsg  =  NULL;
 struct  iovec iov;
 int  sock_fd;
 struct  msghdr msg;
 int  msglen;

 #define  DEVICE_ADD            "add"
#define  DEVICE_REMOVE        "remove"
#define  DEVICE_NAME            "event0"
#define  DEVICE_NAMELEN    6
void   *  DeviceManagement( void   * arg)
 {
    sock_fd  =  socket(PF_NETLINK, SOCK_RAW, NETLINK_KOBJECT_UEVENT);
     int  msgle;
    
    memset( & src_addr,  0 ,  sizeof (src_addr));
    src_addr.nl_family  =  AF_NETLINK;
    src_addr.nl_pid  =  pthread_self()  <<   16   |  getpid();
    src_addr.nl_groups  =   1 ;
    bind(sock_fd, ( struct  sockaddr  * ) & src_addr,  sizeof (src_addr));
    
    memset( & dest_addr,  0 ,  sizeof (dest_addr));
    KernelMsg  =  ( struct  nlmsghdr  * )malloc(MAX_PAYLOAD);
    memset(KernelMsg,  0 ,     MAX_PAYLOAD);
    
    iov.iov_base  =  ( void   * )KernelMsg;
    iov.iov_len  =  MAX_PAYLOAD;
    msg.msg_name  =  ( void   * ) & dest_addr;
    msg.msg_namelen  =   sizeof (dest_addr);
    msg.msg_iov  =   & iov;
    msg.msg_iovlen  =   1 ;
    
     while ( 1 )  {
         // printf("Waiting for message from kernel ");
        recvmsg(sock_fd,  & msg,  0 );
         // printf("Receved message payload: %s ", KernelMsg);
        msglen  =  strlen(KernelMsg);
         // printf("Device: %s ", KernelMsg+msglen-DEVICE_NAMELEN);
         if ( ! strncmp(DEVICE_NAME, KernelMsg + msglen - DEVICE_NAMELEN, DEVICE_NAMELEN))  {
             if ( ! strncmp(DEVICE_ADD, KernelMsg, strlen(DEVICE_ADD))) 
             {
                printf( " Add event0 device " );
                USBKeyboardReady  =   1 ;
            }
             else   if ( ! strncmp(DEVICE_REMOVE, KernelMsg, strlen(DEVICE_REMOVE)))  {
                printf( " Remove event0 device " );
                USBKeyboardReady  =   0 ;
            }
        }
    }
    close(sock_fd);
    
}  

示例：一个用户进程发送数据到内核，然后通过内核发送给另一个用户进程。

内核进程：netlink-exam-kern.c

// kernel module: netlink-exam-kern.c
#ifndef __KERNEL__
 #define  __KERNEL__
#endif

#ifndef MODULE
 #define  MODULE
#endif

#include  < linux / config.h >
#include  < linux / module.h >
#include  < linux / netlink.h >
#include  < linux / sched.h >
#include  < net / sock.h >
#include  < linux / proc_fs.h >

#define  BUF_SIZE 16384
#define  NL 30

static   struct  sock  * netlink_exam_sock;
 static  unsigned  char  buffer[BUF_SIZE];
 static  unsigned  int  buffer_tail  =   0 ;
 static   int  exit_flag  =   0 ;

 static  DECLARE_COMPLETION(exit_completion);

 static   void  recv_handler( struct  sock  *  sk,  int  length)
 {
        wake_up(sk -> sk_sleep);
}

static   int  process_message_thread( void   *  data)
 {
         struct  sk_buff  *  skb  =  NULL;
         struct  nlmsghdr  *  nlhdr  =  NULL;
         int  len;
        DEFINE_WAIT(wait);

        daemonize( " mynetlink " );

         while  (exit_flag  ==   0 )  {
                prepare_to_wait(netlink_exam_sock -> sk_sleep,  & wait, TASK_INTERRUPTIBLE);
                schedule();
                finish_wait(netlink_exam_sock -> sk_sleep,  & wait);

                 while  ((skb  =  skb_dequeue( & netlink_exam_sock -> sk_receive_queue))
                          !=  NULL)  {
                        nlhdr  =  ( struct  nlmsghdr  * )skb -> data;
                         if  (nlhdr -> nlmsg_len  <   sizeof ( struct  nlmsghdr))  {
                                printk( " Corrupt netlink message. " );
                                 continue ;
                        }
                        len  =  nlhdr -> nlmsg_len  -  NLMSG_LENGTH( 0 );
                         if  (len  +  buffer_tail  >  BUF_SIZE)  {
                                printk( " netlink buffer is full. " );
                        }
                         else   {
                                memcpy(buffer  +  buffer_tail, NLMSG_DATA(nlhdr), len);
                                buffer_tail  +=  len;
                        }
                        nlhdr -> nlmsg_pid  =   0 ;
                        nlhdr -> nlmsg_flags  =   0 ;
                        NETLINK_CB(skb).pid  =   0 ;
                        NETLINK_CB(skb).dst_pid  =   0 ;
                        NETLINK_CB(skb).dst_group  =   1 ;
                        netlink_broadcast(netlink_exam_sock, skb,  0 ,  1 , GFP_KERNEL);
                }
        }
        complete( & exit_completion);
         return   0 ;
}

static   int  netlink_exam_readproc( char   * page,  char   ** start, off_t off,
                           int  count,  int   * eof,  void   * data)
 {
         int  len;

         if  (off  >=  buffer_tail)  {
                 *  eof  =   1 ;
                 return   0 ;
        }
         else   {
                len  =  count;
                 if  (count  >  PAGE_SIZE)  {
                        len  =  PAGE_SIZE;
                }
                 if  (len  >  buffer_tail  -  off)  {
                        len  =  buffer_tail  -  off;
                }
                memcpy(page, buffer  +  off, len);
                 * start  =  page;
                 return  len;
        }

}

static   int  __init netlink_exam_init( void )
 {
        netlink_exam_sock  =  netlink_kernel_create(NL,  0 , recv_handler, THIS_MODULE);
         if  ( ! netlink_exam_sock)  {
                printk( " Fail to create netlink socket. " );
                 return   1 ;
        }
        kernel_thread(process_message_thread, NULL, CLONE_KERNEL);
        create_proc_read_entry( " netlink_exam_buffer " ,  0444 , NULL, netlink_exam_readproc,  0 );
         return   0 ;
}

static   void  __exit netlink_exam_exit( void )
 {
        exit_flag  =   1 ;
        wake_up(netlink_exam_sock -> sk_sleep);
        wait_for_completion( & exit_completion);
        sock_release(netlink_exam_sock -> sk_socket);
}

module_init(netlink_exam_init);
module_exit(netlink_exam_exit);
MODULE_LICENSE( " GPL " );

编译成模块：

ifneq ($(KERNELRELEASE),)
debug - objs : =  netlink - exam - kern.o
obj - m : =  netlink - exam - kern1.o
CFLAGS  +=   - w  - Wimplicit - function - declaration
 else
PWD : =  $(shell pwd)
KVER  ?=  $(shell uname  - r)
KDIR : =   / lib / modules / $(KVER) / build
all:
        $(MAKE)  - C $(KDIR) M = $(PWD)
clean:
        rm  - rf . * .cmd  * .o  * .mod.c  * .ko .tmp_versions
endif

用户发送进程：netlink-exam-user-send.c

// application sender: netlink-exam-user-send.c
#include  < stdio.h >
#include  < stdlib.h >
#include  < unistd.h >
#include  < string .h >
#include  < sys / types.h >
#include  < sys / socket.h >
#include  < linux / netlink.h >

#define  MAX_MSGSIZE 1024


int  main( int  argc,  char   *  argv[])
 {
        FILE  *  fp;
         struct  sockaddr_nl saddr, daddr;
         struct  nlmsghdr  * nlhdr  =  NULL;
         struct  msghdr msg;
         struct  iovec iov;
         int  sd;
         char  text_line[MAX_MSGSIZE];
         int  ret  =   - 1 ;

         if  (argc  <   2 )  {
                printf( " Usage: %s atextfilename " , argv[ 0 ]);
                exit( 1 );
        }

         if  ((fp  =  fopen(argv[ 1 ],  " r " ))  ==  NULL)  {
                printf( " File %s dosen't exist. " );
                exit( 1 );
        }

        sd  =  socket(AF_NETLINK, SOCK_RAW,  30 );
        memset( & saddr,  0 ,  sizeof (saddr));
        memset( & daddr,  0 ,  sizeof (daddr));

        saddr.nl_family  =  AF_NETLINK;
        saddr.nl_pid  =  getpid();
        saddr.nl_groups  =   0 ;
        bind(sd, ( struct  sockaddr * ) & saddr,  sizeof (saddr));

        daddr.nl_family  =  AF_NETLINK;
        daddr.nl_pid  =   0 ;
        daddr.nl_groups  =   0 ;

        nlhdr  =  ( struct  nlmsghdr  * )malloc(NLMSG_SPACE(MAX_MSGSIZE));

         while  (fgets(text_line, MAX_MSGSIZE, fp))  {
                memcpy(NLMSG_DATA(nlhdr), text_line, strlen(text_line));
                memset( & msg,  0  , sizeof ( struct  msghdr));

                nlhdr -> nlmsg_len  =  NLMSG_LENGTH(strlen(text_line));
                nlhdr -> nlmsg_pid  =  getpid();   /*  self pid  */
                nlhdr -> nlmsg_flags  =   0 ;

                iov.iov_base  =  ( void   * )nlhdr;
                iov.iov_len  =  nlhdr -> nlmsg_len;
                msg.msg_name  =  ( void   * ) & daddr;
                msg.msg_namelen  =   sizeof (daddr);
                msg.msg_iov  =   & iov;
                msg.msg_iovlen  =   1 ;
                ret  =  sendmsg(sd,  & msg,  0 );
                 if  (ret  ==   - 1 )  {
                        perror( " sendmsg error: " );
                }
        }

        close(sd);
         return   0 ;
}

用户接收进程：netlink-exam-user-recv.c

// application sender: netlink-exam-user-send.c
#include  < stdio.h >
#include  < stdlib.h >
#include  < unistd.h >
#include  < string .h >
#include  < sys / types.h >
#include  < sys / socket.h >
#include  < linux / netlink.h >

#define  MAX_MSGSIZE 1024


int  main( int  argc,  char   *  argv[])
 {
        FILE  *  fp;
         struct  sockaddr_nl saddr, daddr;
         struct  nlmsghdr  * nlhdr  =  NULL;
         struct  msghdr msg;
         struct  iovec iov;
         int  sd;
         char  text_line[MAX_MSGSIZE];
         int  ret  =   - 1 ;

         if  (argc  <   2 )  {
                printf( " Usage: %s atextfilename " , argv[ 0 ]);
                exit( 1 );
        }

         if  ((fp  =  fopen(argv[ 1 ],  " r " ))  ==  NULL)  {
                printf( " File %s dosen't exist. " );
                exit( 1 );
        }

        sd  =  socket(AF_NETLINK, SOCK_RAW,  30 );
        memset( & saddr,  0 ,  sizeof (saddr));
        memset( & daddr,  0 ,  sizeof (daddr));

        saddr.nl_family  =  AF_NETLINK;
        saddr.nl_pid  =  getpid();
        saddr.nl_groups  =   0 ;
        bind(sd, ( struct  sockaddr * ) & saddr,  sizeof (saddr));

        daddr.nl_family  =  AF_NETLINK;
        daddr.nl_pid  =   0 ;
        daddr.nl_groups  =   0 ;

        nlhdr  =  ( struct  nlmsghdr  * )malloc(NLMSG_SPACE(MAX_MSGSIZE));

         while  (fgets(text_line, MAX_MSGSIZE, fp))  {
                memcpy(NLMSG_DATA(nlhdr), text_line, strlen(text_line));
                memset( & msg,  0  , sizeof ( struct  msghdr));

                nlhdr -> nlmsg_len  =  NLMSG_LENGTH(strlen(text_line));
                nlhdr -> nlmsg_pid  =  getpid();   /*  self pid  */
                nlhdr -> nlmsg_flags  =   0 ;

                iov.iov_base  =  ( void   * )nlhdr;
                iov.iov_len  =  nlhdr -> nlmsg_len;
                msg.msg_name  =  ( void   * ) & daddr;
                msg.msg_namelen  =   sizeof (daddr);
                msg.msg_iov  =   & iov;
                msg.msg_iovlen  =   1 ;
                ret  =  sendmsg(sd,  & msg,  0 );
                 if  (ret  ==   - 1 )  {
                        perror( " sendmsg error: " );
                }
        }

        close(sd);
         return   0 ;
}

from:http://blog.youkuaiyun.com/dipperkun/archive/2007/12/19/1953526.aspx

Linux内核通信的Netlink机制与编程
SVIPCODE的博客
10-06 616
Netlink机制提供了一种可靠的、高效的通信方式，用于实现内核与用户空间进程之间的数据交换。Netlink机制是Linux内核中用于进程间通信的一种机制，它提供了一种可靠的、高效的通信方式，用于内核与用户空间进程之间的数据交换。在本文中，我们将详细介绍Netlink机制的原理和编程方法，并给出相应的源代码示例。通过使用Netlink机制，我们可以实现内核与用户空间进程之间的高效通信。下面是一个简单的Netlink编程示例，演示了如何使用Netlink发送消息并接收回复。一、Netlink机制的原理。
Linux中的Netlink详解
ACMIII的博客
11-08 1134
下面是一个更详细的内核Netlink代码示例，包括内核模块的初始化和退出函数，Netlink套接字的创建和消息处理函数。该示例代码实现了一个简单的内核模块，通过Netlink与用户空间进行通信，将接收到的消息打印到内核日志中。在这个示例代码中，我们首先创建了一个Netlink套接字，并将其绑定到指定的地址上。然后，我们构造了一个Netlink消息，将用户空间的消息内容复制到消息缓冲区中，并通过。对于Netlink来说，地址由。以下是一个详细的用户空间代码示例，用于与上述内核模块中的Netlink进行通信。
Linux下netlink编程示例
heyustudent的专栏
06-25 1347
http://www.360doc.com/content/12/0112/10/1317564_178894692.shtml 在 Linux 2.4 版以后版本的内核中，几乎全部的中断过程与用户态进程的通信都是使用 netlink 套接字实现的，同时还使用 netlink 实现了 ip queue 工具，但 ip queue 的使用有其局限性，不能自由地用于各种中断过程。内核的帮助文档和
linux下wifi编程（基于netlink和nl80211.h）
热门推荐
Bloom and Grow
09-29 1万+
http://blog.youkuaiyun.com/ljy1988123/article/details/9263983 写用户空间程序时，现在官方推荐的唯一编程方式就是基于netlink的nl80211.h编程。        netlink是一种linux下的用户空间和内核空间通信的方式，传输的都是一个个的帧。用户空间程序通过生成预定义好的结构帧，与内核达到传递消息的目的。    
Linux内核netlink机制 - 用户空间和内核空间数据传输
最新发布
hinewcc的博客
07-29 4803
Linux内核netlink机制，数据传输介绍及代码实现。
精选资源
linux下使用netlink获取gateway的IP地址
04-23
总结，Netlink编程虽然对于网络编程初学者来说具有一定的挑战性，但它提供了直接访问内核网络信息的能力，使得获取网关IP地址等任务变得高效和灵活。理解Netlink的原理和操作，对于深入理解Linux网络编程和系统管理...
linux netlink详解
白日梦想家霍华特的博客
04-29 1025
netlink从用户态到内核态原理解析
linux内核编程之netlink
m0_53869923的博客
01-18 586
上一节说到proc文件系统，这是用户态和内核态通信的一种方法，本节将要说到另外一种通信的方法，该方法相比于其他的内核和用户通信有时在于： Netlink相对于其他的通信机制具有以下优点： 1.使用Netlink通过自定义一种新的协议并加入协议族即可通过socket API使用Netlink协议完成数据交换，而ioctl和proc文件系统均需要通过程序加入相应的设备或文件。 2.Netlink使用socket缓存队列，是一种异步通信机制，而ioctl是同步通信机制，如果传输的数据量较大，会影响系统性能。 3.
Unix/Linux编程：Netlink机制
OceanStar的博客
09-24 4048
什么是Netlink通信机制 Netlink是linux提供的用于内核和用户态进程之间的通信方式。 但是注意虽然Netlink主要用于用户空间和内核空间的通信，但是也能用于用户空间的两个进程通信。 只是进程间通信有其他很多方式，一般不用Netlink。除非需要用到Netlink的广播特性时。 NetLink机制是一种特殊的socket，它是Linux特有的，由于传送的消息是暂存在socket接收缓存中，并不为接受者立即处理，所以netlink是一种异步通信机制。系统调用和ioctl是同步通信机制 .
linux netlink 示例代码: 通过net link 进行 内核和用户空间的数据通讯
04-30
eunetlink.c -用户程序源码 eknetlink.c -内核程序源码 netlink提供了一种很好很强大的的用户与内核之间的通讯机制，本文通过静态的新增一个netlink协议类型，并使用这个新的netlink类型实现用户态和内核态的双向通讯，对linux的netlink通讯方式有了一个初步的认识。 说明：本文所含代码的运行环境为 android提供的 goldfish 模拟器平台， Linux 内核版本为 2.6.29
linux netlink 示例代码
03-24
eunetlink.c -用户程序源码 eknetlink.c -内核程序源码 netlink提供了一种很好很强大的的用户与内核之间的通讯机制，本文通过静态的新增一个netlink协议类型，并使用这个新的netlink类型实现用户态和内核态的双向通讯，对linux的netlink通讯方式有了一个初步的认识。 说明：本文所含代码的运行环境为 android提供的 goldfish 模拟器平台， Linux 内核版本为 2.6.29
netlink编程介绍
aabb3575007的专栏
01-07 1108
netlink 编程介绍 Linux从 2.2开始支持PF_NETLINK 域的通讯方式，这个方式主要的用途是在Linux的内核空间和用户空间进行通讯。目前在网络上面关于netlink编程的中文资料很少，为了促进对 netlink编程的理解我编写了这篇文章，由于我对netlink的了解不是很透彻，特别是对于内核部分不是很熟悉，所以文章中肯定有很多错误的地方还 请大家指正。文章分下面几个部分进行
linux netlink通信机制
anyifu6885的博客
01-20 327
一、什么是Netlink通信机制 　 Netlink套接字是用以实现用户进程与内核进程通信的一种特殊的进程间通信(IPC) ,也是网络应用程序与内核通信的最常用的接口。 Netlink 是一种特殊的 socket，它是 Linux 所特有的，类似于 BSD 中的AF_ROUTE 但又远比它的功能强大，目前在Linux 内核中 使用netlink 进行应用与内核通信的应...
netlink 编程
sinat_32343037的博客
11-09 427
本文出自 “陈立峰嵌入式之路” 博客，请务必保留此出处http://linuxkernel.blog.51cto.com/1308410/1341522 Linux 系统下内核与应用进行数据交换的各种方式，包括内核启动参数、模块参数与 sysfs、sysctl、系统调用、netlink、procfs、seq_file、debugfs 和 relayfs； 包括：路由 daemon（NE
linux netlink 用法,Linux下netlink编程示例
weixin_39551103的博客
05-13 590
在 Linux 2.4 版以后版本的内核中，几乎全部的中断过程与用户态进程的通信都是使用 netlink套接字实现的，同时还使用 netlink 实现了 ip queue 工具，但 ip queue的使用有其局限性，不能自由地用于各种中断过程。内核的帮助文档和其他一些 Linux 相关文章都没有对 netlink套接字在中断过程和用户空间通信的应用上作详细的说明，使得很多用户对此只有一个模糊的概念...
Linux netlink编程详解：内核与用户空间通信
"netlink编程介绍" 在Linux操作系统中，Netlink是一种用于内核与用户空间之间通信的重要机制。自Linux 2.2版本以来，Netlink被引入以支持PF_NETLINK域的通信方式，其设计目的是为了方便、高效地在用户空间应用程序...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值