绑定完请刷新页面
取消
刷新
登录 | 注册

分享好友

×
取消 复制
Linux内核IP Queue机制的分析（三）——ip_queue内核模块的分析（3）
2020-05-25 10:23:22

（三）ip_queue报文入队处理函数的注册
   在上面分析的模块注册代码中，IP Queue的报文入队处理函数的注册是通过调用nf_register_queue_handler()来实现的。因此，有必要了解一下该函数的源码，源码位于nf_queue.c中：

  1. /* return EBUSY when somebody else is registered, return EEXIST if the
  2. * same handler is registered, return 0 in case of success. */
  3. int nf_register_queue_handler(int pf, struct nf_queue_handler *qh)
  4. {      
  5.         int ret;
  6.         /*IP协议族的值必须在当前指定的范围内*/
  7.         if (pf >= NPROTO)
  8.                 return -EINVAL;

  10.         write_lock_bh(&queue_handler_lock);
  11.         /*该queue handler已经被注册过了*/
  12.         if (queue_handler[pf] == qh)
  13.                 ret = -EEXIST;
  14.         /*该协议族已经被注册了handler了*/
  15.         else if (queue_handler[pf])
  16.                 ret = -EBUSY;
  17.         /*将该协议的queue hanler指向参数qh*/
  18.         else {
  19.                 queue_handler[pf] = qh;
  20.                 ret = 0;
  21.         }
  22.         write_unlock_bh(&queue_handler_lock);

  24.         return ret;
  25. }
复制代码


该函数的代码比较简单，先来了解一下函数的两个参数：
（1）pf：IP协议族的值，PF_INET和PF_INET6分别代表IPv4和IPv6。
（2）qh：NF中对报文进行Queue的结构体，定义如下(netfilter.h)：

  1. /* Packet queuing */
  2. struct nf_queue_handler {
  3.         int (*outfn)(struct sk_buff *skb, struct nf_info *info,
  4.                      unsigned int queuenum, void *data);
  5.         void *data;
  6.         char *name;
  7. };
复制代码


由此可见，该结构体主要包含一个函数指针，用于处理NF框架需要Queue的报文。data应该是用来保存一些私有数据，name则是该queue handler的名称。
代码中已经包含了该函数源码的简单注释，这里再对该函数进行一下简单的总结：
(1) 每个协议族只能注册一个queue handler；
(2) 随后报文的处理中，可以根据报文的协议族，就可以找到报文进行Queue时的处理函数queue_handler[pf]->outfn()。
        在IP Queue模块中，queue handler的注册如下所示：

  1. status = nf_register_queue_handler(PF_INET, &nfqh);
复制代码


        可见，注册的是IPv4协议族的报文处理函数，而nfqh结构体的定义如下：

  1. static struct nf_queue_handler nfqh = {
  2.         .name        = "ip_queue",
  3.         .outfn        = &ipq_enqueue_packet,
  4. };
复制代码


这里，IP Queue处理报文的函数终于闪亮登场了，我们前面啰嗦了半天，主要就是想理顺一下思路，顺理成章的引出该函数。
（四）入队函数ipq_enqueue_packet —— 发送数据包到用户空间
        第二部分已经分析过了该函数会在什么条件下被触发。这里详细分析该函数的实现，代码在ip_queue.c中。
        分析代码之前，我们先了解一下IP Queue对数据包队列管理的核心数据结构：

  1. struct ipq_queue_entry {
  2.         struct list_head list;
  3.         struct nf_info *info;
  4.         struct sk_buff *skb;
  5. };
复制代码


所有被Queue到用户空间的数据包都会有这样一个结构体。其中，
该数据结构的第1个元素是个双向链表结构，用于将所有queue的数据包用双向链表连
接起来，实现队列管理。
第2个元素同样是一个结构体，其定义在netfilter.h中：

  1. /* Each queued (to userspace) skbuff has one of these. */
  2. struct nf_info
  3. {
  4.         /* The ops struct which sent us to userspace. */
  5.         struct nf_hook_ops *elem;
  6.         
  7.         /* If we're sent to userspace, this keeps housekeeping info */
  8.         int pf;
  9.         unsigned int hook;
  10.         struct net_device *indev, *outdev;
  11.         int (*okfn)(struct sk_buff *);
  12. };
复制代码


这个结构体应该很容易看出他的作用，就是记录下当数据包被Queue时所在的hook函数的相关信息，包括hook的操作结构、协议号、hook点等相关信息。当用户空间下发了对数据包的处理结果时，内核就需要参考这个结构对数据包进行进一步的处理。具体的我们会在后面数据包回注函数中分析。
第3个元素是skb本身，也就是回注函数中要处理的数据包。

