Linux TCP数据包接收处理

在接收流程一节中可以看到数据包在读取到用户空间前，都要经过tcp_v4_do_rcv处理，从而在receive queue中排队。

在该函数中，我们只分析当连接已经建立后的数据包处理流程，也即tcp_rcv_established函数。

 

tcp_rcv_established函数的工作原理是把数据包的处理分为2类：fast path和slow path，其含义显而易见。这样分类

的目的当然是加快数据包的处理，因为在正常情况下，数据包是按顺序到达的，网络状况也是稳定的，这时可以按照fast path

直接把数据包存放到receive queue了。而在其他的情况下则需要走slow path流程了。

 

在协议栈中，是用头部预测来实现的，每个tcp sock有个pred_flags成员，它就是判别的依据。

static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd) { tp->pred_flags = htonl((tp->tcp_header_len << 26) | ntohl(TCP_FLAG_ACK) | snd_wnd); }

可以看出头部预测依赖的是头部长度字段和通告窗口。也就是说标志位除了ACK和PSH外，如果其他的存在的话，就不能用

fast path处理，其揭示的含义如下：

1 Either the data transaction is taking place in only one direction (which means that we are the receiver

and not transmitting any data) or in the case where we are sending out data also, the window advertised

 from the other end is constant. The latter means that we have not transmitted any data from our side for

quite some time but are receiving data from the other end. The receive window advertised by the other end is constant.

 

2. Other than PSH|ACK flags in the TCP header, no other flag is set (ACK is set for each TCP segment). 

This means that if any other flag is set such as URG, FIN, SYN, ECN, RST, and CWR, we
know that something important is there to be attended and we need to move into the SLOW path.

 

3. The header length has unchanged. If the TCP header length remains unchanged,
we have not added/reduced any TCP option and we can safely assume that
there is nothing important to be attended, if the above two conditions are TRUE.

 

fast path工作的条件

static inline void tcp_fast_path_check(struct sock *sk) { struct tcp_sock *tp = tcp_sk(sk); if (skb_queue_empty(&tp->out_of_order_queue) && tp->rcv_wnd && atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf && !tp->urg_data) tcp_fast_path_on(tp); }

 

1 没有乱序数据包

2 接收窗口不为0

3 还有接收缓存空间

4 没有紧急数据

 

反之，则进入slow path处理；另外当连接新建立时处于slow path。

 

从fast path进入slow path的触发条件（进入slow path 后pred_flags清除为0）：

1 在tcp_data_queue中接收到乱序数据包

2 在tcp_prune_queue中用完缓存并且开始丢弃数据包

3 在tcp_urgent_check中遇到紧急指针

4 在tcp_select_window中发送的通告窗口下降到0.

 

从slow_path进入fast_path的触发条件：

1 When we have read past an urgent byte in tcp_recvmsg() . Wehave gotten an urgent byte and we remain

  in the slow path mode until we receive the urgent byte because it is handled in the slow path in
  tcp_rcv_established() .

2 当在tcp_data_queue中乱序队列由于gap被填充而处理完毕时，运行tcp_fast_path_check。

3 tcp_ack_update_window()中更新了通告窗口。

 

fast path处理流程

A 判断能否进入fast path

if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags && TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {​

TCP_HP_BITS的作用就是排除flag中的PSH标志位。只有在头部预测满足并且数据包以正确的顺序（该数据包的第一个序号就是下个要接收

的序号）到达时才进入fast path。

int tcp_header_len = tp->tcp_header_len; /* Timestamp header prediction: tcp_header_len * is automatically equal to th->doff*4 due to pred_flags * match. */ /* Check timestamp */ if (tcp_header_len == sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) { /* No? Slow path! */ if (!tcp_parse_aligned_timestamp(tp, th)) goto slow_path; /* If PAWS failed, check it more carefully in slow path */ if ((s32)(tp->rx_opt.rcv_tsval - tp->rx_opt.ts_recent) < 0) goto slow_path; /* DO NOT update ts_recent here, if checksum fails * and timestamp was corrupted part, it will result * in a hung connection since we will drop all * future packets due to the PAWS test. */ }

该代码段是依据时戳选项来检查PAWS（Protect Against Wrapped Sequence numbers）。

 

如果发送来的仅是一个TCP头的话（没有捎带数据或者接收端检测到有乱序数据这些情况时都会发送一个纯粹的ACK包）

/* Bulk data transfer: sender */ if (len == tcp_header_len) { /* Predicted packet is in window by definition. * seq == rcv_nxt and rcv_wup <= rcv_nxt. * Hence, check seq<=rcv_wup reduces to: */ if (tcp_header_len == (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) && tp->rcv_nxt == tp->rcv_wup) tcp_store_ts_recent(tp); /* We know that such packets are checksummed * on entry. */ tcp_ack(sk, skb, 0); __kfree_skb(skb); tcp_data_snd_check(sk); return 0; } else { /* Header too small */ TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS); goto discard; }

