Chinaunix首页 | 论坛 | 博客

菜鸟先飞

首页　| 　博文目录　| 　关于我

luoyan_xy

  • 博客访问： 378965
  • 博文数量： 73
  • 博客积分： 3574
  • 博客等级： 中校
  • 技术积分： 1503
  • 用 户 组： 普通用户
  • 注册时间： 2010-03-26 11:17
文章分类

全部博文（73）

文章存档

2012年（14）

2011年（15）

2010年（44）

我的朋友
最近访客
推荐博文
相关博文
Linux用户态与内核态的通信之netlink

分类： LINUX

2010-09-07 21:27:08

难道有心情打算自己写一下笔记，无奈浏览器接连卡死两次，两次写到内容也都没有保存成功，那自己就索性偷下懒，把别人的笔记粘贴过来，再加上些许自己的见解，如果自己还有见解的话。。。
这是一篇学习笔记，主要是对《Linux 系统内核空间与用户空间通信的实现与分析》中的源码imp2的分析。其中的源码，可以到以下URL下载：
http://www-128.ibm.com/developerworks/cn/linux/l-netlink/imp2.tar.gz

参考文档
《Linux 系统内核空间与用户空间通信的实现与分析》                陈鑫
http://www-128.ibm.com/developerworks/cn/linux/l-netlink/?ca=dwcn-newsletter-linux
《在 Linux 下用户空间与内核空间数据交换的方式》                杨燚
http://www-128.ibm.com/developerworks/cn/linux/l-kerns-usrs/

理论篇
        在 Linux 2.4 版以后版本的内核中，几乎全部的中断过程与用户态进程的通信都是使用 netlink 套接字实现的，例如iprote2网络管理工具，它与内核的交互就全部使用了netlink，著名的内核包过滤框架Netfilter在与用户空间的通读，也在最新版本中改变为netlink，无疑，它将是Linux用户态与内核态交流的主要方法之一。它的通信依据是一个对应于进程的标识，一般定为该进程的 ID。当通信的一端处于中断过程时，该标识为 0。当使用 netlink 套接字进行通信，通信的双方都是用户态进程，则使用方法类似于消息队列。但通信双方有一端是中断过程，使用方法则不同。netlink 套接字的最大特点是对中断过程的支持，它在内核空间接收用户空间数据时不再需要用户自行启动一个内核线程，而是通过另一个软中断调用用户事先指定的接收函数。工作原理如图：



如图所示，这里使用了软中断而不是内核线程来接收数据，这样就可以保证数据接收的实时性。
当 netlink 套接字用于内核空间与用户空间的通信时，在用户空间的创建方法和一般套接字使用类似，但内核空间的创建方法则不同，下图是 netlink 套接字实现此类通信时创建的过程：


以下举一个 netlink 套接字的应用示例。示例实现了从 netfilter 的 NF_IP_PRE_ROUTING 点截获的 ICMP 数据报，在将数据报的相关信息传递到一个用户态进程，由用户态进程将信息打印在终端上。

用户空间
用户空间中关于netlink的使用应该是最容易理解的吧，其在与内核通信的过程中所扮演的角色与传统意义上的socket通信中所扮演的角色大致相同。
流程基本如下:
1)创建socket套接口
2)完成地址的绑定bind，这里有些不同，传统的socket通信中大多在服务器端进行绑定，绑定到特定的端口上，而在这里则是进行地址绑定，将socket套接口与本进程的pid完成绑定
3)通过sendto()或者sendmsg()函数发送消息
4)通过recvfrom()或者rcvmsg()函数接受消息
5)完成本次通信过程
这里的区别就是发往内核的消息格式不同于传统的网络通信，在传统网络上发送一个IP网络数据包的话，则数据包结构为“IP包头+IP数据”，同样地，netlink的消息结构是“netlink消息头部+数据”，因此用户空间使用netlink发往内核的消息至少要包含一个netlink的头结构，这里的数据部分不是必须的，因为一般情况下，用户空间发往内核的消息类型与内核发往用户的消息类型并不相同，可以根据需要自由添加

