Linux - 一个网络数据包的完整流转过程

2022年04月10日 11:03:31    [原创]

一个网络数据表从网卡进入系统后，到底是在系统内部各个子系统之间如何流转，直到最终被应用程序处理并从网卡返回的，本文将详细探究流转的每一个环节，以便我们更深入的理解Linux网络协议栈的工作原理。

目录

  • 1. 第一阶段：网卡接收数据包
  • 2. 第二阶段：包在内核各个模块中的流转
  • 3. 第三阶段：应用层收包
  • 4. 第四阶段：数据包的发送
  • 5. 整体流转图

    • 第一阶段：网卡接收数据包

    1：通过DMA把数据包从网卡拷贝到内存的Ring buffer缓冲区中，Ring buffer这里不再详细展开，它是网卡暂存和处理数据包的一种通用数据结构，分为RX Ring和TX Ring。

    2：网卡触发硬中断通知CPU收包

    3：CPU调用网卡驱动注册的硬中断处理函数

    1. 记录一下硬件中断频率
    2. 将驱动napi_struct传过来的poll_list添加到CPU变量softnet_data里的poll_list中 //主要实现驱动程序将其poll函数注册到cpu的softnet_data
    3. 调用网卡驱动注册的硬中断处理函数

    4：硬中断处理函数向内核软中断线程ksoftirqd发出NET_RX_SOFTIRQ软中断请求

    5：ksoftirqd执行软中断处理函数net_rx_action()

    6：net_rx_action()调用驱动注册的poll函数从Ring buffer开始轮询收包


    第二阶段：包在内核各个模块中的流转

    内核各个模块中的流转图

    1：poll收包函数从Ring buffer取出数据并封装为sk_buff结构，并传递到net_device子系统层处理，sk_buff是个很重要的结构，内核通过sk_buff结构在各层协议层之间传递数据。

    <p data-track="14"igb_fetch_rx_buffer和igb_is_non_eop函数</p>
    • 这里会设置sk_buff的timestamp,
    • 进行一些关于VLAN的处理, 比如VLAN id
    • 设置protocol等字段

    2：传递到netif_receive_skb函数进行处理，tcpdump抓包流程就是在这个函数中，netif_receive_skb根据协议类型（ip or arp）传递到不同的上层处理函数

    报文从设备层送到上层之前，必须区分是 IP 报文还是 ARP 报文， 然后才能往上层送。去 packet_type{} 查该包网络层使用的是哪种协议，查到和数据包协议类型相匹配的协议后，就调用对应的处理函数，如IP协议对应的处理函数是ip_rcv。

    3：ip_rcv()是ip层的入口函数，会先进行一些简单的ip层处理，比如检验ip数据包的完整性等

    4：ip_rcv函数随后调用NF_HOOK函数宏将控制权交给在netfilter模块的PREROUTING，进行PREROUTING链的相关规则处理

    5：随后调用ip_rcv_finish函数进行相关的处理，该函数最重要的流程就是ROUTING路由处理，通过查找路由表，根据路由表信息判断目的ip是：

    1. 发往本机处理址（根据是否匹配到目标ip对应的local路由条目来判断）
    2. 还是进行转发（如果内核开启了允许转发选项）或者drop处理（非本机处理也不允许转发）

    6：如果是本机处理，则调用 ip_local_deliver() 函数发送到上层协议进行处理，如果收到的是ip分片，则会在 ip_local_deliver() 中对ip分片进行重组后再传递到上层

    7：随后经过netfilter模块的INPUT链规则处理后传递到上层进行处理

    8：这里会根据协议类型决定调用不同的收包函数，比如tcp or udp or icmp，tcp的收包函数就是tcp_v4_rcv，udp和icmp分别是udp_rcv和icmp_rcv


    第三阶段：应用层收包

    fd、socket、sock关系和应用层收包流程图

    1：握手阶段，数据包会被存储在backlog队列的request_sock结构中，backlog是一个半连接队列用于存储还未完成tcp3次握手的连接，request_sock是一个临时存储tcp连接信息的sock结构。

    如果内核开启syn cookies的情况下，当backlog半连接队列存满之后连接信息经过处理后会被存储到seq序列号中再由客户端回包的时候传递回来。

    2：完成握手的连接则会被存储在监听套接字的全连接队列中，并从request_sock临时结构转为完整的sock结构，等待应用进程accept函数处理，应用进程调用accept函数后，就会创建一个新的tcp连接，包括创建socket结构体，file结构体，并把file、socket、sock结构关联起来，通过fd文件描述符返回给应用程序，这样一个完整的连接才算建立了，并把socket信息以源、目的ip和源、目的端口为key加入到一个哈希表中，用于后续的查找。

    这里延伸一下，fd和socket以及sock之间的关系：

    fd：文件描述符，对应一个file结构体，在内核中一个打开的文件用file结构体表示

    socket：分为监听socket和连接socket，这里的socket是连接socket，主要用于关联fd和sock结构，它是应用层程序和内核协议栈的一个接口。

    sock：实际表示网络连接的结构，和socket结构一一对应，tcp连接对应的sock结构是tcp_sock，由sock结构体通过sock->inet_sock->inet_connection_sock->tcp_sock链封装而来。sock结构体中有包含各种接收队列，如：sk_receive_queue。

    TCP数据接收流程

    3：TCP数据接收流程

    这里有3个队列：

    sk_receive_queue：正常接收队列。

    prequeue：预存放队列，如果prequeue未满且未开启tcp_low_latency，则新到的包先放入该队列。

    backlog：后备存储队列，如果socket被用户锁定则新到的包都放入该队列。

    3.1：tcp_v4_rcv是tcp层的入口

    3.2：首先判断当前socket是否被用户进程锁定，进程正在读取socket接收队列数据的时候会先锁定给队列。

    if (!sock_owned_by_user(sk)) {
  ret = tcp_v4_do_rcv(sk, skb);
} else if (tcp_add_backlog(sk, skb)) {
  goto discard_and_relse;
}

    如上述代码可以看到如果被用户锁定则走到tcp_add_backlog方法，也就是把数据存储到该socket的backlog后备队列中，如果没被锁定则直接调用tcp_v4_do_rcv进行下一步的处理，存储到backlog队列中的包并没有被tcp层实际处理，包括各种校验，回复ack等。

    3.3：如果没有锁定则继续走到tcp_prequeue函数中，判断是否启用了tcp_low_latency低延迟功能，默认为0不启用，如果tcp_low_latency为0且prequeue未满则先放入prequeue队列中。prequeue队列的作用主要是为了加速软中断的处理，因为tcp_v4_rcv还是在软中断上下文中，这里放入prequeue中可以加快软中断上下文的处理流程，丢到prequeue中后等后续在用户进程上下文去出处理，软中断能快速结束。prequeue队列中的数据和backlog队列一样，都没经过tcp层各种校验，回复ack等处理。

    3.4：如果无法加入到prequeue队列，则调用tcp_v4_do_rcv继续处理，处理完成后放入sk_receive_queue正常接收队列中。

    3.5：数据到达sk_receive_queue队列后，接着就会调用数据就绪函数回调指针sk_data_ready，这个函数指针在初始化的时候指向了sock_def_readble函数。

    在sock_def_readable函数中会去获取socket->sock->sk_wq等待队列。在wake_up_common函数中从等待队列sk_wq中找出一个等待项wait_queue_t，回调注册在该等待项上的func回调函数（wait_queue_t->func），epoll机制中，这里的回调函数是ep_poll_callback。

    sk_data_ready会检测接收队列上是否有可读事件，如果有可读事件则会唤醒socket等待队列上的用户进程（如果是epoll机制，则这里是epoll注册的等待队列项而不是用户进程），通知应用程序来收包。

    backlog数据处理时机：

    backlog中的数据什么时候被处理呢？socket队列的锁被用户进程释放的时候，会调用tcp_v4_do_rcv处理backlog队列的数据并转入sk_receive_queue队列中。

    prequeue数据处理时机：

    prequeue中的数据什么时候被处理呢？1：当用户进程在sk_receive_queue中没有数据可处理的时候，会去继续处理prequeue中的数据，这里直接在用户进程上下文中直接处理，不再转入sk_receive_queue队列中；2：如果进程阻塞在socket队列上，当prequeue队列变得可读后也会唤醒用户进程去prequeue读取数据。

    但需要注意：prequeue机制在较新的内核版本（v4.14以上版本）中已经被移除。

    4：TCP相关socket队列

    socket相关队列

    sk_receive_queue：正常接收数据的队列

    sk_backlog：后备存储队列，如果socket被用户锁定则新到的包都放入该队列。

    prequeue：预存放队列，如果prequeue未满且未开启tcp_low_latency，则新到的包先放入该队列。

    out_of_order_queue：乱序队列，如果序列号接不上，则暂时放入 out_of_order_queue 队列，等序列号能够接上的时候，再放入 sk_receive_queue 队列。

    sk_write_queue：发送数据的队列

    sk_error_queue：错误队列，挂接一些 pengding 的 error 信息


    第四阶段：数据包的发送


    sendfile零拷贝数据流转图

    ip层数据包发送流转图

    数据包的发送整体流转图


    数据拷贝方式：

    1. 普通方式是：数据先从内核缓冲区 -> 拷贝到用户态缓冲区，然后从用户态缓冲区 -> 再拷贝到内核socket缓冲区
    2. sendfile方式：也就是零拷贝，数据直接从内核缓冲区 -> 发送到socket缓冲区，如果网卡支持scatter-gather，则只拷贝fd到socket缓冲区，数据则直接从内核缓冲区拷贝到网卡缓冲区。

    1：tcp层处理

    通过 tcp_sendmsg->tcp_write_xmit->tcp_transmit_skb->ip_queue_xmit 调用链发送数据包，

    tcp_sendmsg：是发送数据包的入口

    1. 申请并封装sk_buff结构
    2. 更新skb的TCP控制块字段，把sk_buff加入到sock发送队列的尾部，增加发送队列的大小，减小预分配缓存的大小
    3. 如果是零拷贝方式，则进行零拷贝相关处理
    4. 将发送队列中的sk_buff发送出去

    2：ip层处理

    通过 ip_queue_xmit->__ip_local_out->NF_INET_LOCAL_OUT->dst_output->ip_output->NF_INET_POST_ROUTING->ip_finish_output->ip_finish_output2->dst_neigh_output->neigh_resolve_output 调用链进行ip层的处理

    int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
{
    struct sock *sk = skb->sk;
    struct inet_sock *inet = inet_sk(sk);
    struct ip_options *opt = inet->opt;
    struct rtable *rt;
    struct iphdr *iph;
    /*……*/
    /* Make sure we can route this packet. */
rt = (struct rtable )__sk_dst_check(sk, 0); /*取出sk中缓存的“路由缓存”*/
   if (rt == NULL) { /*如果没有缓存“路由缓存”，则要查找路由缓存*/
        __be32 daddr;
        daddr = inet->daddr;
        {
            struct flowi fl = { .oif = sk->sk_bound_dev_if,
                        .mark = sk->sk_mark,
                        .nl_u = { .ip4_u =
                              { .daddr = daddr,
                            .saddr = inet->saddr,
                            .tos = RT_CONN_FLAGS(sk) } },
                        .proto = sk->sk_protocol,
                        .flags = inet_sk_flowi_flags(sk),
                        .uli_u = { .ports =
                               { .sport = inet->sport,
                             .dport = inet->dport } } };
            if (ip_route_output_flow(sock_net(sk), &rt, &fl, sk, 0))
                goto no_route;
        }
        sk_setup_caps(sk, &rt->u.dst);
    }
skb_dst_set(skb, dst_clone(&rt->u.dst));
packet_routed:
    /* OK, we know where to send it, allocate and build IP header. */
    /*这里省略了根据查找出得路由缓存设置ip头部字段，包括源、目的地址、ttl、是否允许分片等标示*/
    return ip_local_out(skb);
}

    1. ip_queue_xmit： IP模块发送数据包的入口，会读取sk中缓存的“路由缓存”，根据查找出得路由缓存设置ip头部字段，包括源、目的地址、ttl、是否允许分片等。如果没有路由缓存，则调用ip_route_output_flow查找路由表。

    如果该socket没有绑定源IP，该函数会根据路由表找到一个最合适的源IP给它。 如果该socket已经绑定了源IP，但根据路由表，从这个源IP对应的网卡没法到达目的地址，则该包会被丢弃，于是数据发送失败

    2. ip_route_output_flow：这个函数是用来查找路由缓存的（注意不是查找路由表的，只有路由缓存查找不命中时才会查找路由表，路由缓存表在内核中用struct rtable结构体来表示），如果路由缓存没有查找到，则调用ip_route_output_slow查找路由表。

    3. ip_route_output_slow：如果找到路由后则会调用ip_mkroute_output根据路由表的查找结果构建一个路由缓存项，这样下次向同一个目的地址发送就可以直接查路由缓存了（其实对于TCP连路由缓存也不需要查，因为会将路由缓存存入sock结构，当然这个缓存有过期时间）。

    4. arp_bind_neighbour：负责为路由缓存项创建邻居项，查找并创建下一跳ip对应的邻居表项，将下一跳的邻居表项和目的地址的路由缓存绑定。如果没找到邻居表项缓存，则会创建（这里仅仅是创建邻居表项，并不填充对应的mac地址）下一跳ip对应的邻居表项，并加入邻居表项hash表。

    5. __ip_local_out： 设置IP报文头的长度和checksum，然后调用下面netfilter的钩子

    6. NF_INET_LOCAL_OUT： netfilter的钩子，可以通过iptables来配置怎么处理该数据包，如果该数据包没被丢弃，则继续往下走

    7. dst_output： 该函数根据skb里面的信息，调用相应的output函数，对于单播数据报，会调用ip_output

    8. ip_output： 将上面tcp_sendmsg得到的网卡信息写入skb，然后调用NF_INET_POST_ROUTING的钩子

    9. NF_INET_POST_ROUTING： 在这里，用户有可能配置了SNAT，从而导致该skb的路由信息发生变化

    10：ip_finish_output： 此函数主要功能是：如果数据包大于MTU，则调用ip_fragment进行分片，否则调用ip_finish_output2输出，其实ip_fragment分片后也会调用ip_finish_output2。这里会判断经过了上一步后，路由信息是否发生变化，如果发生变化的话，需要重新调用dst_output（重新调用这个函数时，可能就不会再走到ip_output，而是走到被netfilter指定的output函数里，这里有可能是xfrm4_transport_output），否则往下走

    11. ip_finish_output2： 根据目的IP到路由表里面找到下一跳(nexthop)的地址，然后调用__ipv4_neigh_lookup_noref去arp表里面找下一跳的neigh信息，没找到的话会调用__neigh_create构造一个空的neigh结构体

    12. dst_neigh_output： 在该函数中，如果上一步ip_finish_output2没得到neigh信息，那么将会走到函数neigh_resolve_output中，否则直接调用neigh_hh_output，在该函数中，会将neigh信息里面的mac地址填到skb中，然后调用dev_queue_xmit发送数据包

    13. neigh_resolve_output： 该函数里面会发送arp请求，得到下一跳的mac地址，然后将mac地址填到skb中并调用dev_queue_xmit

    3：net_device子系统层处理

    通过 dev_queue_xmit->Traffic Control->dev_hard_start_xmit->ndo_start_xmit调用链进行netdevice子系统层处理。

    1: dev_queue_xmit：net_device子系统的入口函数，在该函数中，会先获取设备对应的qdisc，如果没有的话（如loopback或者IP tunnels），就直接调用dev_hard_start_xmit，否则数据包将经过Traffic Control模块进行处

    2: Traffic Control：这里主要是流量控制模块，进行一些过滤、优先级处理，在这里，如果队列满了的话，数据包会被丢掉，这步完成后也会走到dev_hard_start_xmit

    3: dev_hard_start_xmit：该函数中，首先是拷贝一份skb给“packet taps”，tcpdump就是从这里得到数据的，然后调用ndo_start_xmit。如果dev_hard_start_xmit返回错误的话（大部分情况可能是NETDEV_TX_BUSY），调用它的函数会把skb放到一个地方，然后抛出软中断NET_TX_SOFTIRQ，交给软中断处理程序net_tx_action稍后重试（如果是loopback或者IP tunnels的话，失败后不会有重试的逻辑）

    4: ndo_start_xmit：这是一个函数指针，会指向具体驱动发送数据的函数

    4：网卡驱动层处理

    ndo_start_xmit会绑定到具体网卡驱动的相应函数，到这步之后，就归网卡驱动管了，不同的网卡驱动有不同的处理方式，这里不做详细介绍，其大概流程如下：

    1. 将skb放入网卡自己的发送队列
    2. 通知网卡发送数据包
    3. 网卡发送完成后发送中断给CPU
    4. 收到中断后进行skb的清理工作

    在网卡驱动发送数据包过程中，会有一些地方需要和netdevice子系统打交道，比如网卡的队列满了，需要告诉上层不要再发了，等队列有空闲的时候，再通知上层接着发数据。


    整体流转图：