深入剖析数据接收过程

深入剖析数据接收过程

Layer 2：数据链路层(Data Link Layer)

在进入正式讨论数据包的接收之前，需要介绍一下linux中断过程。 当网卡检测到一个数据包到来时，就会向8259A触发相应的中断信号线，识别为一个中断后，控制单元将会执行如下步骤：

1. 确定与中断或异常关联的向量i（0≤ i ≤255） 2. 读由idtr寄存器指向的IDT表中的第i项。 3. 从gdtr寄存器获得GDT的基地址，并在GDT中查找，以读取IDT表项中的选择符标识的段描述符。这个描述符指定中断或异常处理程序所在的段的基地址。

4. 确信中断是由授权的（中断）发生源发出的。首先将当前特权级CPL（存放在cs寄存器的低两位）与段描述符（存放在GDT中）的描述符特权级DPL比较。如果CPL小于DPL，就产生一个“通常保护”异常，因为中断处理程序的特权级不能低于引起中断的程序的特权。对于编程异常，则做进一步的安全检查：比较CPL与处于IDT中的门描述符的DPL，如果DPL小于CPL，就产生一个“通常保护”异常，这最后

一个检查可以避免用户应用程序访问特殊的陷阱门和中断门。

5. 检查是否发生了特权级的变化，也就是说，CPL是否不同于所选择的段描述符的DPL。如果是，控制单元必须开始使用与新的特权级相关的栈，通过执行以下步骤来保证这一点： A． 读tr寄存器，以访问运行进程的TSS段。

B． 用与新特权级相关的栈段和栈指针的正确值装载ss和esp寄存器。这些值可以在TSS中找到。

C． 在新的栈中保存ss和esp以前的值，这些值定义了与旧特权级相关的栈的逻辑地址。 6. 如果故障已发生，用引起异常的指令地址装载cs和eip寄存器，从而使得这条指令能再次被执行。

7. 在栈中保存eflag、cs和eip的内容。

8. 如果异常产生了一个硬件出错码，则将它保存在栈中。

9. 装载cs和eip寄存器，其值分别是IDT表中第i项门描述符的段选择符和偏移量字段。这些值给出了中断或者异常处理程序的第一条指令的逻辑地址。 从上面的步骤可以看出，硬件会做相应的一些环境保存：转入到 SS和ESP指针所在的地址，也就是新栈地址。这样就可以访问新的栈了(通过SS+ESP)，但是还有一个问题：当我们的中断返回时也要恢复到原来的栈，那么原来所在的栈都保存到什么地方呢？其实就是保存在所切换到的这个新栈中，好了地方是找到了，保存到新栈中。那么旧的SS和ESP的值又到哪里去找呢？是在TSS中，其实在中断发生的时候,如果检测到运行级别发生了改了,将寄存器SS,ESP中的值保存进TSS的相应级别位置，再加载新的SS,ESP的值,然后从TSS中取出旧的SS,ESP值,再压栈.压栈前后示意图如下：

以上所陈述的都是硬件自动保存的环境，那么还有很多寄存器的值由谁来保存呢？这就需要操作系统来完成了。 从上面的第9步，我们可以清晰的看到，下一步CPU将要做的事情就是执行中断或是异常所在的地址。其实IRQn中断处理程序所在的地址开始是保存在interrupt[n]之中的，之后才复制到IDT相应的表项中断门中.那么我们可以看下iterript[n]是在什么地方，是否在它后面还有些什么代码？在/arch/i386/kernel/entry.S中可以找到这个地址： .data

ENTRY(interrupt) .text

vector=0

ENTRY(irq_entries_start) .rept NR_IRQS ALIGN

1: pushl $vector-256 jmp common_interrupt .data

.long 1b .text

vector=vector+1 .endr

可以看到在interrupt之后还出现了这么两句： 1: pushl $vector-256//将中断索引号取负压栈 jmp common_interrupt

好，接下来看common_interrupt是什么？ ALIGN