用户态应用使用标准的socket与内核通讯，标准的socket API 的函数， socket(), bind(), sendmsg(), recvmsg() 和 close()很容易地应用到 netlink socket。
为了创建一个 netlink socket，用户需要使用如下参数调用 socket():
  1. socket(AF_NETLINK, SOCK_RAW, netlink_type)

netlink对应的协议簇是 AF_NETLINK，第二个参数必须是SOCK_RAW或SOCK_DGRAM， 第三个参数指定netlink协议类型，它可以是一个自定义的类型，也可以使用内核预定义的类型：
  1. #define NETLINK_ROUTE          0       /* Routing/device hook                          */
  2. #define NETLINK_W1             1       /* 1-wire subsystem                             */
  3. #define NETLINK_USERSOCK       2       /* Reserved for user mode socket protocols      */
  4. #define NETLINK_FIREWALL       3       /* Firewalling hook                             */
  5. #define NETLINK_INET_DIAG      4       /* INET socket monitoring                       */
  6. #define NETLINK_NFLOG          5       /* netfilter/iptables ULOG */
  7. #define NETLINK_XFRM           6       /* ipsec */
  8. #define NETLINK_SELINUX        7       /* SELinux event notifications */
  9. #define NETLINK_ISCSI          8       /* Open-iSCSI */
  10. #define NETLINK_AUDIT          9       /* auditing */
  11. #define NETLINK_FIB_LOOKUP     10
  12. #define NETLINK_CONNECTOR      11
  13. #define NETLINK_NETFILTER      12      /* netfilter subsystem */
  14. #define NETLINK_IP6_FW         13
  15. #define NETLINK_DNRTMSG        14      /* DECnet routing messages */
  16. #define NETLINK_KOBJECT_UEVENT 15      /* Kernel messages to userspace */
#define NETLINK_GENERIC        16

同样地，socket函数返回的套接字，可以交给bind等函数调用：
  1. static int skfd;
  2. skfd = socket(PF_NETLINK, SOCK_RAW, NL_IMP2);
  3. if(skfd < 0)
  4. {
  5.       printf("can not create a netlink socket\n");
  6.       exit(0);
  7. }


bind函数需要绑定协议地址，netlink的socket地址使用struct sockaddr_nl结构描述：
  1. struct sockaddr_nl
  2. {
  3.   sa_family_t    nl_family;
  4.   unsigned short nl_pad;
  5.   __u32          nl_pid;
  6.   __u32          nl_groups;
  7. };

成员 nl_family为协议簇 AF_NETLINK，成员 nl_pad 当前没有使用，因此要总是设置为 0，成员 nl_pid 为接收或发送消息的进程的 ID，如果希望内核处理消息或多播消息，就把该字段设置为 0，否则设置为处理消息的进程 ID。成员 nl_groups 用于指定多播组，bind 函数用于把调用进程加入到该字段指定的多播组，如果设置为 0，表示调用者不加入任何多播组：
  1. struct sockaddr_nl local;

  3. memset(&local, 0, sizeof(local));
  4. local.nl_family = AF_NETLINK;
  5. local.nl_pid = getpid();                /*设置pid为自己的pid值*/
  6. local.nl_groups = 0;
  7. /*绑定套接字*/
  8. if(bind(skfd, (struct sockaddr*)&local, sizeof(local)) != 0)
  9. {
  10. printf("bind() error\n");
  11.      return -1;
  12. }


用户空间可以调用send函数簇向内核发送消息，如sendto、sendmsg等，同样地，也可以使用struct sockaddr_nl来描述一个对端地址，以待send函数来调用，与本地地址稍不同的是，因为对端为内核，所以nl_pid成员需要设置为0：

  1. struct sockaddr_nl kpeer;
  2. memset(&kpeer, 0, sizeof(kpeer));
  3. kpeer.nl_family = AF_NETLINK;
  4. kpeer.nl_pid = 0;
  5. kpeer.nl_groups = 0;