OK，我们下面就开始如对函数的分析。

  1. static int
  2. ipq_enqueue_packet(struct sk_buff *skb, struct nf_info *info,
  3.                    unsigned int queuenum, void *data)
  4. {
  5.         int status = -EINVAL;
  6.         struct sk_buff *nskb;
  7.         struct ipq_queue_entry *entry;

  9.         /*判断用户配置的模式，可以为拷贝元数据或者整个数据包的信息*/
  10.         if (copy_mode == IPQ_COPY_NONE)
  11.                 return -EAGAIN;
  12.         /*为即将入队的数据包分配一个struct ipq_queue_entry 结构体，用于实现对数据包的管理，我们称之为queue管理结构体*/
  13.         entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
  14.         if (entry == NULL) {
  15.                 printk(KERN_ERR "ip_queue: OOM in ipq_enqueue_packet()\n");
  16.                 return -ENOMEM;
  17.         }
  18.         /*将该数据包对应的相关信息保存到管理结构体中*/
  19.         entry->info = info;
  20.         entry->skb = skb;
  21.         
  22. /*构建用于发往用户空间的消息*/
  23.         nskb = ipq_build_packet_message(entry, &status);
  24.         if (nskb == NULL)
  25.                 goto err_out_free;
  26.                 
  27.         write_lock_bh(&queue_lock);
  28.         
  29.         /如果用户空间没有开启进程，等待接收消息的话，就释放该消息/
  30.         if (!peer_pid)
  31.                 goto err_out_free_nskb; 
  32.         /*如果当前队列中的数据包总数超过了设置的大值，则是放该消息，并且增加丢弃数据包的统计计数*/
  33.         if (queue_total >= queue_maxlen) {
  34.                 queue_dropped++;
  35.                 status = -ENOSPC;
  36.                 if (net_ratelimit())
  37.                           printk (KERN_WARNING "ip_queue: full at %d entries, "
  38.                                   "dropping packets(s). Dropped: %d\n", queue_total,
  39.                                   queue_dropped);
  40.                 goto err_out_free_nskb;
  41.         }

  43.         /* 将消息发送给用户空间 */ 
  44.         status = netlink_unicast(ipqnl, nskb, peer_pid, MSG_DONTWAIT);
  45.         if (status < 0) {
  46.                 queue_user_dropped++;
  47.                 goto err_out_unlock;
  48.         }
  49.         /*成功发送到用户空间之后，将该数据包的queue管理结构添加到全局队列链表中*/
  50.         __ipq_enqueue_entry(entry);

  52.         write_unlock_bh(&queue_lock);
  53.         return status;

  55. err_out_free_nskb:
  56.         kfree_skb(nskb); 
  57.         
  58. err_out_unlock:
  59.         write_unlock_bh(&queue_lock);

  61. err_out_free:
  62.         kfree(entry);
  63.         return status;
  64. }
复制代码