common_interrupt: SAVE_ALL

movl %esp,êx call do_IRQ

jmp ret_from_intr

在common_interrupt:之后首先我们看到的就是一个宏SAVE_ALL，该宏就是我们刚才所说的系统对其它一些中断环境的保存，如下：

#define SAVE_ALL \\

__SAVE_ALL; \\

__SWITCH_KERNELSPACE; #在没有定义CONFIG_X86_HIGH_ENTRY的情况下,此宏是一个空宏

__SAVE_ALL定义如下: #define __SAVE_ALL \\ cld; \\ pushl %es; \\ pushl %ds; \\ pushl êx; \\ pushl ?p; \\ pushl íi; \\ pushl %esi; \\ pushl íx; \\ pushl ìx; \\ pushl ?x; \\

movl $(__USER_DS), íx; \\ movl íx, %ds; \\ movl íx, %es;

__USER_DS的设置是为了在中断返回之后，防止不法程序对内核的访问而设置的，也免去了内核清除寄存器的任务，使得系统提高了效率。从eax开始到ebx都是传递给中断处理函数的参数选项。

以上其实都是我对网络上一篇非常经典的关于中断初始化的文章<>的一个简述，这篇文章的完整内容如下:

http://blog.chinaunix.net/u/26185/showart_1405389.html

好了，接下来就是进入do_IRQ了。关于d0_IRQ()所做的工作，以及后来如何调用到我们所定义的中断处理函数的详细过程可以参考下面这篇文章（这篇文章太经典了！），名为Linux处理之IRQ中断。

http://tech.ddvip.com/2008-11/122725623294208.html 好了，关于系统中断我们先简单介绍到这里，下面进入Linux驱动开发中所对应的中断处理程序。

1） 中断处理函数

由前面的分析可以看到内核接下来就进入到了中断处理部分。中断处理函数主要做如下工作：

1.1） 间接调用outsw来访问网卡控制寄存器中的接收标志以及其它一些硬件标志，做

出相应的动作。当检测到网卡中数据包到来了时就进入数据包的处理阶段。

1.2） 数据包处理阶段：

1.2.1）首先访问网卡控制寄存器，看数据包被放在了网卡的什么地方，返回一个缓

冲区的标识号(index)。

1.2.2）查询该标识号所对应的缓冲区是否空闲.

1.2.3) 从网卡所标识的缓冲区中将数据读出到内存缓冲区中。

1.2.4）判断所接收到的数据大小，如果太大和太小均会被丢弃。如下： if (len > 2312) { printk( KERN_ERR \

goto badrx; } if (len == 0) goto badrx;

1.2.5）判断数据帧类型，从而调整数据包头的大小，如下(针对无线网卡)： bap_read (apriv, (u16*)&fc, sizeof(fc), BAP0); fc = le16_to_cpu(fc); switch (fc & 0xc) { case 4: if ((fc & 0xe0) == 0xc0) hdrlen = 10; else hdrlen = 16; break; case 8: if ((fc&0x300)==0x300){ hdrlen = 30; break; } default: hdrlen = 24; } } else hdrlen = ETH_ALEN * 2; 1.2.6）为sk_buff数据结构分配一个空间。 1.2.7）视数据包的大小，从而调整sk_buff的大小。之后将数据再次读入到sk_buff

之中存储。

1.2.8）填写该数据结构中的相应项，如下： skb->mac.raw = skb->data; skb->pkt_type = PACKET_OTHERHOST; skb->dev = apriv->wifidev; skb->protocol = htons(ETH_P_802_2); skb->dev->last_rx = jiffies; skb->ip_summed = CHECKSUM_NONE;

1.2.9）最后一步，调用netif_rx( skb )，将数据交到上层处理。

2）netif_rx()

该函数首先检测所传送过来的skb中的时间戳是否有值，没有的话就获取当前时间作为时间戳。接下来询问当前队列是否还有空闲，如果由空闲就将skb压入到struct softnet_data queue结构体的队列之中，如下：