另一个问题就是发内核发送的消息的组成，使用我们发送一个IP网络数据包的话，则数据包结构为“IP包头+IP数据”，同样地，netlink的消息结构是“netlink消息头部+数据”。Netlink消息头部使用struct nlmsghdr结构来描述：
  1. struct nlmsghdr
  2. {
  3.   __u32 nlmsg_len;   /* Length of message */
  4.   __u16 nlmsg_type;  /* Message type*/
  5.   __u16 nlmsg_flags; /* Additional flags */
  6.   __u32 nlmsg_seq;   /* Sequence number */
  7.   __u32 nlmsg_pid;   /* Sending process PID */
  8. };


字段 nlmsg_len 指定消息的总长度，包括紧跟该结构的数据部分长度以及该结构的大小，一般地，我们使用netlink提供的宏NLMSG_LENGTH来计算这个长度，仅需向NLMSG_LENGTH宏提供要发送的数据的长度，它会自动计算对齐后的总长度：
  1. /*计算包含报头的数据报长度*/
  2. #define NLMSG_LENGTH(len) ((len)+NLMSG_ALIGN(sizeof(struct nlmsghdr)))
  3. /*字节对齐*/
  4. #define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )


后面还可以看到很多netlink提供的宏，这些宏可以为我们编写netlink宏提供很大的方便。

字段 nlmsg_type 用于应用内部定义消息的类型，它对 netlink 内核实现是透明的，因此大部分情况下设置为 0，字段 nlmsg_flags 用于设置消息标志，对于一般的使用，用户把它设置为 0 就可以，只是一些高级应用（如 netfilter 和路由 daemon 需要它进行一些复杂的操作），字段 nlmsg_seq 和 nlmsg_pid 用于应用追踪消息，前者表示顺序号，后者为消息来源进程 ID。

  1. struct msg_to_kernel                /*自定义消息首部，它仅包含了netlink的消息首部*/
  2. {
  3.   struct nlmsghdr hdr;
  4. };

  6. struct msg_to_kernel message;
  7. memset(&message, 0, sizeof(message));
  8. message.hdr.nlmsg_len = NLMSG_LENGTH(0);                /*计算消息，因为这里只是发送一个请求消息，没有多余的数据，所以，数据长度为0*/
  9. message.hdr.nlmsg_flags = 0;
  10. message.hdr.nlmsg_type = IMP2_U_PID;                        /*设置自定义消息类型*/
  11. message.hdr.nlmsg_pid = local.nl_pid;                /*设置发送者的PID*/

  13. 这样，有了本地地址、对端地址和发送的数据，就可以调用发送函数将消息发送给内核了：
  14.   /*发送一个请求*/
  15.   sendto(skfd, &message, message.hdr.nlmsg_len, 0,
  16.          (struct sockaddr*)&kpeer, sizeof(kpeer));


当发送完请求后，就可以调用recv函数簇从内核接收数据了，接收到的数据包含了netlink消息首部和要传输的数据：
  1. /*接收的数据包含了netlink消息首部和自定义数据结构*/
  2. struct u_packet_info
  3. {
  4.   struct nlmsghdr hdr;
  5.   struct packet_info icmp_info;
  6. };
  7. struct u_packet_info info;
  8. while(1)
  9. {
  10.     kpeerlen = sizeof(struct sockaddr_nl);
  11.       /*接收内核空间返回的数据*/
  12.       rcvlen = recvfrom(skfd, &info, sizeof(struct u_packet_info),
  13.                         0, (struct sockaddr*)&kpeer, &kpeerlen);
  14.                   
  15.        /*处理接收到的数据*/
  16. ……
  17. }


