内核tcp协议栈SACK的处理

最新推荐文章于 2024-04-10 17:07:24 发布
最新推荐文章于 2024-04-10 17:07:24 发布
阅读量1.6k 收藏
点赞数
分类专栏： 操作系统 linux内核 TCP/IP
linux内核 同时被 3 个专栏收录
44 篇文章 0 订阅
订阅专栏
操作系统
42 篇文章 1 订阅
订阅专栏
TCP/IP
21 篇文章 0 订阅
订阅专栏
上一篇处理ack的blog中我们知道当我们接收到ack的时候，我们会判断sack段，如果包含sack段的话，我们就要进行处理。这篇blog就主要来介绍内核如何处理sack段。 

SACK是包含在tcp的option中的，由于tcp的头的长度的限制，因此SACK也就是最多包含4个段，也就是32个字节。我们先来看tcp中的SACK段的表示： 

Java代码   收藏代码
  1. struct tcp_sack_block {  
  2. //起始序列号  
  3.     u32 start_seq;  
  4. //结束序列号  
  5.     u32 end_seq;  
  6. };  


可以看到很简单，就是一个段的起始序列号和一个结束序列号。 

前一篇blog我们知道tcp_skb_cb的sacked域也就是sack option的偏移值，而在tcp的option它的组成是由3部分组成的，第一部分为option类型，第二部分为当前option的长度，第三部分才是数据段，因此我们如果要取得SACK的段，就必须这样计算。 

这里ack_skb也就是我们要处理的skbuffer。 
Java代码   收藏代码
  1. //首先得到sack option的起始指针。  
  2. unsigned char *ptr = (skb_transport_header(ack_skb) +  
  3.                   TCP_SKB_CB(ack_skb)->sacked);  
  4. //加2的意思也就是加上类型和长度，这里刚好是2个字节。最终结果也就是sack option的数据段。  
  5.     struct tcp_sack_block_wire *sp_wire = (struct tcp_sack_block_wire *)(ptr+2);  


这里很奇怪，内核还有一个tcp_sack_block_wire类型的结构，它和tcp_sack_block是完全一样的。 

而我们如果要得到当前的SACK段的个数我们要这样做: 

Java代码   收藏代码
  1. #define TCPOLEN_SACK_BASE       2  
  2. int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3);  


这里ptr1也就是sack option的长度(字节数),而TCPOLEN_SACK_BASE为类型和长度字段的长度，因此这两个值的差也就是sack段的总长度，而这里每个段都是8个字节，因此我们右移3位就得到了它的个数，最后sack的段的长度不能大于4,因此我们要取一个最小值。 

上面的结构下面这张图非常清晰的展示了，这几个域的关系： 



然后我们来看SACK的处理，在内核中SACK的处理是通过tcp_sacktag_write_queue来实现的，这个函数比较长，因此这里我们分段来看。 

先来看函数的原型 

Java代码   收藏代码
  1. static int  
  2. tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb,  
  3.             u32 prior_snd_una)  


第一个参数是当前的sock，第二个参数是要处理的skb，第三个参数是接受ack的时候的snd_una. 



在看之前这里有几个重要的域要再要说明下。 

1  tcp socket的sacked_out域，这个域保存了所有被sack的段的个数。 

2 还有一个就是tcp_sacktag_state结构，这个结构保存了当前skb的一些信息。 

Java代码   收藏代码
  1. struct tcp_sacktag_state {  
  2.     int reord;  
  3.     int fack_count;  
  4.     int flag;  
  5. };  


3 tcp socket的highest_sack域，这个域也就是被sack确认的最大序列号的skb。 


先来看第一部分，这部分的代码主要功能是初始化一些用到的值，比如sack的指针，当前有多少sack段等等，以及一些合法性校验。 