__skb_queue_tail(&queue->input_pkt_queue, skb); 最后就调用netif_rx_schedule函数，如下： netif_rx_schedule (&queue->backlog_dev);

这里需要注意的是这个函数的参数，看下struct softnet_data的具体结构,如下：

struct softnet_data {

struct net_device *output_queue; struct sk_buff_head input_pkt_queue; struct list_head poll_list;

struct sk_buff *completion_queue; struct net_device backlog_dev; #ifdef CONFIG_NET_DMA

struct dma_chan *net_dma; #endif };

采用该数据结构的原因是当数据包到来时就将它们挂在这个这个数据结构上，这样访问这些数据时就不需要锁定了。

可以看到backlog_dev是一个struct net_device结构，所以数据包就转化为了该数据结构来传输。

2) netif_rx_schedule()

该函数会去调用__netif_rx_schedule，在函数__netif_rx_schedule中会去触发软中断NET_RX_SOFTIRQ, 也即是去调用net_rx_action.如下： __raise_softirq_irqoff(NET_RX_SOFTIRQ);//触发软中断

在net_rx_action函数中会去调用设备的poll函数, 它是设备自己注册的.在设备的poll函数中, 会去调用netif_receive_skb函数。 3) netif_receive_skb(skb)

关于这个函数，R.wen (rwen2012@126.com)写了一份介绍链路层收发数据包的详细文档，

大家可以去看看。（接收过程中的第五点就是介绍这个函数的），地址如下：

http://linux.chinaunix.net/bbs/viewthread.php?tid=886985&extra=

Layer 3：网络层(Network Layer)

由以上文章的分析，我们可以看到。在数据链路层最后是内核调用了deliver_skb()来向上层（也就是网络层）中所注册的协议发送一份IP数据包的副本，当然再内核中可能会注册多个的协议(如ARP,IP)，这里我们讲解IP协议，它具体的处理函数是ip_rcv(). 1）ip_rcv()

1.1）该函数首先对传送过来的数据包中取出ip头描述数据结构struct iphdr *iph，如下：

iph = skb->nh.iph;

1.3） 依据RFC1122中的规定，对不满足规定的IP头数据包丢弃，RFC1122中认为一个

正常的数据包应该有如下几种： 1. 数据包的大小不能小于IP头的大小；

2. 版本是IPV4（当然，我们这是以IPV4来阐述的）； 3. 校验码正确；

4. 数据包的长度是真实的。 如下代码演示了以上规范：

if (iph->ihl < 5 || iph->version != 4) goto inhdr_error;

if (!pskb_may_pull(skb, iph->ihl*4)) goto inhdr_error;

if (ip_fast_csum((u8 *)iph, iph->ihl) != 0) goto inhdr_error;

if (skb->len < len || len < (iph->ihl<<2)) goto inhdr_error;

如果一切都OK，那么就转入到钩子函数执行，如下：

return NF_HOOK(PF_INET, NF_IP_PRE_ROUTING, skb, dev, NULL,ip_rcv_finish); 再发送过程中，简单的介绍过钩子函数，这里就不再累述了。钩子函数最终会转到ip_rcv_finish()函数执行。接下来分析下看这个函数。 2）ip_rcv_finish()

到此，ip_rcv_finish函数真正要完成一些IP层的工作了。IP层要做的主要工作就是路由，要决定把数据包往那里送。路由的工作是通过函数ip_route_input()实现的。对于进来的包可能的路由有这些： 属于本地的数据(即是需要传递给TCP，UDP，IGMP这些上层协议的) ； 需要转发的数据包(网关或者NAT服务器之类的)； 不可能路由的数据包(地址信息有误)；具体所需要做的工作如下：

2.1)首先判断skb->dst是否等于NULL,也就是查看数据包中是否有目的地址。如果没有的话，该函数会调用ip_route_input()函数在内核的路由hash表中寻找一个目的地址，其主要代码如下：