该函数成功执行之后，就将数据包相关的信息发送到用户空间，同时将该数据包对应的queue管理结构加到全局链表中。
下面对于ipq_enqueue_packet函数中调用的几个重要函数做一些分析。
首先是构建消息的函数ipq_build_packet_message。

  1. static struct sk_buff *
  2. ipq_build_packet_message(struct ipq_queue_entry *entry, int *errp)
  3. {
  4.         unsigned char *old_tail;
  5.         size_t size = 0;
  6.         size_t data_len = 0;
  7.         struct sk_buff *skb;
  8.         struct ipq_packet_msg *pmsg;
  9.         struct nlmsghdr *nlh;

  11.         read_lock_bh(&queue_lock);
  12.         /*根据用户配置的copy模式，确定发给用户空间消息的长度*/
  13.         switch (copy_mode) {
  14.         /*对于初始模式和拷贝元数据的模式，消息应该包括netlink的消息头和ipq的消息头，长度为两个消息头长度之和，即sizeof(struct nlmsghdr) + sizeof(struct ipq_packet_msg)，并考虑对齐的因素。这里直接调用netlink封装的宏NLMSG_SPACE来计算长度。该宏本身已经包含了netlink消息头的长度*/
  15.         case IPQ_COPY_META:
  16.         case IPQ_COPY_NONE:
  17.                 /*消息长度为netlink的消息头和ipq的消息头的长度之和*/
  18.                 size = NLMSG_SPACE(sizeof(*pmsg));
  19.                 data_len = 0;
  20.                 break;
  21.         
  22.         case IPQ_COPY_PACKET:
  23.                 if (entry->skb->ip_summed == CHECKSUM_HW &&
  24.                     (*errp = skb_checksum_help(entry->skb,
  25.                                                entry->info->outdev == NULL))) {
  26.                         read_unlock_bh(&queue_lock);
  27.                         return NULL;
  28.                 }
  29.                 /*如果用户需要拷贝整个数据包的内容，那么如果配置的长度为0或者超出数据包的实际长度，则以数据包的实际长度进行拷贝*/
  30.                 if (copy_range == 0 || copy_range > entry->skb->len)
  31.                         data_len = entry->skb->len;
  32.                 else
  33.                         data_len = copy_range;
  34.                 /*消息长度为netlink的消息头、ipq的消息头的长度以及要拷贝数据包的长度之和*/
  35.                 size = NLMSG_SPACE(sizeof(*pmsg) + data_len);
  36.                 break;
  37.         
  38.         default:
  39.                 *errp = -EINVAL;
  40.                 read_unlock_bh(&queue_lock);
  41.                 return NULL;
  42.         }

  44.         read_unlock_bh(&queue_lock);
  45.         /*为构建的消息申请内存，同样适用skb结构体，消息的内容应该在skb->data和skb->tail之间*/
  46.         skb = alloc_skb(size, GFP_ATOMIC);
  47.         if (!skb)
  48.                 goto nlmsg_failure;
  49.         /*记录一下新分配的skb中的tail指针的地址，此时应该skb->tail指向skb->data*/
  50.         old_tail= skb->tail;
  51.         /*填充netlink消息头*/
  52.         nlh = NLMSG_PUT(skb, 0, 0, IPQM_PACKET, size - sizeof(*nlh));
  53.         /*获取netlink消息体的起始地址，即ipq的消息头*/
  54.         pmsg = NLMSG_DATA(nlh);
  55.         memset(pmsg, 0, sizeof(*pmsg));

  57.         /*将相关的ipq消息记录到消息头中*/
  58.                 /*将skb对应的queue管理结构体的地址作为packet_id*/
  59.         pmsg->packet_id       = (unsigned long )entry; 
  60.         pmsg->data_len        = data_len;
  61.         pmsg->timestamp_sec   = entry->skb->tstamp.off_sec;
  62.         pmsg->timestamp_usec  = entry->skb->tstamp.off_usec;
  63.         pmsg->mark            = entry->skb->nfmark;
  64.         pmsg->hook            = entry->info->hook;
  65.         pmsg->hw_protocol     = entry->skb->protocol;
  66.         
  67.         /*记录被queue数据包对应的输入设备名称*/
  68.         if (entry->info->indev)
  69.                 strcpy(pmsg->indev_name, entry->info->indev->name);
  70.         else
  71.                 pmsg->indev_name[0] = '\0';
  72.         /*记录被queue数据包对应的输出设备名称*/
  73.         if (entry->info->outdev)
  74.                 strcpy(pmsg->outdev_name, entry->info->outdev->name);
  75.         else
  76.                 pmsg->outdev_name[0] = '\0';

  78.         /*记录被queue数据包对应的链路层的协议类型及地址长度*/
  79.         if (entry->info->indev && entry->skb->dev) {
  80.                 pmsg->hw_type = entry->skb->dev->type;
  81.                 if (entry->skb->dev->hard_header_parse)
  82.                         pmsg->hw_addrlen =
  83.                                 entry->skb->dev->hard_header_parse(entry->skb,
  84.                                                                    pmsg->hw_addr);
  85.         }
  86.         /* data_len != 0 说明需要拷贝数据包的原始数据。skb_copy_bits 函数的实现不再分析，其主要功能就是将从skb->data+offset开始的数据拷贝data_len个字节到pmsg->payload中，即ipq消息的载荷。另外一个需要注意的问题，如果skb挂载的有分片包，则skb_copy_bits也会按照顺序拷贝分片包中的数据*/
  87.         if (data_len)
  88.                 if (skb_copy_bits(entry->skb, 0, pmsg->payload, data_len))
  89.                         BUG();
  90.         /*设置netlink消息的长度*/
  91.         nlh->nlmsg_len = skb->tail - old_tail;
  92.         return skb;

  94. nlmsg_failure:
  95.         if (skb)
  96.                 kfree_skb(skb);
  97.         *errp = -EINVAL;
  98.         printk(KERN_ERR "ip_queue: error creating packet message\n");
  99.         return NULL;
  100. }
复制代码


其次，对于netlink_unicast函数，我们这里不具体分析，它的作用就是将内核封装好的netlink消息发送到用户态。
后分析一下__ipq_enqueue_entry 函数。

  1. static inline void
  2. __ipq_enqueue_entry(struct ipq_queue_entry *entry)
  3. {
  4.        list_add(&entry->list, &queue_list);
  5.        queue_total++;
  6. }
复制代码


该函数的功能很简答，就是将当前skb的queue管理结构添加到全局的queue管理链表queue_list中，并增加队列的统计计数。该链表记录了所有发往用户空间，且并未收到用户空间下发处理结果的数据包。
至此，数据包的入队处理函数已经分析完毕。一切顺利执行的话，现在用户态已经接收到关于该数据包的消息。

--未完待续  

文章来源CU社区：Linux内核IP Queue机制的分析（三）——ip_queue内核模块的分析

上一篇：架构成长之路：大型网站演变中的负载均衡场景分析!
下一篇：Linux内核IP Queue机制的分析（三）——ip_queue内核模块的分析（2）
分享好友

分享这个小栈给你的朋友们，一起进步吧。

内核源码
创建时间：2020-05-18 13:36:55
内核源码精华帖内容汇总
展开
订阅须知

• 所有用户可根据关注领域订阅专区或所有专区

• 付费订阅：虚拟交易，一经交易不退款；若特殊情况，可3日内客服咨询

• 专区发布评论属默认订阅所评论专区（除付费小栈外）

技术专家

查看更多
  • 飘絮絮絮丶
    专家
戳我，来吐槽～

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8  北京市公安局海淀分局网监中心备案编号：11010802021510  未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员