Java代码   收藏代码
  1. //sack段的最大个数  
  2. #define TCP_NUM_SACKS 4  
  3. .....................................................................................................  
  4.         const struct inet_connection_sock *icsk = inet_csk(sk);  
  5.     struct tcp_sock *tp = tcp_sk(sk);  
  6. ///下面两句代码，前面已经分析过了，也就是取得sack的指针以及sack 数据段的指针。  
  7.     unsigned char *ptr = (skb_transport_header(ack_skb) +  
  8.                   TCP_SKB_CB(ack_skb)->sacked);  
  9.     struct tcp_sack_block_wire *sp_wire = (struct tcp_sack_block_wire *)(ptr+2);  
  10. //这个数组最终会用来保存所有的SACK段。  
  11.     struct tcp_sack_block sp[TCP_NUM_SACKS];  
  12.     struct tcp_sack_block *cache;  
  13.     struct tcp_sacktag_state state;  
  14.     struct sk_buff *skb;  
  15. //这里得到当前的sack段的个数，这段代码前面也介绍过了。  
  16.     int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3);  
  17.     int used_sacks;  
  18. ///重复的sack的个数。  
  19.     int found_dup_sack = 0;  
  20.     int i, j;  
  21.     int first_sack_index;  
  22.   
  23.     state.flag = 0;  
  24.     state.reord = tp->packets_out;  
  25. //如果sack的个数为0,则我们要更新相关的域。  
  26.     if (!tp->sacked_out) {  
  27.         if (WARN_ON(tp->fackets_out))  
  28.             tp->fackets_out = 0;  
  29. ///这个函数主要更新highest_sack域。  
  30.         tcp_highest_sack_reset(sk);  
  31.     }  
  32.   
  33. //开始检测是否有重复的sack。这个函数紧接着会详细分析。  
  34.     found_dup_sack = tcp_check_dsack(sk, ack_skb, sp_wire,  
  35.                      num_sacks, prior_snd_una);  
  36. //如果有发现，则设置flag。  
  37.     if (found_dup_sack)  
  38.         state.flag |= FLAG_DSACKING_ACK;  
  39.   
  40. ///再次判断ack的序列号是否太老。  
  41.     if (before(TCP_SKB_CB(ack_skb)->ack_seq, prior_snd_una - tp->max_window))  
  42.         return 0;  
  43. //如果packets_out为0,则说明我们没有发送还没有确认的段，此时进入out，也就是错误处理。  
  44.     if (!tp->packets_out)  
  45.         goto out;  


在看接下来的部分之前我们先来看tcp_highest_sack_reset和tcp_check_dsack函数，先是tcp_highest_sack_reset函数。 

Java代码   收藏代码
  1. static inline void tcp_highest_sack_reset(struct sock *sk)  
  2. {  
  3. //设置highest_sack为写队列的头。  
  4.     tcp_sk(sk)->highest_sack = tcp_write_queue_head(sk);  
  5. }  


这里原因很简单，因为当sacked_out为0,则说明没有通过sack确认的段，此时highest_sack自然就指向写队列的头。 

第二个是tcp_check_dsack函数，这个函数比较复杂，他主要是为了检测D-SACK,也就是重复的sack。 

有关dsack的概念可以去看RFC 2883和3708. 

我这里简要的提一下dsack的功能，D-SACK的功能主要是使接受者能够通过sack的块来报道接收到的重复的段，从而使发送者更好的进行拥塞控制。 


这里D-SACK的判断是通过RFC2883中所描述的进行的。如果是下面两种情况，则说明收到了一个D-SACK。 

1 如果SACK的第一个段所ack的区域被当前skb的ack所确认的段覆盖了一部分，则说明我们收到了一个d-sack,而代码中也就是sack第一个段的起始序列号小于snd_una。下面的图描述了这种情况： 


 

2 如果sack的第二个段完全包含了第二个段，则说明我们收到了重复的sack，下面这张图描述了这种关系。 

 


最后要注意的是，这里收到D-SACK后，我们需要打开当前sock d-sack的option。并设置dsack的flag。 

然后我们还需要判断dsack的数据是否已经被ack完全确认过了，如果确认过了，我们就需要更新undo_retrans域，这个域表示重传的数据段的个数。 

来看代码： 

Java代码   收藏代码
  1. static int tcp_check_dsack(struct sock *sk, struct sk_buff *ack_skb,  
  2.                struct tcp_sack_block_wire *sp, int num_sacks,  
  3.                u32 prior_snd_una)  
  4. {  
  5.     struct tcp_sock *tp = tcp_sk(sk);  
  6. //首先取得sack的第一个段的起始和结束序列号  
  7.     u32 start_seq_0 = get_unaligned_be32(&sp[0].start_seq);  
  8.     u32 end_seq_0 = get_unaligned_be32(&sp[0].end_seq);  
  9.     int dup_sack = 0;  
  10.   
  11. ///判断D-sack,首先判断第一个条件，也就是起始序列号小于ack的序列号  
  12.     if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {  
  13. //设置dsack标记。  
  14.         dup_sack = 1;  
  15. ///这里更新tcp的option的sack_ok域。  
  16.         tcp_dsack_seen(tp);  
  17.         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPDSACKRECV);  
  18.     } else if (num_sacks > 1) {  
  19. //然后执行第二个判断，取得第二个段的起始和结束序列号。  
  20.         u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq);  
  21.         u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq);  
  22. //执行第二个判断，也就是第二个段完全包含第一个段。  
  23.         if (!after(end_seq_0, end_seq_1) &&  
  24.             !before(start_seq_0, start_seq_1)) {  
  25.             dup_sack = 1;  
  26.             tcp_dsack_seen(tp);  
  27.             NET_INC_STATS_BH(sock_net(sk),  
  28.                     LINUX_MIB_TCPDSACKOFORECV);  
  29.         }  
  30.     }  
  31.   
  32. ///判断是否dsack的数据段完全被ack所确认。  
  33.     if (dup_sack &&  
  34.         !after(end_seq_0, prior_snd_una) &&  
  35.         after(end_seq_0, tp->undo_marker))  
  36. //更新重传段的个数。  
  37.         tp->undo_retrans--;  
  38.   
  39.     return dup_sack;  
  40. }  