int ip_route_input(struct sk_buff *skb, u32 daddr, u32 saddr, u8 tos, struct net_device *dev) {

struct rtable * rth; unsigned hash; int iif = dev->ifindex;

tos &= IPTOS_RT_MASK;

hash = rt_hash_code(daddr, saddr ^ (iif << 5), tos);//计算hash值

rcu_read_lock();

for (rth = rt_hash_table[hash].chain; rth; rth = rth->u.rt_next) //在相

//同的hash链表中搜索能满足条件的目的地址

{

smp_read_barrier_depends(); if (rth->fl.fl4_dst == daddr && rth->fl.fl4_src == saddr && rth->fl.iif == iif && rth->fl.oif == 0 && #ifdef CONFIG_IP_ROUTE_FWMARK

rth->fl.fl4_fwmark == skb->nfmark && #endif

rth->fl.fl4_tos == tos) {

rth->u.dst.lastuse = jiffies;

dst_hold(&rth->u.dst); rth->u.dst.__use++;

RT_CACHE_STAT_INC(in_hit); rcu_read_unlock(); skb->dst = (struct dst_entry*)rth;//找到之后赋予skb->dst return 0; } ? ? ? ?

return ip_route_input_slow(skb, daddr, saddr, tos, dev);

最后调用了ip_route_input_slow()函数，在这个函数中针对所传送过来的数据包类型分别进行了处理，我们这里要讨论的是本地数据包，也就是需要传送给TCP,UDP等这些协议的数据包。具体看这个子代码： local_input:

rth = dst_alloc(&ipv4_dst_ops); if (!rth)

goto e_nobufs;

rth->u.dst.output= ip_rt_bug;

atomic_set(&rth->u.dst.__refcnt, 1); rth->u.dst.flags= DST_HOST; if (in_dev->cnf.no_policy)

rth->u.dst.flags |= DST_NOPOLICY; rth->fl.fl4_dst = daddr; rth->rt_dst = daddr; rth->fl.fl4_tos = tos; #ifdef CONFIG_IP_ROUTE_FWMARK

rth->fl.fl4_fwmark= skb->nfmark; #endif

rth->fl.fl4_src = saddr; rth->rt_src = saddr; #ifdef CONFIG_IP_ROUTE_NAT

rth->rt_dst_map = fl.fl4_dst; rth->rt_src_map = fl.fl4_src; #endif

#ifdef CONFIG_NET_CLS_ROUTE

rth->u.dst.tclassid = itag; #endif

rth->rt_iif =

rth->fl.iif = dev->ifindex; rth->u.dst.dev = &loopback_dev; dev_hold(rth->u.dst.dev); rth->rt_gateway = daddr; rth->rt_spec_dst= spec_dst;

rth->u.dst.input= ip_local_deliver; rth->rt_flags = flags|RTCF_LOCAL; if (res.type == RTN_UNREACHABLE) { rth->u.dst.input= ip_error; rth->u.dst.error= -err;

rth->rt_flags &= ~RTCF_LOCAL; }

rth->rt_type = res.type; goto intern;

首先看第1句，rth = dst_alloc(&ipv4_dst_ops);该语句是为struct dst_entry数据结构分配一个空间，之后就是对该数据结构进行填充，这里需要注意的是rth->u.dst.input= ip_local_deliver;该行对后面将要讲解的dst->input函数进行了填充，就是具体由ip_local_deliver函数来处理。 接下来就看标记intern: intern:

err = rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);

rt_intern_hash（）主要是将rth加入到hash队列之中，之后将其赋给skb->dst,也就是在skb中添加了这样一个路由地址包了！

2.2)由于接下来要在skb数据包上添加一个ip_option的数据结构，所以skb就需要在头部重新添加一个头部空间来加载这些数据量，如下：

if (skb_cow(skb, skb_headroom(skb)))//拷贝一个skb头部信息 {

IP_INC_STATS_BH(IpInDiscards); goto drop; }

