Linux TCP数据包接收流程

   TCP接收方存在3种队列：

1 Backlog Queue (sk->backlog)

2 Prequeue Queue (tp->ucopy.prequeue)

3 Receive Queue (sk->receive_queue)

 

然后来看3个队列的区别。

首先sk_backlog队列是当当前的sock在进程上下文中被使用时，如果这个时候有数据到来，则将数据拷贝到sk_backlog.

prequeue则是数据buffer第一站,一般都是这里，如果prequeue已满，则会拷贝数据到receive_queue队列种。

最后一个receive_queue也就是进程上下文第一个取buffer的队列

这里为什么要有prequeue呢,直接放到receive_queue不就好了.因为receive_queue的处理比较繁琐

(看tcp_rcv_established的实现就知道了,分为slow path和fast path),而软中断每次只能处理一个数据包

(在一个cpu上),因此为了软中断能尽快完成,我们就可以先将数据放到prequeue中(tcp_prequeue),然后软

中断就直接返回. 而处理prequeue就放到进程上下文(tcp_recvmsg调用中)去处理了.

最后在分析tcp_v4_rcv和tcp_recvmsg之前，我们要知道tcp_v4_rcv还是处于软中断上下文，

而tcp_recvmsg是处于进程上下文，因此比如socket_lock_t才会提供一个owned来锁住对应的sock。

而我们也就是需要这3个队列来进行软中断上下文和进程上下文之间的通信。最终当数据拷贝到对应队列，

则软中断调用返回。这里要注意的是相同的函数在软中断上下文和进程上下文种调用是不同的，我们下面就会看到(比如tcp_rcv_established函数) 。

首先数据包进入软中断上下文的tcp_v4_rcv函数

int tcp_v4_rcv(struct sk_buff *skb) { const struct iphdr *iph; struct tcphdr *th; struct sock *sk; int ret; struct net *net = dev_net(skb->dev); if (skb->pkt_type != PACKET_HOST) goto discard_it; /* Count it even if it's bad */ TCP_INC_STATS_BH(net, TCP_MIB_INSEGS); if (!pskb_may_pull(skb, sizeof(struct tcphdr))) goto discard_it; /* 。。。。。。*/ bh_lock_sock_nested(sk); ret = 0; if (!sock_owned_by_user(sk)) { #ifdef CONFIG_NET_DMA struct tcp_sock *tp = tcp_sk(sk); if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list) tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY); if (tp->ucopy.dma_chan) ret = tcp_v4_do_rcv(sk, skb); else #endif { if (!tcp_prequeue(sk, skb)) ret = tcp_v4_do_rcv(sk, skb); } } else sk_add_backlog(sk, skb); bh_unlock_sock(sk); sock_put(sk); return ret;

 

该函数的处理过程是：

首先bh_lock_sock_nested调用加自旋锁

然后判断当前sock是否被用户进程占用（sock_owned_by_user函数判断）。如果没有的话，就调用tcp_prequeue将数据包加入

prequeue队列中；否则调用sk_add_backlog将它加入backlog队列中。

 

tcp_prequeue调用流程如下

static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb) { struct tcp_sock *tp = tcp_sk(sk); if (!sysctl_tcp_low_latency && tp->ucopy.task) { __skb_queue_tail(&tp->ucopy.prequeue, skb); tp->ucopy.memory += skb->truesize; if (tp->ucopy.memory > sk->sk_rcvbuf) { struct sk_buff *skb1; BUG_ON(sock_owned_by_user(sk)); while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) { sk_backlog_rcv(sk, skb1); NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPPREQUEUEDROPPED); } tp->ucopy.memory = 0; } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) { wake_up_interruptible(sk->sk_sleep); if (!inet_csk_ack_scheduled(sk)) inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, (3 * TCP_RTO_MIN) / 4, TCP_RTO_MAX); } return 1; } return 0; }

 

该函数的本意是将数据包加入prequeue队列，以待tcp_recvmsg函数调用（通过函数tcp_prequeue_process），这时就返回0；

如果ucopy.task为NULL的话，表示当前没有pending的进程，函数返回1，数据包在软中断（函数tcp_v4_do_rcv）中处理。

还有一种情况是prequeue已满，则在软中断上下文中处理该队列中的所有数据包（函数 sk_backlog_rcv）。

最后，如果发现该skb使得prequeue从空变为非空，则调用wake_up_interruptible(sk->sk_sleep)唤醒在该sock上的等待进程

（该进程在tcp_recvmsg函数中通过sk_wait_data调用进入该sock的等待队列）。

 

不管是软中断中的数据包处理还是系统调用中的数据包的处理，都是调用tcp_v4_do_rcv。在连接建立后，该函数的作用是处理数据包，

数据包加入receive queue中。

 