然后回到tcp_sacktag_write_queue，接下来这部分很简单，主要是提取sack的段到sp中，并校验每个段的合法性，然后统计一些信息。 

Java代码   收藏代码
  1. //开始遍历，这里num_sacks也就是我们前面计算的sack段的个数  
  2.               for (i = 0; i < num_sacks; i++) {  
  3.         int dup_sack = !i && found_dup_sack;  
  4.   
  5. //赋值。  
  6.         sp[used_sacks].start_seq = get_unaligned_be32(&sp_wire[i].start_seq);  
  7.         sp[used_sacks].end_seq = get_unaligned_be32(&sp_wire[i].end_seq);  
  8.   
  9. //检测段的合法性。  
  10.         if (!tcp_is_sackblock_valid(tp, dup_sack,  
  11.                         sp[used_sacks].start_seq,  
  12.                         sp[used_sacks].end_seq)) {  
  13.             int mib_idx;  
  14.   
  15.             if (dup_sack) {  
  16.                 if (!tp->undo_marker)  
  17.                     mib_idx = LINUX_MIB_TCPDSACKIGNOREDNOUNDO;  
  18.                 else  
  19.                     mib_idx = LINUX_MIB_TCPDSACKIGNOREDOLD;  
  20.             } else {  
  21.                 /* Don't count olds caused by ACK reordering */  
  22.                 if ((TCP_SKB_CB(ack_skb)->ack_seq != tp->snd_una) &&  
  23.                     !after(sp[used_sacks].end_seq, tp->snd_una))  
  24.                     continue;  
  25.                 mib_idx = LINUX_MIB_TCPSACKDISCARD;  
  26.             }  
  27. //更新统计信息。  
  28.             NET_INC_STATS_BH(sock_net(sk), mib_idx);  
  29.             if (i == 0)  
  30.                 first_sack_index = -1;  
  31.             continue;  
  32.         }  
  33.   
  34. //忽略已经确认过的段。  
  35.         if (!after(sp[used_sacks].end_seq, prior_snd_una))  
  36.             continue;  
  37. //这个值表示我们要使用的sack的段的个数。  
  38.         used_sacks++;  
  39.     }  




然后接下来的代码就是排序sack的段，也就是按照序列号的大小来排序： 


Java代码   收藏代码
  1. for (i = used_sacks - 1; i > 0; i--) {  
  2.         for (j = 0; j < i; j++) {  
  3. //可以看到这里通过比较起始序列号来排序。  
  4.             if (after(sp[j].start_seq, sp[j + 1].start_seq)) {  
  5. //交换对应的值。  
  6.                 swap(sp[j], sp[j + 1]);  
  7.   
  8.                 /* Track where the first SACK block goes to */  
  9.                 if (j == first_sack_index)  
  10.                     first_sack_index = j + 1;  
  11.             }  
  12.         }  
  13.     }  


然后就是cache的初始化，这里的tcp socket的recv_sack_cache域要注意，这个域保存了上一次处理的sack的段的序列号。可以看到这个域类型也是tcp_sack_block，而且大小也是4, 

Java代码   收藏代码
  1. //如果sack的数据段的个数为0,则说明我们要忽略调cache，此时可以看到cache指向recv_sack_cache的末尾。  
  2. if (!tp->sacked_out) {  
  3.         /* It's already past, so skip checking against it */  
  4.         cache = tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);  
  5.     } else {  
  6. //否则取出cache，然后跳过空的块。  
  7.         cache = tp->recv_sack_cache;  
  8.         /* Skip empty blocks in at head of the cache */  
  9.         while (tcp_sack_cache_ok(tp, cache) && !cache->start_seq &&  
  10.                !cache->end_seq)  
  11. //跳过空的块。  
  12.             cache++;  
  13.     }  


然后就是开始真正处理重传队列中的skb了。 



我们要知道重传队列中的skb有三种类型，分别是SACKED(S), RETRANS(R) 和LOST(L)，而每种类型所处理的数据包的个数分别保存在sacked_out, retrans_out 和lost_out中。 

而处于重传队列的skb也就是会处于下面6中状态： 

