TCP输入 之 tcp_prequeue

在未开启tcp_low_latency的情况下，软中断将skb送上来，加入到prequeue中，然后

在未启用tcp_low_latency且有用户进程在读取数据的情况下，skb入队到prequeue，入队之后，若达到队列长度上限或者内存上限，则将队列中的skb出队，调用tcp_v4_do_rcv处理，若入队skb为队列的第一个skb，则需要唤醒进程，通知可读事件，并设置延迟ack定时器；

 bool tcp_prequeue(struct sock *sk, struct sk_buff *skb)
 {
     struct tcp_sock *tp = tcp_sk(sk);

     /* 启用了latency || 没有进程读取数据 */
     if (sysctl_tcp_low_latency || !tp->ucopy.task)
         return false;

     /* 长度<= tcp头部长度，无数据&& prequeue队列长度为0，空队列 */
     /* 队列为空，无数据skb不入队，
        有数据或者之前队列中有skb，则入队，防止乱序??
     */
     if (skb->len <= tcp_hdrlen(skb) &&
         skb_queue_len(&tp->ucopy.prequeue) == )
         return false;

     /* Before escaping RCU protected region, we need to take care of skb
      * dst. Prequeue is only enabled for established sockets.
      * For such sockets, we might need the skb dst only to set sk->sk_rx_dst
      * Instead of doing full sk_rx_dst validity here, let's perform
      * an optimistic check.
      */
     /* 释放skb路由缓存 */
     if (likely(sk->sk_rx_dst))
         skb_dst_drop(skb);
     else
         skb_dst_force_safe(skb);

     /* 加入队列尾部 */
     __skb_queue_tail(&tp->ucopy.prequeue, skb);
     /* 内存增加 */
     tp->ucopy.memory += skb->truesize;

     /* 队列长度>=32 || 内存消耗> rcvbuf */
     if (skb_queue_len(&tp->ucopy.prequeue) >=  ||
         tp->ucopy.memory + atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf) {
         struct sk_buff *skb1;

         BUG_ON(sock_owned_by_user(sk));
         __NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPPREQUEUEDROPPED,
                 skb_queue_len(&tp->ucopy.prequeue));

         /* skb出队，调用tcp_v4_do_rcv处理 */
         while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
             sk_backlog_rcv(sk, skb1);

         /* 重置消耗内存 */
         tp->ucopy.memory = ;
     }
     /* 空队列新增的第一个skb */
     else if (skb_queue_len(&tp->ucopy.prequeue) == ) {
         /* 唤醒进程可读 */
         wake_up_interruptible_sync_poll(sk_sleep(sk),
                        POLLIN | POLLRDNORM | POLLRDBAND);
         /* 没有ack要发送，则设置延迟ack定时器 */
         if (!inet_csk_ack_scheduled(sk))
             inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
                           ( * tcp_rto_min(sk)) / ,
                           TCP_RTO_MAX);
     }
     return true;
 }

上面函数中的tp->ucopy.task是在tcp_recvmsg中设置的，简要截取一部分代码，后续补充该函数的详细分析；

 int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
         int flags, int *addr_len)
 {
        do {
             if (!sysctl_tcp_low_latency && tp->ucopy.task == user_recv) {
             /* Install new reader */
             if (!user_recv && !(flags & (MSG_TRUNC | MSG_PEEK))) {
                 user_recv = current;
                                 /* 设置task */
                 tp->ucopy.task = user_recv;
                 tp->ucopy.msg = msg;
             }
           } while (len > );

         /*...*/

     if (user_recv) {
         if (!skb_queue_empty(&tp->ucopy.prequeue)) {
             int chunk;

             tp->ucopy.len = copied >  ? len : ;

             tcp_prequeue_process(sk);

             if (copied >  && (chunk = len - tp->ucopy.len) != ) {
                 NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);
                 len -= chunk;
                 copied += chunk;
             }
         }
                 /* 清除task */
         tp->ucopy.task = NULL;
         tp->ucopy.len = ;
     }
 }