linux tcp 包大小,Linux TCP数据包接收处理 --- 转

心已赠人 2023-01-20 11:57 226阅读 0赞

在接收流程一节中可以看到数据包在读取到用户空间前，都要经过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 <

ntohl(TCP\_FLAG\_ACK) |

snd\_wnd);

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

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

1Either 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\_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)

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

/\* eaten为1，表示数据直接copy到了用户空间，这时无需提醒用户进程数据的到达，否则需调用sk\_data\_ready来通知，因为此时数据到达了receive queue\*/

if (eaten)

\_\_kfree\_skb(skb);

else

sk->sk\_data\_ready(sk, 0);

return 0;

tcp\_event\_data\_recv函数

static void tcp\_event\_data\_recv(struct sock \*sk, struct sk\_buff \*skb)

struct tcp\_sock \*tp = tcp\_sk(sk);

struct inet\_connection\_sock \*icsk = inet\_csk(sk);

u32 now;

/\* 接收到了数据，设置ACK需调度标志\*/

inet\_csk\_schedule\_ack(sk);

tcp\_measure\_rcv\_mss(sk, skb);

tcp\_rcv\_rtt\_measure(tp);

now = tcp\_time\_stamp;

/\* 以下为根据接收间隔更新icsk\_ack.ato，该值主要用于判断pingpong模式见函数tcp\_event\_data\_sent \*/