iph = skb->nh.iph;//重新获取数据包头 ? ? ?

if (ip_options_rcv_srr(skb))//添加ip_option数据 goto drop;

2.3）最后调用return dst_input(skb); 该函数的完整代码如下:

static inline int dst_input(struct sk_buff *skb) {

int err;

for (;;) {

err = skb->dst->input(skb);

if (likely(err == 0)) return err;

/* Oh, Jamal... Seems, I will not forgive you this mess. :-) */ if (unlikely(err != NET_XMIT_BYPASS)) return err; }

}

代码功能很简单，就是不断地调用skb->dst->input(skb)函数，这个函数其实就是和我们在发送过程的网络层中最后所讨论的那个函数skb->dst->output(skb)是对应的。就是将数据包传送到上一层：传输层.具体的过程如下：

由上面的讨论我们已经知道了，input函数实际上是由ip_local_deliver（）来处理，在这个函数中调用了钩子函数NF_HOOK,最后会转到一个名为ip_local_diliver_finish()的函数来处理，在这个函数中我们只需要注意以下两行： if ((ipprot = inet_protos[hash]) != NULL) { int ret; ? ? ? ?

ret = ipprot->handler(skb); 在这两行代码中，我们注意到有个inet_protos,这是一个承载协议类型的数据结构，在ipv4中是如下定义的：

static struct inet_protocol tcp_protocol = { .handler = tcp_v4_rcv, .err_handler = tcp_v4_err, .no_policy = 1, };

到此，我们明白了，接下来在传输层中首先要执行的函数是tcp_v4_rcv()。

Layer 4: 传输层(Transport Layer)

1) tcp_v4_rcv(skb) 该函数按如下步骤进行：

1.1) 获取tcp头数据结构，并且在skb->cb[]中添加数据包控制信息，如下：

th = skb->h.th;

TCP_SKB_CB(skb)->seq = ntohl(th->seq);

TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin + skb->len - th->doff * 4); TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq); TCP_SKB_CB(skb)->when = 0;

TCP_SKB_CB(skb)->flags = skb->nh.iph->tos; TCP_SKB_CB(skb)->sacked = 0; 以上的TCP_SKB_CB是获取skb->cb[]的宏。

1.2) 将skb中的源地址，目的地址，数据包指针都转存到一个sock的数据结构中，在

发送过程中讲过这个数据结构，它是沟通传输层和协议层之间的重要数据类型。 sk = __tcp_v4_lookup(skb->nh.iph->saddr, th->source,

skb->nh.iph->daddr, ntohs(th->dest), tcp_v4_iif(skb)); 1.4） 调用tcp_rcv_established

在该函数中会调用tcp_data_queue（），该函数主要是用来维护receive queue以及out_of_order_queue两个队列的。当用户空间正在等待内核的数据包时，内核就会调用如下函数将数据包从内核拷贝到用户空间skb_copy_datagram_iovec()，否则内核会将sk_buff挂载到socket的队列之中以等待用户需要时再进行拷贝。最后函数会调用

sk_data_ready()函数来标明数据可以获取，同时也唤醒等待数据包的用户进程。

Layer 5:应用层(Application Layer)

最后一层就是和用户直接接触的一层。当用户调用read,recvfrom,recvmsg时都会陷入内核最后都调用__sock_recvmsg。该函数首先进行权限检查，当是内核权限时，该函数会调用下层（即传输层）套接字所定义的虚拟函数recvmsg，而这个函数针对不同的协议会定义不同的处理函数，在TCP中就是tcp_recvmsg()。该函数也是使用skb_copy_datagram_iovec()函数从套接字队列中将数据拷贝到用户空间，或是使用sk_wait_data()等待内核空间数据包的到来，这样就返到了上层的1.4)最后所阐述的，就是当数据包到来时内核会使用sk_data_ready()函数来标明数据可以获得，同时启动等待队列。到此数据包的接收就算是圆满完成了！

本文来源：https://www.bwwdw.com/article/5cw5.html