主要的工作如下：

1 保存对方的最近时戳 tcp_store_ts_recent。通过前面的if判断可以看出tcp总是回显2次时戳回显直接最先到达的数据包的时戳，

  rcv_wup只在发送数据（这时回显时戳）时重置为rcv_nxt，所以接收到前一次回显后第一个数据包后，rcv_nxt增加了，但是

  rcv_wup没有更新，所以后面的数据包处理时不会调用该函数来保存时戳。

2 ACK处理。这个函数非常复杂，包含了拥塞控制机制，确认处理等等。

3 检查是否有数据待发送 tcp_data_snd_check。

 

如果该数据包中包含了数据的话

} else { int eaten = 0; int copied_early = 0; /* 此数据包刚好是下一个读取的数据，并且用户空间可存放下该数据包*/ if (tp->copied_seq == tp->rcv_nxt && len - tcp_header_len <= tp->ucopy.len) { #ifdef CONFIG_NET_DMA if (tcp_dma_try_early_copy(sk, skb, tcp_header_len)) { copied_early = 1; eaten = 1; } #endif /* 如果该函数在进程上下文中调用并且sock被用户占用的话*/ if (tp->ucopy.task == current && sock_owned_by_user(sk) && !copied_early) { /* 进程有可能被设置为TASK_INTERRUPTIBLE */ __set_current_state(TASK_RUNNING); /* 直接copy数据到用户空间*/ if (!tcp_copy_to_iovec(sk, skb, tcp_header_len)) eaten = 1; } if (eaten) { /* Predicted packet is in window by definition. * seq == rcv_nxt and rcv_wup <= rcv_nxt. * Hence, check seq<=rcv_wup reduces to: */ if (tcp_header_len == (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) && tp->rcv_nxt == tp->rcv_wup) tcp_store_ts_recent(tp); /* 更新RCV RTT，Dynamic Right-Sizing算法*/ tcp_rcv_rtt_measure_ts(sk, skb); __skb_pull(skb, tcp_header_len); tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq; NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPHPHITSTOUSER); } if (copied_early) tcp_cleanup_rbuf(sk, skb->len); } if (!eaten) { /* 没有直接读到用户空间*/ if (tcp_checksum_complete_user(sk, skb)) goto csum_error; /* Predicted packet is in window by definition. * seq == rcv_nxt and rcv_wup <= rcv_nxt. * Hence, check seq<=rcv_wup reduces to: */ if (tcp_header_len == (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) && tp->rcv_nxt == tp->rcv_wup) tcp_store_ts_recent(tp); tcp_rcv_rtt_measure_ts(sk, skb); if ((int)skb->truesize > sk->sk_forward_alloc) goto step5; NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPHPHITS); /* Bulk data transfer: receiver */ __skb_pull(skb, tcp_header_len); /* 进入receive queue 排队，以待tcp_recvmsg读取*/ __skb_queue_tail(&sk->sk_receive_queue, skb); skb_set_owner_r(skb, sk); tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq; } /* 数据包接收后续处理*/ tcp_event_data_recv(sk, skb); /* ACK 处理*/ if (TCP_SKB_CB(skb)->ack_seq != tp->snd_una) { /* Well, only one small jumplet in fast path... */ tcp_ack(sk, skb, FLAG_DATA); tcp_data_snd_check(sk); if (!inet_csk_ack_scheduled(sk)) goto no_ack; } /* ACK发送处理*/ if (!copied_early || tp->rcv_nxt != tp->rcv_wup) __tcp_ack_snd_check(sk, 0); no_ack: #ifdef CONFIG_NET_DMA if (copied_early) __skb_queue_tail(&sk->sk_async_wait_queue, skb); else #endif