同样地，函数close用于关闭打开的netlink socket。程序中，因为程序一直循环接收处理内核的消息，需要收到用户的关闭信号才会退出，所以关闭套接字的工作放在了自定义的信号函数sig_int中处理：
  1. /*这个信号函数，处理一些程序退出时的动作*/
  2. static void sig_int(int signo)
  3. {
  4.   struct sockaddr_nl kpeer;
  5.   struct msg_to_kernel message;

  7.   memset(&kpeer, 0, sizeof(kpeer));
  8.   kpeer.nl_family = AF_NETLINK;
  9.   kpeer.nl_pid    = 0;
  10.   kpeer.nl_groups = 0;

  12.   memset(&message, 0, sizeof(message));
  13.   message.hdr.nlmsg_len = NLMSG_LENGTH(0);
  14.   message.hdr.nlmsg_flags = 0;
  15.   message.hdr.nlmsg_type = IMP2_CLOSE;
  16.   message.hdr.nlmsg_pid = getpid();

  18.   /*向内核发送一个消息，由nlmsg_type表明，应用程序将关闭*/
  19.   sendto(skfd, &message, message.hdr.nlmsg_len, 0, (struct sockaddr *)(&kpeer),         sizeof(kpeer));

  21.   close(skfd);
  22.   exit(0);
  23. }


这个结束函数中，向内核发送一个“我已经退出了”的消息，然后调用close函数关闭netlink套接字，退出程序。

内核空间
内核空间的流程比用户空间难理解一些，主要包括3部分工作
1)创建netlink套接字，并注册回调函数，这里的回调函数就是当有消息到达netlink socket时，就会触发回调函数的执行
2)根据用户的请求类型，处理用户空间发送的数据
3)将数据发送至用户空间
按照文章头所讲的netlink实现机制的话，回调函数是被防在软中断中区处理的，通过这种方式去保证相应的实时性，但是按照原文所讲最终结果是通过中断的方式返回用户层的，所以这一点仍然存有疑问。。。
如果按照软中断去实现的话，如果操作量很大，全部都在软中断中完成工作的话，可能会影响后续包的接受，因此可以通过其他形式，如创建内核线程的方式帮助处理
在本例中，回调函数仅仅完成用户空间与内核空间连结的建立，将消息写回用户空间的操作交由netfilter完成
如果最简单的形式，应该是在回调函数中，获取用户空间数据，根据消息类型，完成相应操作，将消息直接发回用户空间

与应用程序内核，内核空间也主要完成三件工作：
n        创建netlink套接字
n        接收处理用户空间发送的数据
n        发送数据至用户空间

API函数netlink_kernel_create用于创建一个netlink socket，同时，注册一个回调函数，用于接收处理用户空间的消息：

  1. struct sock *
  2. netlink_kernel_create(int unit, void (*input)(struct sock *sk, int len));


参数unit表示netlink协议类型，如NL_IMP2，参数input则为内核模块定义的netlink消息处理函数，当有消息到达这个netlink socket时，该input函数指针就会被引用。函数指针input的参数sk实际上就是函数netlink_kernel_create返回的struct sock指针，sock实际是socket的一个内核表示数据结构，用户态应用创建的socket在内核中也会有一个struct sock结构来表示。
  1. static int __init init(void)
  2. {
  3.   rwlock_init(&user_proc.lock);                /*初始化读写锁*/

  5.   /*创建一个netlink socket，协议类型是自定义的ML_IMP2，kernel_reveive为接受处理函数*/
  6.   nlfd = netlink_kernel_create(NL_IMP2, kernel_receive);
  7.   if(!nlfd)                /*创建失败*/
  8.   {
  9.       printk("can not create a netlink socket\n");
  10.       return -1;
  11.   }

  13.   /*注册一个Netfilter 钩子*/
  14.   return nf_register_hook(&imp2_ops);
  15. }


  18. module_init(init);