Java代码   收藏代码
  1.    
  2. * Tag  InFlight Description  
  3.  * 0         1      - orig segment is in flight.  
  4.  * S         0      - nothing flies, orig reached receiver.  
  5.  * L       0        - nothing flies, orig lost by net.  
  6.  * R          2     - both orig and retransmit are in flight.  
  7.  * L|R  1       - orig is lost, retransmit is in flight.  
  8.  * S|R    1     - orig reached receiver, retrans is still in flight.  


这里Tag也就是上面所说的三种类型，而InFlight也就是表示还在网络中的段的个数。 

然后重传队列中的skb的状态变迁是通过下面这几种事件来触发的： 

Java代码   收藏代码
  1. 1. New ACK (+SACK) arrives. (tcp_sacktag_write_queue())  
  2. * 2. Retransmission. (tcp_retransmit_skb(), tcp_xmit_retransmit_queue())  
  3. * 3. Loss detection event of one of three flavors:  
  4. *   A. Scoreboard estimator decided the packet is lost.  
  5. *      A'. Reno "three dupacks" marks head of queue lost.  
  6. *      A''. Its FACK modfication, head until snd.fack is lost.  
  7. *   B. SACK arrives sacking data transmitted after never retransmitted  
  8. *      hole was sent out.  
  9. *   C. SACK arrives sacking SND.NXT at the moment, when the  
  10. *      segment was retransmitted.  
  11. * 4. D-SACK added new rule: D-SACK changes any tag to S.  



在进入这段代码分析之前，我们先来看几个重要的域。 

tcp socket的high_seq域，这个域是我们进入拥塞控制的时候最大的发送序列号，也就是snd_nxt. 

然后这里还有FACK的概念，FACK算法也就是收到的不同的SACK块之间的hole，他就认为是这些段丢失掉了。因此这里tcp socket有一个fackets_out域，这个域表示了 
Java代码   收藏代码
  1. //首先取得写队列的头，以便与下面的遍历。  
  2. skb = tcp_write_queue_head(sk);  
  3.     state.fack_count = 0;  
  4.     i = 0;  
  5.   
  6. ///这里used_sacks表示我们需要处理的sack段的个数。  
  7. while (i < used_sacks) {  
  8.         u32 start_seq = sp[i].start_seq;  
  9.         u32 end_seq = sp[i].end_seq;  
  10. //得到是否是重复的sack  
  11.         int dup_sack = (found_dup_sack && (i == first_sack_index));  
  12.         struct tcp_sack_block *next_dup = NULL;  
  13.   
  14.         if (found_dup_sack && ((i + 1) == first_sack_index))  
  15.             next_dup = &sp[i + 1];  
  16.   
  17. //如果sack段的结束序列号大于将要发送的最大序列号，这个情况说明我们可能有数据丢失。因此设置丢失标记。这里可以看到也就是上面所说的事件B到达。  
  18.         if (after(end_seq, tp->high_seq))  
  19.             state.flag |= FLAG_DATA_LOST;  
  20.   
  21. //跳过一些太老的cache  
  22.         while (tcp_sack_cache_ok(tp, cache) &&  
  23.                !before(start_seq, cache->end_seq))  
  24.             cache++;  
  25.   
  26. //如果有cache，就先处理cache的sack块。  
  27.         if (tcp_sack_cache_ok(tp, cache) && !dup_sack &&  
  28.             after(end_seq, cache->start_seq)) {  
  29.   
  30. //如果当前的段的起始序列号小于cache的起始序列号(这个说明他们之间有交叉)，则我们处理他们之间的段。  
  31.             if (before(start_seq, cache->start_seq)) {  
  32.                 skb = tcp_sacktag_skip(skb, sk, &state,  
  33.                                start_seq);  
  34.                 skb = tcp_sacktag_walk(skb, sk, next_dup,  
  35.                                &state,  
  36.                                start_seq,  
  37.                                cache->start_seq,  
  38.                                dup_sack);  
  39.             }  
  40.   
  41.     //处理剩下的块，也就是cache->end_seq和ned_seq之间的段。  
  42.             if (!after(end_seq, cache->end_seq))  
  43.                 goto advance_sp;  
  44. //是否有需要跳过处理的skb  
  45.             skb = tcp_maybe_skipping_dsack(skb, sk, next_dup,  
  46.                                &state,  
  47.                                cache->end_seq);  
  48.   
  49.             /* ...tail remains todo... */  
  50. //如果刚好等于sack处理的最大序列号，则我们需要处理这个段。  
  51.             if (tcp_highest_sack_seq(tp) == cache->end_seq) {  
  52.                 /* ...but better entrypoint exists! */  
  53.                 skb = tcp_highest_sack(sk);  
  54.                 if (skb == NULL)  
  55.                     break;  
  56.                 state.fack_count = tp->fackets_out;  
  57.                 cache++;  
  58.                 goto walk;  
  59.             }  
  60.   
  61. //再次检测是否有需要skip的段。  
  62.             skb = tcp_sacktag_skip(skb, sk, &state, cache->end_seq);  
  63.   
  64. ///紧接着处理下一个cache。  
  65.             cache++;  
  66.             continue;  
  67.         }  
  68.   
  69. //然后处理这次新的sack段。  
  70.         if (!before(start_seq, tcp_highest_sack_seq(tp))) {  
  71.             skb = tcp_highest_sack(sk);  
  72.             if (skb == NULL)  
  73.                 break;  
  74.             state.fack_count = tp->fackets_out;  
  75.         }  
  76.         skb = tcp_sacktag_skip(skb, sk, &state, start_seq);  
  77.   
  78. walk:  
  79. ///处理sack的段，主要是tag赋值。  
  80.         skb = tcp_sacktag_walk(skb, sk, next_dup, &state,  
  81.                        start_seq, end_seq, dup_sack);  
  82.   
  83. advance_sp:  
  84.         /* SACK enhanced FRTO (RFC4138, Appendix B): Clearing correct 
  85.          * due to in-order walk 
  86.          */  
  87.         if (after(end_seq, tp->frto_highmark))  
  88.             state.flag &= ~FLAG_ONLY_ORIG_SACKED;  
  89.   
  90.         i++;  
  91.     }  