先分析数据包如何接收到用户进程的——tcp_recvmsg函数。

 /* * This routine copies from a sock struct into the user buffer. * * Technical note: in 2.3 we work on _locked_ socket, so that * tricks with *seq access order and skb->users are not required. * Probably, code can be easily improved even more. */ int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, size_t len, int nonblock, int flags, int *addr_len) { struct tcp_sock *tp = tcp_sk(sk); int copied = 0; u32 peek_seq; u32 *seq; unsigned long used; int err; int target; /* Read at least this many bytes */ long timeo; struct task_struct *user_recv = NULL; int copied_early = 0; struct sk_buff *skb; u32 urg_hole = 0; /* 需要强调的是这里的锁操作只是把sk->sk_lock.owned置为1，表示当前sock上有用户进程 而没有对其spinlock加锁，所以软中断可以把数据包加入backlog中，但此时软中断不能对prequeue和receive queue 操作*/ lock_sock(sk); TCP_CHECK_TIMER(sk); err = -ENOTCONN; if (sk->sk_state == TCP_LISTEN) goto out; timeo = sock_rcvtimeo(sk, nonblock); /* Urgent data needs to be handled specially. */ if (flags & MSG_OOB) goto recv_urg; /* copied_seq表示下一被应用程序读取的序号,当设置了MSG_PEEK时，seq指针指向一个自动变量，其含义在于当读取后，下次读取任然从原有的位置开始 */ seq = &tp->copied_seq; if (flags & MSG_PEEK) { peek_seq = tp->copied_seq; seq = &peek_seq; } /* 如果设置了MSG_WAITALL，则读取数据直到指定长度len */ target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);

 

下一步从receive queue中读取数据包

do { u32 offset; /* Are we at urgent data? Stop if we have read anything or have SIGURG pending. */ if (tp->urg_data && tp->urg_seq == *seq) { if (copied) break; if (signal_pending(current)) { copied = timeo ? sock_intr_errno(timeo) : -EAGAIN; break; } } /* Next get a buffer. */ /* 从receive queue 中找到可用的数据包 */ skb = skb_peek(&sk->sk_receive_queue); do { if (!skb) break; /* Now that we have two receive queues this * shouldn't happen. */ /* 存在hole，不可能发生*/ if (before(*seq, TCP_SKB_CB(skb)->seq)) { printk(KERN_INFO "recvmsg bug: copied %X " "seq %X/n", *seq, TCP_SKB_CB(skb)->seq); break; } /* offset不为0，表示数据有重叠 */ offset = *seq - TCP_SKB_CB(skb)->seq; /* SYN占用一个序号 */ if (tcp_hdr(skb)->syn) offset--; /* 当前skb有数据可读 */ if (offset < skb->len) goto found_ok_skb; if (tcp_hdr(skb)->fin) goto found_fin_ok; WARN_ON(!(flags & MSG_PEEK)); skb = skb->next; } while (skb != (struct sk_buff *)&sk->sk_receive_queue);

receive queue的特征是

(1) already acked
(2) guaranteed in order
(3) contain no holes but
(4) apparently may contain overlapping data（数据可能重叠）

 

当receive queue没有可用数据或已经读取完后，进入下面流程

/* Well, if we have backlog, try to process it now yet. */ /* copied表示已经读取的数据量，target表示最少读取量，如果copied大于target并且backlog队列为空，则接收过程结束*/ if (copied >= target && !sk->sk_backlog.tail) break; /* 下面是出错以及信号处理*/ if (copied) { if (sk->sk_err || sk->sk_state == TCP_CLOSE || (sk->sk_shutdown & RCV_SHUTDOWN) || !timeo || signal_pending(current)) break; } else { if (sock_flag(sk, SOCK_DONE)) break; if (sk->sk_err) { copied = sock_error(sk); break; } if (sk->sk_shutdown & RCV_SHUTDOWN) break; if (sk->sk_state == TCP_CLOSE) { if (!sock_flag(sk, SOCK_DONE)) { /* This occurs when user tries to read * from never connected socket. */ copied = -ENOTCONN; break; } break; } if (!timeo) { copied = -EAGAIN; break; } if (signal_pending(current)) { copied = sock_intr_errno(timeo); break; } }

接下来程序调用函数

tcp_cleanup_rbuf(sk, copied);

该函数的主要作用是发送一个通告窗口更新的ACK，因为用户进程消费了读缓存中的数据。

 

流程到此的条件是：

● the receive queue is empty, 
● no serious errors or state changes were noted and
● we haven't consumed sufficient data to return to the caller.

/* 第一次到来时，task和user_recv都为NULL，所以装载该进程为sock的当前任务*/ if (!sysctl_tcp_low_latency && tp->ucopy.task == user_recv) { /* Install new reader */ if (!user_recv && !(flags & (MSG_TRUNC | MSG_PEEK))) { user_recv = current; tp->ucopy.task = user_recv; tp->ucopy.iov = msg->msg_iov; } tp->ucopy.len = len; WARN_ON(tp->copied_seq != tp->rcv_nxt && !(flags & (MSG_PEEK | MSG_TRUNC))); /* Ugly... If prequeue is not empty, we have to * process it before releasing socket, otherwise * order will be broken at second iteration. * More elegant solution is required!!! * * Look: we have the following (pseudo)queues: * * 1. packets in flight * 2. backlog * 3. prequeue * 4. receive_queue * * Each queue can be processed only if the next ones * are empty. At this point we have empty receive_queue. * But prequeue _can_ be not empty after 2nd iteration, * when we jumped to start of loop because backlog * processing added something to receive_queue. * We cannot release_sock(), because backlog contains * packets arrived _after_ prequeued ones. * * Shortly, algorithm is clear --- to process all * the queues in order. We could make it more directly, * requeueing packets from backlog to prequeue, if * is not empty. It is more elegant, but eats cycles, * unfortunately. */ /* prequeue不为空，先处理 */ if (!skb_queue_empty(&tp->ucopy.prequeue)) goto do_prequeue; /* __ Set realtime policy in scheduler __ */ } if (copied >= target) { /* 读取了足够的数据，但是backlog中还有数据，所以调用release_sock来处理该 队列中的数据包（tcp_v4_do_recv函数）*/ /* Do not sleep, just process backlog. */ release_sock(sk); lock_sock(sk); } else /* 数据读取未完成，也不确定backlog中是否有数据，所以需要一个等待的操作*/ sk_wait_data(sk, &timeo);

 

分析sk_wait_data函数

int sk_wait_data(struct sock *sk, long *timeo) { int rc; DEFINE_WAIT(wait); /* 加入等待队列，该等待队列当有数据包进入prequeue或receive queue时唤醒*/ prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue)); clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); finish_wait(sk->sk_sleep, &wait); return rc; } #define sk_wait_event(__sk, __timeo, __condition) / ({ int __rc; /* 解锁时可能会处理backlog中数据包，如果有的话，__rc就为1，无需等待 ；没有可处理的话，就置used成员为0，这样软中断可以接收数据到prequeue队列中，重而唤醒本进程 */ / release_sock(__sk); / __rc = __condition; / if (!__rc) { / *(__timeo) = schedule_timeout(*(__timeo)); / } / lock_sock(__sk); / __rc = __condition; / __rc; / })

 