用户空间向内核发送了两种自定义消息类型：IMP2_U_PID和IMP2_CLOSE，分别是请求和关闭。kernel_receive 函数分别处理这两种消息：
  1. DECLARE_MUTEX(receive_sem);                                                        /*初始化信号量*/
  2. static void kernel_receive(struct sock *sk, int len)
  3. {
  4.         do
  5.     {
  6.                 struct sk_buff *skb;
  7.                 if(down_trylock(&receive_sem))                                /*获取信号量*/
  8.                         return;
  9.                 /*从接收队列中取得skb，然后进行一些基本的长度的合法性校验*/
  10.                 while((skb = skb_dequeue(&sk->receive_queue)) != NULL)
  11.         {
  12.                         {
  13.                                 struct nlmsghdr *nlh = NULL;
  14.                                
  15.                                 if(skb->len >= sizeof(struct nlmsghdr))
  16.                                 {
  17.                                         /*获取数据中的nlmsghdr 结构的报头*/
  18.                                         nlh = (struct nlmsghdr *)skb->data;
  19.                                         if((nlh->nlmsg_len >= sizeof(struct nlmsghdr))
  20.                                                 && (skb->len >= nlh->nlmsg_len))
  21.                                         {
  22.                                                 /*长度的全法性校验完成后，处理应用程序自定义消息类型，主要是对用户PID的保存，即为内核保存“把消息发送给谁”*/
  23.                                                 if(nlh->nlmsg_type == IMP2_U_PID)                /*请求*/
  24.                                                 {
  25.                                                         write_lock_bh(&user_proc.pid);
  26.                                                         user_proc.pid = nlh->nlmsg_pid;
  27.                                                         write_unlock_bh(&user_proc.pid);
  28.                                                 }
  29.                                                 else if(nlh->nlmsg_type == IMP2_CLOSE)        /*应用程序关闭*/
  30.                                                 {
  31.                                                         write_lock_bh(&user_proc.pid);
  32.                                                         if(nlh->nlmsg_pid == user_proc.pid)
  33.                                                                 user_proc.pid = 0;
  34.                                                         write_unlock_bh(&user_proc.pid);
  35.                                                 }
  36.                                         }
  37.                                 }
  38.                         }
  39.                         kfree_skb(skb);
  40.         }
  41.                 up(&receive_sem);                                /*返回信号量*/
  42.     }while(nlfd && nlfd->receive_queue.qlen);
  43. }
 03～18 和 31～38 是 netlink socket 在内核空间接收数据的框架。在框架中主要是从套接字缓存中取出全部的数据，然后分析是不是合法的数据报，合法的 netlink 数据报必须有nlmsghdr 结构的报头。在实例这里使用了自己定义的消息类型：IMP2_U_PID（消息为用户空间进程的ID），IMP2_CLOSE（用户空间进程关闭）。因为考虑到 SMP，所以在这里使用了读写锁来避免不同 CPU 访问临界区的问题。
kernel_receive() 函数的运行在软中断环境

因为内核模块可能同时被多个进程同时调用，所以函数中使用了信号量和锁来进行互斥。skb = skb_dequeue(&sk->receive_queue)用于取得socket sk的接收队列上的消息，返回为一个struct sk_buff的结构，skb->data指向实际的netlink消息。

程序中注册了一个Netfilter钩子，钩子函数是get_icmp，它截获ICMP数据包，然后调用send_to_user函数将数据发送给应用空间进程。发送的数据是info结构变量，它是struct packet_info结构，这个结构包含了来源/目的地址两个成员。Netfilter Hook不是本文描述的重点，略过。
send_to_user 用于将数据发送给用户空间进程，发送调用的是API函数netlink_unicast 完成的：
  1. int netlink_unicast(struct sock *sk, struct sk_buff *skb, u32 pid, int nonblock);


参数sk为函数netlink_kernel_create()返回的套接字，参数skb存放待发送的消息，它的data字段指向要发送的netlink消息结构，而skb的控制块保存了消息的地址信息， 参数pid为接收消息进程的pid，参数nonblock表示该函数是否为非阻塞，如果为1，该函数将在没有接收缓存可利用时立即返回，而如果为0，该函数在没有接收缓存可利用时睡眠。
向用户空间进程发送的消息包含三个部份：netlink 消息头部、数据部份和控制字段，控制字段包含了内核发送netlink消息时，需要设置的目标地址与源地址，内核中消息是通过sk_buff来管理的， linux/netlink.h中定义了NETLINK_CB宏来方便消息的地址设置：

  1. #define NETLINK_CB(skb)         (*(struct netlink_skb_parms*)&((skb)->cb))


例如：

  1. NETLINK_CB(skb).pid = 0;
  2. NETLINK_CB(skb).dst_pid = 0;
  3. NETLINK_CB(skb).dst_group = 1;