上面的代码并不复杂，这里主要有两个函数，我们需要详细的来分析，一个是tcp_sacktag_skip，一个是tcp_sacktag_walk。 

先来看tcp_sacktag_skip，我们给重传队列的skb的tag赋值时，我们需要遍历整个队列，可是由于我们有序列号，因此我们可以先确认起始的skb，然后从这个skb开始遍历，这里这个函数就是用来确认起始skb的，这里确认的步骤主要是通过start_seq来确认的。 


Java代码   收藏代码
  1. static struct sk_buff *tcp_sacktag_skip(struct sk_buff *skb, struct sock *sk,  
  2.                     struct tcp_sacktag_state *state,  
  3.                     u32 skip_to_seq)  
  4. {  
  5. //开始遍历重传队列。  
  6.     tcp_for_write_queue_from(skb, sk) {  
  7. //如果当前的skb刚好等于发送队列的头，则说明我们这个是第一个数据包，则我们直接跳出循环。  
  8.         if (skb == tcp_send_head(sk))  
  9.             break;  
  10.   
  11. //如果skb的结束序列号大于我们传递进来的序列号，则说明这个skb包含了我们sack确认的段，因此我们退出循环。  
  12.         if (after(TCP_SKB_CB(skb)->end_seq, skip_to_seq))  
  13.             break;  
  14. //更新fack的计数。  
  15.         state->fack_count += tcp_skb_pcount(skb);  
  16.     }  
  17. //返回skb  
  18.     return skb;  
  19. }  



然后是最关键的一个函数tcp_sacktag_walk，这个函数主要是遍历重传队列，找到对应需要设置的段，然后设置tcp_cb的sacked域为TCPCB_SACKED_ACKED，这里要注意，还有一种情况就是sack确认了多个skb，这个时候我们就需要合并这些skb，然后再处理。 