if (user_recv) { int chunk; /* ucopy.len初始值为len，但在tcp_rcv_established中会减小，减少量为copy到用户进程中的数据大小*/ /* __ Restore normal policy in scheduler __ */ if ((chunk = len - tp->ucopy.len) != 0) { NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMBACKLOG, chunk); len -= chunk; copied += chunk; } /* 确保数据有序*/ if (tp->rcv_nxt == tp->copied_seq && !skb_queue_empty(&tp->ucopy.prequeue)) { do_prequeue: /* 调用 tcp_v4_do_rcv处理prequeue中skb */ tcp_prequeue_process(sk); if ((chunk = len - tp->ucopy.len) != 0) { NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk); len -= chunk; copied += chunk; } } } if ((flags & MSG_PEEK) && (peek_seq - copied - urg_hole != tp->copied_seq)) { if (net_ratelimit()) printk(KERN_DEBUG "TCP(%s:%d): Application bug, race in MSG_PEEK./n", current->comm, task_pid_nr(current)); peek_seq = tp->copied_seq; } /* 开始下一次循环，接下来的是receive queue中skb的数据读取，所以不进入 */ continue;

 

接下来的是receive queue中skb的数据读取

found_ok_skb: /* Ok so how much can we use? */ used = skb->len - offset; if (len < used) used = len; /* Do we have urgent data here? */ if (tp->urg_data) { u32 urg_offset = tp->urg_seq - *seq; if (urg_offset < used) { if (!urg_offset) { if (!sock_flag(sk, SOCK_URGINLINE)) { ++*seq; urg_hole++; offset++; used--; if (!used) goto skip_copy; } } else used = urg_offset; } } if (!(flags & MSG_TRUNC)) { #ifdef CONFIG_NET_DMA #endif { err = skb_copy_datagram_iovec(skb, offset, msg->msg_iov, used); if (err) { /* Exception. Bailout! */ if (!copied) copied = -EFAULT; break; } } } *seq += used; copied += used; len -= used; /* 调整TCP接收缓存空间 */ tcp_rcv_space_adjust(sk); skip_copy: if (tp->urg_data && after(tp->copied_seq, tp->urg_seq)) { tp->urg_data = 0; tcp_fast_path_check(sk); } if (used + offset < skb->len) continue; if (tcp_hdr(skb)->fin) goto found_fin_ok; if (!(flags & MSG_PEEK)) { sk_eat_skb(sk, skb, copied_early); copied_early = 0; } continue; found_fin_ok: /* Process the FIN. */ ++*seq; if (!(flags & MSG_PEEK)) { sk_eat_skb(sk, skb, copied_early); copied_early = 0; } break; } while (len > 0);

 

最后在跳出循环后，prequeue队列又一次被处理（因为其中可能还有数据，可以读取到本进程中）

if (user_recv) { if (!skb_queue_empty(&tp->ucopy.prequeue)) { int chunk; tp->ucopy.len = copied > 0 ? len : 0; tcp_prequeue_process(sk); if (copied > 0 && (chunk = len - tp->ucopy.len) != 0) { NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk); len -= chunk; copied += chunk; } } /* 处理完后task复位为NULL， 表示当前sock没有进程占用 */ tp->ucopy.task = NULL; tp->ucopy.len = 0; }

 

数据包处理函数将在后面分析