字段pid表示消息发送者进程ID，也即源地址，对于内核，它为 0， dst_pid 表示消息接收者进程 ID，也即目标地址，如果目标为组或内核，它设置为 0，否则 dst_group 表示目标组地址，如果它目标为某一进程或内核，dst_group 应当设置为 0。
  1. static int send_to_user(struct packet_info *info)
  2. {
  3. int ret;
  4. int size;
  5. unsigned char *old_tail;
  6. struct sk_buff *skb;
  7. struct nlmsghdr *nlh;
  8. struct packet_info *packet;

  10. /*计算消息总长：消息首部加上数据加度*/
  11. size = NLMSG_SPACE(sizeof(*info));

  13. /*分配一个新的套接字缓存*/
  14. skb = alloc_skb(size, GFP_ATOMIC);
  15. old_tail = skb->tail;

  17. /*初始化一个netlink消息首部*/
  18. nlh = NLMSG_PUT(skb, 0, 0, IMP2_K_MSG, size-sizeof(*nlh));
  19. /*跳过消息首部，指向数据区*/
  20. packet = NLMSG_DATA(nlh);
  21. /*初始化数据区*/
  22. memset(packet, 0, sizeof(struct packet_info));
  23. /*填充待发送的数据*/
  24. packet->src = info->src;
  25. packet->dest = info->dest;

  27. /*计算skb两次长度之差，即netlink的长度总和*/
  28. nlh->nlmsg_len = skb->tail - old_tail;
  29. /*设置控制字段*/
  30. NETLINK_CB(skb).dst_groups = 0;

  32. /*发送数据*/
  33. read_lock_bh(&user_proc.lock);
  34. ret = netlink_unicast(nlfd, skb, user_proc.pid, MSG_DONTWAIT);
  35. read_unlock_bh(&user_proc.lock);
  36. return ret;
  37.  
  38. nlmsg_failure:
     
  39. if(skb)
       
  40.  kfree_skb(skb);
     
  41. return -1;

  43. }
个人认为，由于netlin通信在形式上借助于socket的机制来实现，所以对于每一个消息都要封装成skb套接字，在内核接收数据的时候再skb缓存中找寻对应的skb结构，在发送的时候也要自己构建相应的skb结构，然后将消息发送回用户空间

函数初始化netlink 消息首部，填充数据区，然后设置控制字段，这三部份都包含在skb_buff中，最后调用netlink_unicast函数把数据发送出去。
函数中调用了netlink的一个重要的宏NLMSG_PUT，它用于初始化netlink 消息首部：
  1. #define NLMSG_PUT(skb, pid, seq, type, len) \
  2. ({ if (skb_tailroom(skb) < (int)NLMSG_SPACE(len)) goto nlmsg_failure; \
  3.    __nlmsg_put(skb, pid, seq, type, len); })
  4. static __inline__ struct nlmsghdr *
  5. __nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len)
  6. {
  7.         struct nlmsghdr *nlh;
  8.         int size = NLMSG_LENGTH(len);

  10.         nlh = (struct nlmsghdr*)skb_put(skb, NLMSG_ALIGN(size));
  11.         nlh->nlmsg_type = type;
  12.         nlh->nlmsg_len = size;
  13.         nlh->nlmsg_flags = 0;
  14.         nlh->nlmsg_pid = pid;
  15.         nlh->nlmsg_seq = seq;
  16.         return nlh;
  17. }


这个宏一个需要注意的地方是调用了nlmsg_failure标签，所以在程序中应该定义这个标签。

在内核中使用函数sock_release来释放函数netlink_kernel_create()创建的netlink socket：
  1. void sock_release(struct socket * sock);


程序在退出模块中释放netlink sockets和netfilter hook：
  1. static void __exit fini(void)
  2. {
  3.   if(nlfd)
  4.     {
  5.       sock_release(nlfd->socket);                /*释放netlink socket*/
  6.     }
  7.   nf_unregister_hook(&imp2_ops);                /*撤锁netfilter 钩子*/
  8. }
阅读(2107) | 评论(0) | 转发(0) |
0

上一篇：netfilter/iptables 简介

下一篇：list_entry 与 container_of

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6