然后来看代码。 
Java代码   收藏代码
  1. static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,  
  2.                     struct tcp_sack_block *next_dup,  
  3.                     struct tcp_sacktag_state *state,  
  4.                     u32 start_seq, u32 end_seq,  
  5.                     int dup_sack_in)  
  6. {  
  7.     struct tcp_sock *tp = tcp_sk(sk);  
  8.     struct sk_buff *tmp;  
  9.   
  10. //开始遍历skb队列。  
  11.     tcp_for_write_queue_from(skb, sk) {  
  12. //in_sack不为0的话表示当前的skb就是我们要设置标记的skb。  
  13.         int in_sack = 0;  
  14.         int dup_sack = dup_sack_in;  
  15.   
  16.         if (skb == tcp_send_head(sk))  
  17.             break;  
  18.   
  19. //由于skb是有序的，因此如果某个skb的序列号大于sack段的结束序列号，我们就退出循环。  
  20.         if (!before(TCP_SKB_CB(skb)->seq, end_seq))  
  21.             break;  
  22. //如果存在next_dup,则判断是否需要进入处理。这里就是skb的序列号小于dup的结束序列号  
  23.         if ((next_dup != NULL) &&  
  24.             before(TCP_SKB_CB(skb)->seq, next_dup->end_seq)) {  
  25. //返回值付给in_sack,也就是这个函数会返回当前skb是否能够被sack的段确认。  
  26.             in_sack = tcp_match_skb_to_sack(sk, skb,  
  27.                             next_dup->start_seq,  
  28.                             next_dup->end_seq);  
  29.             if (in_sack > 0)  
  30.                 dup_sack = 1;  
  31.         }  
  32.   
  33. //如果小于等于0,则尝试着合并多个skb段(主要是由于可能一个sack段确认了多个skb，这样我们尝试着合并他们)  
  34.         if (in_sack <= 0) {  
  35.             tmp = tcp_shift_skb_data(sk, skb, state,  
  36.                          start_seq, end_seq, dup_sack);  
  37. //这里tmp就为我们合并成功的skb。  
  38.             if (tmp != NULL) {  
  39. //如果不等，则我们从合并成功的skb重新开始处理。  
  40.                 if (tmp != skb) {  
  41.                     skb = tmp;  
  42.                     continue;  
  43.                 }  
  44.   
  45.                 in_sack = 0;  
  46.             } else {  
  47. //否则我们单独处理这个skb  
  48.                 in_sack = tcp_match_skb_to_sack(sk, skb,  
  49.                                 start_seq,  
  50.                                 end_seq);  
  51.             }  
  52.         }  
  53.   
  54.         if (unlikely(in_sack < 0))  
  55.             break;  
  56. ///如果in_sack大于0,则说明我们需要处理这个skb了。  
  57.         if (in_sack) {  
  58. //开始处理skb，紧接着我们会分析这个函数。  
  59.             TCP_SKB_CB(skb)->sacked = tcp_sacktag_one(skb, sk,  
  60.                                   state,  
  61.                                   dup_sack,  
  62.                                   tcp_skb_pcount(skb));  
  63. //是否需要更新sack处理的那个最大的skb。  
  64.             if (!before(TCP_SKB_CB(skb)->seq,  
  65.                     tcp_highest_sack_seq(tp)))  
  66.                 tcp_advance_highest_sack(sk, skb);  
  67.         }  
  68.   
  69.         state->fack_count += tcp_skb_pcount(skb);  
  70.     }  
  71.     return skb;  
  72. }  


然后我们来看tcp_sacktag_one函数，这个函数用来设置对应的tag，这里所要设置的也就是tcp_cb的sacked域。我们再来回顾一下它的值： 

Java代码   收藏代码
  1. #define TCPCB_SACKED_ACKED  0x01    /* SKB ACK'd by a SACK block    */  
  2. #define TCPCB_SACKED_RETRANS    0x02    /* SKB retransmitted        */  
  3. #define TCPCB_LOST      0x04    /* SKB is lost          */  
  4. #define TCPCB_TAGBITS       0x07    /* All tag bits         */  
  5.   
  6. #define TCPCB_EVER_RETRANS  0x80    /* Ever retransmitted frame */  
  7. #define TCPCB_RETRANS       (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)  


如果一切都正常的话，我们最终就会设置skb的这个域为TCPCB_SACKED_ACKED，也就是已经被sack过了。 

这个函数处理比较简单，主要就是通过序列号以及sacked本身的值最终来确认sacked要被设置的值。 

这里我们还记得，一开始sacked是被初始化为sack option的偏移(如果是正确的sack)的. 

Java代码   收藏代码
  1. static u8 tcp_sacktag_one(struct sk_buff *skb, struct sock *sk,  
  2.               struct tcp_sacktag_state *state,  
  3.               int dup_sack, int pcount)  
  4. {  
  5.     struct tcp_sock *tp = tcp_sk(sk);  
  6.     u8 sacked = TCP_SKB_CB(skb)->sacked;  
  7.     int fack_count = state->fack_count;  
  8.   
  9. ...........................................................................................................  
  10.   
  11. //如果skb的结束序列号小于发送未确认的，则说明这个帧应当被丢弃。  
  12.     if (!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una))  
  13.         return sacked;  
  14. //如果当前的skb还未被sack确认过，则我们才会进入处理。  
  15.     if (!(sacked & TCPCB_SACKED_ACKED)) {  
  16. //如果是重传被sack确认的。  
  17.         if (sacked & TCPCB_SACKED_RETRANS) {  
  18.     //如果设置了lost，则我们需要修改它的tag。  
  19.             if (sacked & TCPCB_LOST) {  
  20.                 sacked &= ~(TCPCB_LOST|TCPCB_SACKED_RETRANS);  
  21. //更新lost的数据包  
  22.                 tp->lost_out -= pcount;  
  23.                 tp->retrans_out -= pcount;  
  24.             }  
  25.         } else {  
  26. ....................................................................................  
  27.         }  
  28. //开始修改sacked，设置flag。  
  29.         sacked |= TCPCB_SACKED_ACKED;  
  30.         state->flag |= FLAG_DATA_SACKED;  
  31. //增加sack确认的包的个数/  
  32.         tp->sacked_out += pcount;  
  33.   
  34.         fack_count += pcount;  
  35.   
  36. //处理fack  
  37.         if (!tcp_is_fack(tp) && (tp->lost_skb_hint != NULL) &&  
  38.             before(TCP_SKB_CB(skb)->seq,  
  39.                TCP_SKB_CB(tp->lost_skb_hint)->seq))  
  40.             tp->lost_cnt_hint += pcount;  
  41.   
  42.         if (fack_count > tp->fackets_out)  
  43.             tp->fackets_out = fack_count;  
  44.     }  
  45.   
  46. /* D-SACK. We can detect redundant retransmission in S|R and plain R 
  47.      * frames and clear it. undo_retrans is decreased above, L|R frames 
  48.      * are accounted above as well. 
  49.      */  
  50.     if (dup_sack && (sacked & TCPCB_SACKED_RETRANS)) {  
  51.         sacked &= ~TCPCB_SACKED_RETRANS;  
  52.         tp->retrans_out -= pcount;  
  53.     }  
  54.   
  55.     return sacked;  
  56. }  