if (!icsk->icsk\_ack.ato) \{

/\* The \_first\_ data packet received, initialize

\* delayed ACK engine.

\*/

tcp\_incr\_quickack(sk);

icsk->icsk\_ack.ato = TCP\_ATO\_MIN;

\} else \{

int m = now - icsk->icsk\_ack.lrcvtime;

if (m <= TCP\_ATO\_MIN / 2) \{

/\* The fastest case is the first. \*/

icsk->icsk\_ack.ato = (icsk->icsk\_ack.ato >> 1) + TCP\_ATO\_MIN / 2;

\} else if (m icsk\_ack.ato) \{

icsk->icsk\_ack.ato = (icsk->icsk\_ack.ato >> 1) + m;

if (icsk->icsk\_ack.ato > icsk->icsk\_rto)

icsk->icsk\_ack.ato = icsk->icsk\_rto;

\} else if (m > icsk->icsk\_rto) \{

/\* Too long gap. Apparently sender failed to

\* restart window, so that we send ACKs quickly.

\*/

tcp\_incr\_quickack(sk);

sk\_mem\_reclaim(sk);

icsk->icsk\_ack.lrcvtime = now;

TCP\_ECN\_check\_ce(tp, skb);

/\* 每次接收到来自对方的一个TCP数据报，且数据报长度大于128字节时，我们需要调用tcp\_grow\_window，增加rcv\_ssthresh的值，一般每次为rcv\_ssthresh增长两倍的mss，增加的条件是rcv\_ssthresh小于window\_clamp,并且 rcv\_ssthresh小于接收缓存剩余空间的3/4，同时tcp\_memory\_pressure没有被置位(即接收缓存中的数据量没有太大)。 tcp\_grow\_window中对新收到的skb的长度还有一些限制，并不总是增长rcv\_ssthresh的值\*/

if (skb->len >= 128)

tcp\_grow\_window(sk, skb);

rcv\_ssthresh是当前的接收窗口大小的一个阀值，其初始值就置为rcv\_wnd。它跟rcv\_wnd配合工作，

当本地socket收到数据报，并满足一定条件时，增长rcv\_ssthresh的值，在下一次发送数据报组建TCP首部时，

需要通告对方当前的接收窗口大小，这时需要更新rcv\_wnd，此时rcv\_wnd的取值不能超过rcv\_ssthresh的值。

两者配合，达到一个滑动窗口大小缓慢增长的效果。

\_\_tcp\_ack\_snd\_check用来判断ACK的发送方式

/\*

\* Check if sending an ack is needed.

\*/

static void \_\_tcp\_ack\_snd\_check(struct sock \*sk, int ofo\_possible)

struct tcp\_sock \*tp = tcp\_sk(sk);

/\* More than one full frame received... \*/

if (((tp->rcv\_nxt - tp->rcv\_wup) > inet\_csk(sk)->icsk\_ack.rcv\_mss

/\* ... and right edge of window advances far enough.

\* (tcp\_recvmsg() will send ACK otherwise). Or...

\*/

&& \_\_tcp\_select\_window(sk) >= tp->rcv\_wnd) ||

/\* We ACK each frame or... \*/

tcp\_in\_quickack\_mode(sk) ||

/\* We have out of order data. \*/

(ofo\_possible && skb\_peek(&tp->out\_of\_order\_queue))) \{

/\* Then ack it now \*/

tcp\_send\_ack(sk);

\} else \{

/\* Else, send delayed ack. \*/

tcp\_send\_delayed\_ack(sk);

注释很清楚，无需解释。

这里有个疑问，就是当ucopy应用读到需要读取到的数据包后，也即在一次处理中

if (tp->copied\_seq == tp->rcv\_nxt &&

len - tcp\_header\_len <= tp->ucopy.len) \{

的第二个条件的等号为真 len - tcp\_header\_len == tp->ucopy.len，然后执行流程到后面eaten为1，所以函数以释放skb结束，没有

调用sk\_data\_ready函数。假设这个处理调用流程如下：

tcp\_recvmsg-> sk\_wait\_data  -> sk\_wait\_event -> release\_sock -> \_\_release\_sock-> sk\_backlog\_rcv-> tcp\_rcv\_established

那么即使此时用户得到了所需的数据，但是在tcp\_rcv\_established返回前没有提示数据已得到，

\#define sk\_wait\_event(\_\_sk, \_\_timeo, \_\_condition)           /

(\{  int \_\_rc;                       /

release\_sock(\_\_sk);                 /

\_\_rc = \_\_condition;                 /

if (!\_\_rc) \{                        /

\*(\_\_timeo) = schedule\_timeout(\*(\_\_timeo));  /

\}                           /

lock\_sock(\_\_sk);                    /

\_\_rc = \_\_condition;                 /

\_\_rc;                           /

\})

但是在回到sk\_wait\_event后，由于\_\_condition为 !skb\_queue\_empty(&sk->sk\_receive\_queue)，所以还是会调用schedule\_timeout

来等待。这点显然是浪费时间，所以这个condition应该考虑下这个数据已经读满的情况，而不能光靠观察receive queue来判断是否等待。

接下来分析slow path

slow\_path:

if (len doff <

goto csum\_error;

/\*

\*  Standard slow path.

\*/

/\* 检查到达的数据包 \*/

res = tcp\_validate\_incoming(sk, skb, th, 1);

if (res <= 0)

return -res;

step5:  /\* 如果设置了ACK，则调用tcp\_ack处理，后面再分析该函数\*/

if (th->ack)

tcp\_ack(sk, skb, FLAG\_SLOWPATH);

tcp\_rcv\_rtt\_measure\_ts(sk, skb);

/\* Process urgent data. \*/

tcp\_urg(sk, skb, th);

/\* step 7: process the segment text \*/

tcp\_data\_queue(sk, skb);

tcp\_data\_snd\_check(sk);

tcp\_ack\_snd\_check(sk);

return 0;

先看看tcp\_validate\_incoming函数，在slow path处理前检查输入数据包的合法性。

/\* Does PAWS and seqno based validation of an incoming segment, flags will

\* play significant role here.

\*/

static int tcp\_validate\_incoming(struct sock \*sk, struct sk\_buff \*skb,

struct tcphdr \*th, int syn\_inerr)

struct tcp\_sock \*tp = tcp\_sk(sk);

/\* RFC1323: H1. Apply PAWS check first. \*/

if (tcp\_fast\_parse\_options(skb, th, tp) && tp->rx\_opt.saw\_tstamp &&

tcp\_paws\_discard(sk, skb)) \{

if (!th->rst) \{

NET\_INC\_STATS\_BH(sock\_net(sk), LINUX\_MIB\_PAWSESTABREJECTED);

tcp\_send\_dupack(sk, skb);

goto discard;

/\* Reset is accepted even if it did not pass PAWS. \*/

/\* Step 1: check sequence number \*/

if (!tcp\_sequence(tp, TCP\_SKB\_CB(skb)->seq, TCP\_SKB\_CB(skb)->end\_seq)) \{

/\* RFC793, page 37: "In all states except SYN-SENT, all reset

\* (RST) segments are validated by checking their SEQ-fields."

\* And page 69: "If an incoming segment is not acceptable,

\* an acknowledgment should be sent in reply (unless the RST

\* bit is set, if so drop the segment and return)".

\*/

if (!th->rst)

tcp\_send\_dupack(sk, skb);

goto discard;

/\* Step 2: check RST bit \*/

if (th->rst) \{

tcp\_reset(sk);

goto discard;

/\* ts\_recent update must be made after we are sure that the packet

\* is in window.

\*/

tcp\_replace\_ts\_recent(tp, TCP\_SKB\_CB(skb)->seq);

/\* step 3: check security and precedence \[ignored\] \*/

/\* step 4: Check for a SYN in window. \*/

if (th->syn && !before(TCP\_SKB\_CB(skb)->seq, tp->rcv\_nxt)) \{

if (syn\_inerr)

TCP\_INC\_STATS\_BH(sock\_net(sk), TCP\_MIB\_INERRS);

NET\_INC\_STATS\_BH(sock\_net(sk), LINUX\_MIB\_TCPABORTONSYN);

tcp\_reset(sk);

return -1;

return 1;

discard:

\_\_kfree\_skb(skb);

return 0;

第一步：检查PAWS tcp\_paws\_discard

static inline int tcp\_paws\_discard(const struct sock \*sk,

const struct sk\_buff \*skb)

const struct tcp\_sock \*tp = tcp\_sk(sk);

return ((s32)(tp->rx\_opt.ts\_recent - tp->rx\_opt.rcv\_tsval) > TCP\_PAWS\_WINDOW &&

get\_seconds() rx\_opt.ts\_recent\_stamp + TCP\_PAWS\_24DAYS &&

!tcp\_disordered\_ack(sk, skb));

PAWS丢弃数据包要满足以下条件

1 The difference between the timestamp value obtained in the current segmentand last seen timestamp on

the incoming TCP segment should be more than TCP\_PAWS\_WINDOW (= 1), which means that if the segment that was

transmitted 1 clock tick before the segment that reached here earlier TCP seq should be acceptable.

It may be because of reordering of the segments that the latter reached earlier.

2 the 24 days have not elapsed since last time timestamp was stored,

3 tcp\_disordered\_ack返回0.

在实际进行PAWS预防时，Linux是通过如下代码调用来完成的

tcp\_rcv\_established

|-->tcp\_paws\_discard

|-->tcp\_disordered\_ack

其中关键是local方通过tcp\_disordered\_ack函数对一个刚收到的数据分段进行判断，下面我们对该函数的判断逻辑进行下总结：

大前提：该收到分段的TS值表明有回绕现象发生

a)若该分段不是一个纯ACK，则丢弃。因为显然这个分段所携带的数据是一个老数据了，不是local方目前希望接收的(参见PAWS的处理依据一节)

b)若该分段不是local所希望接收的，则丢弃。这个原因很显然

c)若该分段是一个纯ACK，但该ACK并不是一个重复ACK(由local方后续数据正确到达所引发的)，则丢弃。因为显然该ACK是一个老的ACK，并不是由于为了加快local方重发而在每收到一个丢失分段后的分段而发出的ACK。

d)若该分段是一个ACK，且为重复ACK，并且该ACK的TS值超过了local方那个丢失分段后的重发rto，则丢弃。因为显然此时local方已经重发了那个导致此重复ACK产生的分段，因此再收到此重复ACK就可以直接丢弃。

e)若该分段是一个ACK，且为重复ACK，但是没有超过一个rto的时间，则不能丢弃，因为这正代表peer方收到了local方发出的丢失分段后的分段，local方要对此ACK进行处理(例如立刻重传)

这里有一个重要概念需要理解，即在出现TS问题后，纯ACK和带ACK的数据分段二者是显著不同的，对于后者，可以立刻丢弃掉，因为从一个窗口的某个seq到下一个窗口的同一个seq过程中，一定有窗口变化曾经发生过，从而TS记录值ts\_recent也一定更新过，此时一定可以通过PAWS进行丢弃处理。但是对于前者，一个纯ACK，就不能简单丢弃了，因为有这样一个现象是合理的，即假定local方的接收缓存很大，并且peer方在发送时很快就回绕了，于是在local方的某个分段丢失后，peer方需要在每收到的后续分段时发送重复ACK，而此时该重发ACK的ack\_seq就是这个丢失分段的序号，而该重发ACK的seq已经是回绕后的重复序号了，尽管此时到底是回绕后的那个重复ACK还是之前的那个同样序号seq的重复ACK，对于local方来都需要处理(立刻启动重发动作)，而不能简单丢弃掉。

第2步 检查数据包的序号是否正确，该判断失败后调用tcp\_send\_dupack发送一个duplicate acknowledge(未设置RST标志位时)。

static inline int tcp\_sequence(struct tcp\_sock \*tp, u32 seq, u32 end\_seq)

return  !before(end\_seq, tp->rcv\_wup) &&

!after(seq, tp->rcv\_nxt + tcp\_receive\_window(tp));

由rcv\_wup的更新时机(发送ACK时的tcp\_select\_window)可知位于序号rcv\_wup前面的数据都已确认，所以待检查数据包的结束序号至少

要大于该值；同时开始序号要落在接收窗口内。

第3步 如果设置了RST，则调用tcp\_reset处理

第4步 更新ts\_recent，

第5步 检查SYN，因为重发的SYN和原来的SYN之间不会发送数据，所以这2个SYN的序号是相同的，如果不满足则reset连接。

接下来重点分析tcp\_data\_queue函数，这里就是对数据包的处理了。

static void tcp\_data\_queue(struct sock \*sk, struct sk\_buff \*skb)

struct tcphdr \*th = tcp\_hdr(skb);

struct tcp\_sock \*tp = tcp\_sk(sk);

int eaten = -1;

/\* 没有数据处理\*/

if (TCP\_SKB\_CB(skb)->seq == TCP\_SKB\_CB(skb)->end\_seq)

goto drop;

/\* 跳过tcp头部\*/

\_\_skb\_pull(skb, th->doff \* 4);

/\* 如果收到对方发来的CWR，则本地TCP发送时不在设置ECE\*/

TCP\_ECN\_accept\_cwr(tp, skb);

/\* 初始化Duplicate SACK\*/

if (tp->rx\_opt.dsack) \{

tp->rx\_opt.dsack = 0;

tp->rx\_opt.eff\_sacks = tp->rx\_opt.num\_sacks;

如果该数据包刚好是下一个要接收的数据，则可以直接copy到用户空间(如果存在且可用)，否则排队到receive queue

/\*  Queue data for delivery to the user.

\*  Packets in sequence go to the receive queue.

\*  Out of sequence packets to the out\_of\_order\_queue.

\*/

if (TCP\_SKB\_CB(skb)->seq == tp->rcv\_nxt) \{

if (tcp\_receive\_window(tp) == 0)

goto out\_of\_window;

/\* Ok. In sequence. In window. \*/

if (tp->ucopy.task == current &&

tp->copied\_seq == tp->rcv\_nxt && tp->ucopy.len &&

sock\_owned\_by\_user(sk) && !tp->urg\_data) \{

int chunk = min\_t(unsigned int, skb->len,

tp->ucopy.len);

\_\_set\_current\_state(TASK\_RUNNING);

/\* 这里的下半部开关的作用不解\*/

local\_bh\_enable();

if (!skb\_copy\_datagram\_iovec(skb, 0, tp->ucopy.iov, chunk)) \{

tp->ucopy.len -= chunk;

tp->copied\_seq += chunk;

eaten = (chunk == skb->len && !th->fin);

tcp\_rcv\_space\_adjust(sk);

local\_bh\_disable();

if (eaten <= 0) \{

ueue\_and\_out:

if (eaten

/\* 该函数用于判断是否有接收缓存，在tcp内存管理中将分析\*/

tcp\_try\_rmem\_schedule(sk, skb->truesize))

goto drop;

skb\_set\_owner\_r(skb, sk);

\_\_skb\_queue\_tail(&sk->sk\_receive\_queue, skb);

tp->rcv\_nxt = TCP\_SKB\_CB(skb)->end\_seq;

if (skb->len)

tcp\_event\_data\_recv(sk, skb);

if (th->fin)

tcp\_fin(skb, sk, th);

/\* 到达的数据包哟可能填充了乱序队列中的hole \*/

if (!skb\_queue\_empty(&tp->out\_of\_order\_queue)) \{

tcp\_ofo\_queue(sk);

/\* RFC2581. 4.2. SHOULD send immediate ACK, when

\* gap in queue is filled.

\*/

/\*关闭乒乓模式，在quick计数没消耗完时则可立即发送ACK，见tcp\_in\_quickack\_mode\*/

if (skb\_queue\_empty(&tp->out\_of\_order\_queue))

inet\_csk(sk)->icsk\_ack.pingpong = 0;

/\* 新数据到达导致返回给对方的SACK Block 调整\*/

if (tp->rx\_opt.num\_sacks)

tcp\_sack\_remove(tp);

/\* 在当前slow path，检测是否可以进入fast path\*/

tcp\_fast\_path\_check(sk);

if (eaten > 0)

\_\_kfree\_skb(skb);

else if (!sock\_flag(sk, SOCK\_DEAD))

sk->sk\_data\_ready(sk, 0);

return;

下面看看函数tcp\_ofo\_queue，也即out-of-order queue的处理

/\* This one checks to see if we can put data from the

\* out\_of\_order queue into the receive\_queue.

\*/

static void tcp\_ofo\_queue(struct sock \*sk)

struct tcp\_sock \*tp = tcp\_sk(sk);

\_\_u32 dsack\_high = tp->rcv\_nxt;

struct sk\_buff \*skb;

while ((skb = skb\_peek(&tp->out\_of\_order\_queue)) != NULL) \{

/\* 当前hole未覆盖，则处理结束\*/

if (after(TCP\_SKB\_CB(skb)->seq, tp->rcv\_nxt))

break;

/\* DSACK处理\*/

if (before(TCP\_SKB\_CB(skb)->seq, dsack\_high)) \{

\_\_u32 dsack = dsack\_high;

if (before(TCP\_SKB\_CB(skb)->end\_seq, dsack\_high))

dsack\_high = TCP\_SKB\_CB(skb)->end\_seq;

tcp\_dsack\_extend(sk, TCP\_SKB\_CB(skb)->seq, dsack);

/\* 该乱序数据包完全被到达的数据包覆盖，则从乱序队列中删除之，并释放该数据包\*/

if (!after(TCP\_SKB\_CB(skb)->end\_seq, tp->rcv\_nxt)) \{

SOCK\_DEBUG(sk, "ofo packet was already received /n");

\_\_skb\_unlink(skb, &tp->out\_of\_order\_queue);

\_\_kfree\_skb(skb);

continue;

SOCK\_DEBUG(sk, "ofo requeuing : rcv\_next %X seq %X - %X/n",

tp->rcv\_nxt, TCP\_SKB\_CB(skb)->seq,

TCP\_SKB\_CB(skb)->end\_seq);

/\* hole被填充，取出该乱序数据包到receive queue中排队，并更新rcv\_nxt \*/

\_\_skb\_unlink(skb, &tp->out\_of\_order\_queue);

\_\_skb\_queue\_tail(&sk->sk\_receive\_queue, skb);

tp->rcv\_nxt = TCP\_SKB\_CB(skb)->end\_seq;

if (tcp\_hdr(skb)->fin)

tcp\_fin(skb, sk, tcp\_hdr(skb));

这里DSACK的处理中为什么即使dsack比end\_seq大，还是用dsack作为右边界呢？

/\* 该数据包的数据已经完全存在，则发送DSACK，并进入快速ACK模式，调度ACK发送\*/

if (!after(TCP\_SKB\_CB(skb)->end\_seq, tp->rcv\_nxt)) \{

/\* A retransmit, 2nd most common case.  Force an immediate ack. \*/

NET\_INC\_STATS\_BH(sock\_net(sk), LINUX\_MIB\_DELAYEDACKLOST);

tcp\_dsack\_set(sk, TCP\_SKB\_CB(skb)->seq, TCP\_SKB\_CB(skb)->end\_seq);

out\_of\_window:

tcp\_enter\_quickack\_mode(sk);

inet\_csk\_schedule\_ack(sk);

drop:

\_\_kfree\_skb(skb);

return;

/\* Out of window. F.e. zero window probe. \*/

if (!before(TCP\_SKB\_CB(skb)->seq, tp->rcv\_nxt + tcp\_receive\_window(tp)))

goto out\_of\_window;

tcp\_enter\_quickack\_mode(sk);

/\* 部分数据已存在，则设置正确的DSACK，然后排队到receive queue\*/

if (before(TCP\_SKB\_CB(skb)->seq, tp->rcv\_nxt)) \{

/\* Partial packet, seq

SOCK\_DEBUG(sk, "partial packet: rcv\_next %X seq %X - %X/n",

tp->rcv\_nxt, TCP\_SKB\_CB(skb)->seq,

TCP\_SKB\_CB(skb)->end\_seq);

tcp\_dsack\_set(sk, TCP\_SKB\_CB(skb)->seq, tp->rcv\_nxt);

/\* If window is closed, drop tail of packet. But after

\* remembering D-SACK for its head made in previous line.

\*/

if (!tcp\_receive\_window(tp))

goto out\_of\_window;

goto queue\_and\_out;

TCP\_ECN\_check\_ce(tp, skb); /\* 检查ECE是否设置 \*/

/\* 以下则把数据包排队到失序队列 \*/

/\* 同样先判断内存是否满足 \*/

if (tcp\_try\_rmem\_schedule(sk, skb->truesize))

goto drop;

/\* Disable header prediction. \*/

tp->pred\_flags = 0;

inet\_csk\_schedule\_ack(sk);

SOCK\_DEBUG(sk, "out of order segment: rcv\_next %X seq %X - %X/n",

tp->rcv\_nxt, TCP\_SKB\_CB(skb)->seq, TCP\_SKB\_CB(skb)->end\_seq);

skb\_set\_owner\_r(skb, sk);

/\* 该数据包是失序队列的第一个数据包\*/

if (!skb\_peek(&tp->out\_of\_order\_queue)) \{

/\* Initial out of order segment, build 1 SACK. \*/

if (tcp\_is\_sack(tp)) \{

tp->rx\_opt.num\_sacks = 1;

tp->rx\_opt.dsack     = 0;

tp->rx\_opt.eff\_sacks = 1;

tp->selective\_acks\[0\].start\_seq = TCP\_SKB\_CB(skb)->seq;

tp->selective\_acks\[0\].end\_seq =

TCP\_SKB\_CB(skb)->end\_seq;

\_\_skb\_queue\_head(&tp->out\_of\_order\_queue, skb);

\} else \{

struct sk\_buff \*skb1 = tp->out\_of\_order\_queue.prev;

u32 seq = TCP\_SKB\_CB(skb)->seq;

u32 end\_seq = TCP\_SKB\_CB(skb)->end\_seq;

/\*刚好与失序队列最后一个数据包数据衔接\*/

if (seq == TCP\_SKB\_CB(skb1)->end\_seq) \{

\_\_skb\_queue\_after(&tp->out\_of\_order\_queue, skb1, skb);

/\*如果没有sack block或者当前数据包开始序号不等于第一个block右边界\*/

if (!tp->rx\_opt.num\_sacks ||

tp->selective\_acks\[0\].end\_seq != seq)

goto add\_sack;

/\*该数据包在某个hole后是按序到达的，所以可以直接扩展第一个sack\*/

/\* Common case: data arrive in order after hole. \*/

tp->selective\_acks\[0\].end\_seq = end\_seq;

return;

/\* Find place to insert this segment. \*/

/\* 该循环找到一个开始序号不大于该数据包开始序号的失序队列中的数据包\*/

do \{

if (!after(TCP\_SKB\_CB(skb1)->seq, seq))

break;

\} while ((skb1 = skb1->prev) !=

(struct sk\_buff \*)&tp->out\_of\_order\_queue);

/\* Do skb overlap to previous one? 检查与前个数据包是否有重叠\*/

if (skb1 != (struct sk\_buff \*)&tp->out\_of\_order\_queue &&

before(seq, TCP\_SKB\_CB(skb1)->end\_seq)) \{

if (!after(end\_seq, TCP\_SKB\_CB(skb1)->end\_seq)) \{

/\* All the bits are present. Drop. \*/

\_\_kfree\_skb(skb);

tcp\_dsack\_set(sk, seq, end\_seq);

goto add\_sack;

if (after(seq, TCP\_SKB\_CB(skb1)->seq)) \{

/\* Partial overlap. \*/

tcp\_dsack\_set(sk, seq,

TCP\_SKB\_CB(skb1)->end\_seq);

\} else \{

skb1 = skb1->prev;

/\* 排队到失序队列\*/

\_\_skb\_queue\_after(&tp->out\_of\_order\_queue, skb1, skb);

/\* And clean segments covered by new one as whole. 检测与后面的数据包重叠\*/

while ((skb1 = skb->next) !=

(struct sk\_buff \*)&tp->out\_of\_order\_queue &&

after(end\_seq, TCP\_SKB\_CB(skb1)->seq)) \{

if (before(end\_seq, TCP\_SKB\_CB(skb1)->end\_seq)) \{

tcp\_dsack\_extend(sk, TCP\_SKB\_CB(skb1)->seq,

end\_seq);

break;

\_\_skb\_unlink(skb1, &tp->out\_of\_order\_queue);

tcp\_dsack\_extend(sk, TCP\_SKB\_CB(skb1)->seq,

TCP\_SKB\_CB(skb1)->end\_seq);

\_\_kfree\_skb(skb1);

add\_sack:

if (tcp\_is\_sack(tp))

/\* 根据失序队列的现状更新SACK的blocks \*/

tcp\_sack\_new\_ofo\_skb(sk, seq, end\_seq);

@import url(http://www.cppblog.com/cutesoft\_client/cuteeditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css);

posted on 2013-02-18 14:23 大龙 阅读(6481) 评论(0)  编辑 收藏 引用

linux tcp 包大小,Linux TCP数据包接收处理 --- 转

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 linux tcp 包大小,Linux TCP数据包接收处理 --- 转

相关 Linux 内核网络协议栈 ------ tcp重传数据包 tcp_retransmit_skb 函数

相关 Linux 内核网络协议栈 ------ tcp重传数据包 tcp_xmit_retransmit_skb

相关 Linux 内核网络协议栈 ------ tcp_ack 函数处理接收到的ACK包之后

相关过滤并转发TCP数据包

相关 TCP/IP数据包结构详解

相关 wireshark分析TCP数据包

相关 tcp/ip数据包分析

相关 TCP、UDP数据包大小的限制

相关 LWIP之TCP层接收相关 tcp_recv的实现（转）