最后我们来看tcp_sacktag_write_queue的最后一部分，也就是更新cache的部分。 

它也就是将处理过的sack清0,没处理过的保存到cache中。 


Java代码   收藏代码
  1. //开始遍历，可以看到这里将将我们未处理的sack段的序列号清0.  
  2. for (i = 0; i < ARRAY_SIZE(tp->recv_sack_cache) - used_sacks; i++) {  
  3.         tp->recv_sack_cache[i].start_seq = 0;  
  4.         tp->recv_sack_cache[i].end_seq = 0;  
  5.     }  
  6. //然后保存这次处理了的段。  
  7.     for (j = 0; j < used_sacks; j++)  
  8.         tp->recv_sack_cache[i++] = sp[j];  
  9.   
  10. //标记丢失的段。  
  11.     tcp_mark_lost_retrans(sk);  
  12.   
  13.     tcp_verify_left_out(tp);  
  14.   
  15.     if ((state.reord < tp->fackets_out) &&  
  16.         ((icsk->icsk_ca_state != TCP_CA_Loss) || tp->undo_marker) &&  
  17.         (!tp->frto_highmark || after(tp->snd_una, tp->frto_highmark)))  
  18.         tcp_update_reordering(sk, tp->fackets_out - state.reord, 0);  
我恨天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TCP选项之SACK选项概述
九天小哥的专栏
02-21 2万+
标准的TCP确认机制中，如果发送方发送了0-1000序号之间的数据，接收方收到了0-100、300-1000，那么接收方只能向发送方确认101，这时发送方会重传所有101-1000之间的数据，实际上这是不必要的。为了优化这种情况，必须让发送方知道更多的接收信息，所以发展出了SACK选项，关于SACK的标准见RFC 2018。 SACK在实际使用中是比较普遍的一个选项，而且相关的内容也较多，准备用三...
Tcp_Ip测试
技术杂货铺
06-15 203
TC8 TcpIp协议测试
浅析TCP之SACK（选择性确认）
流风回雪的博客
10-16 4786
参考教材：TCP-IP Guide 引入理由 在文章TCP-IP详解：超时重传机制中，有介绍到快速重传和超时重传都会面临到一个重传什么包的问题，因为发送端也不清楚丢失包后面传送的数据是否有成功的送到。主要原因还是对于TCP的确认系统，不是特别的好处理这种不连续确认的状况了，只有低于ACK number的片段都被收到才有进行ACK，out-of-order的片段只能是等待，同时，这个时间窗口是无法向右移动的。 举个例子： 1. 服务发送4个片段给客户端，seg1(seq=1,len=80),se.
TCP-SCAK详解
nice_wen的博客
10-23 1731
由于本人才疏学浅，本文难免存在遗漏之处，欢迎大家留言指正，本人将感激不尽。 最近做QUIC相关的工作，QUIC中采用的是SACK的确认方式，比较好奇，TCP中SACK是如何工作的，于是网上找了一些资料，发现这篇文章讲的比较详细，供自己和读者学习。 参考 https://www.cnblogs.com/lshs/p/6038555.html 总结 在介绍之前，我先简单总结一下这篇文章给我带来的收获。...
linux内核TCP协议栈部分，下册
11-04
《Linux内核TCP协议栈部分，下册》深入解析了Linux操作系统中TCP协议栈的实现细节，涵盖了TCP协议从启动到控制发送的全过程，以及不启用DSACK（duplicate SACK，重复确认选择）等相关主题。这本书是理解网络通信底层...
Linux 4.4.0内核源码分析TCP实现
最新发布
06-30
`tcp_prot`是表示TCP协议的结构体，在内核中它主要负责处理与TCP协议相关的操作，如连接建立、数据传输、错误处理等。 `tcp_prot`结构体通常会被注册到协议栈中，并且可以通过`get`函数获取到该结构体的指针。这一...
linux网络协议栈完全实现
10-25
Linux网络协议栈是操作系统核心的重要组成部分，它负责处理网络数据的传输和接收。在这个主题中，我们将深入探讨Linux内核中的网络协议栈实现，包括TCP/IP协议族的主要组件和工作流程。 首先，我们要理解TCP/IP协议...
tcp源码分析.pdf
12-23
1. 网络子系统数据结构架构包括多个层次，从高层的协议栈到底层的数据包处理。 2. `sock`是内核中的基本网络套接字结构，它封装了协议特性和数据传输相关的操作。`sock_common`作为所有套接字类型的基础结构，`sock`...
linux tcp_tcp
09-19
在Linux操作系统中，TCP（Transmission Control Protocol）是一种广泛使用的传输层协议，它是互联网协议栈（TCP/IP协议族）的重要组成部分。TCP确保了数据的可靠传输，通过提供面向连接、顺序交付和错误检测的服务，...
Linux网络编程: TCP协议之SACK与D-SACK详解
noevil的博客
04-10 2510
TCP协议SACK与D-SACK详细分析与抓包
TCP重传机制详解——02SACK
m0_47104421的博客
03-24 1399
场景触发条件dup ACK三次后会触发快速重传/proc/aya/net/ipv4/tcp_sack=1但不带SACK块信息dup ACK三次后会触发快速重传/proc/aya/net/ipv4/tcp_sack=1且携带SACK块信息SACK块个数三个后会触发快速重传。
TCP重点系列之sack介绍
maimang1001的专栏
10-08 2350
原文： TCP重点系列之sack介绍 | 凡是过去 皆为序曲https://allen-kevin.github.io/2017/03/01/TCP%E9%87%8D%E7%82%B9%E7%B3%BB%E5%88%97%E4%B9%8Bsack%E4%BB%8B%E7%BB%8D/ TCP重点系列之sack介绍 发表于2017-03-01|分类于TCP/IP||   在早期的TCP拥塞控制中都是通过收到duplicate ack（默认3个）来trigger fast retra...
TCP对SACK的处理以及乱序的处理细节
热门推荐
Netfilter
05-07 1万+
不容易啊，天气热得厉害，终于到了周末却哪里也去不了，昨晚就特意向老婆申请了一段不长不短的周末时间用来总结近期的工作，也实属不易，如果申请没有获得批准，我也只好利用夜晚了，因为我几乎是一个不用怎么睡觉，可吃可不吃的人，只要有水，烧酒，就好了...大早上的，热醒了，看来也用不到我申请的时间了。...此时是早上4点半...RFC2018描述了TCP SACK的规范，主要是规范了SACK的定义以及在使用该
linux内核协议栈 TCP选项之SACK选项的发送
10-16 695
目录 1. 相关数据结构 1.1 struct tcp_sock 1.2 struct tcp_options_received 2慢速路径数据接收tcp_data_queue() 2.1 判断SACK是否使能tcp_is_sack 2.2 DSACK 设置 tcp_dsack_set 2.3 将SACK块加入到 selective_acks 数组 3发送SACK选项tcp_transmit_skb() 3.1 SACK片数计算 tcp_established_options()...
网络优化的神奇之处：TCP SACK的优势
禅与计算机程序设计艺术
12-31 825
1.背景介绍 网络优化是现代互联网的基石，它为用户提供了更快、更稳定的连接体验。在这个过程中，TCP SACK(Selective Acknowledgment)技术发挥了重要作用。本文将深入探讨TCP SACK的优势，揭示其在网络优化中的神奇之处。 1.1 TCP的基本概念 TCP(Transmission Control Protocol，传输控制协议)是一种面向连接的、可靠的传输层协议...
TCP拥塞控制算法之NewReno和SACK
进阶中的程序员吃吃的博客
05-23 1万+
一、TCP Reno拥塞控制算法回顾二、基于TCP Reno拥塞控制算法的改进TCP Reno 提出的快速恢复算法提高了丢失报文后的吞吐量和顽健性，但是：仅考虑了每次拥塞发生时只丢失一个报文的情形。实际网络中，一旦发生拥塞，路由器会丢弃大量的报文，即一次拥塞中丢失多个报文的情形很普遍。下图是Reno算法中快速恢复状态和拥塞避免状态之间的相互转换：一次拥塞中丢失多个报文时若采用Reno算法：（TCP...
Linux kernel中常见的宏整理
lyh290188的博客
02-20 1724
0x00 宏的基本知识 // object-like #define宏名 替换列表 换行符 //function-like #define宏名 ([标识符列表]) 替换列表 换行符 替换列表和标识符列表都是将字符串token化以后的列表。区别在于标识符列表使用,作为不同参数之间的分割符。每一个参数都是一个 token化的列表。在宏中空白符只起到分割tok...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值