• 深入了解- TCP拥塞状态机 tcp_fastretrans_alert

    【推荐阅读】

    浅析linux内核网络协议栈--linux bridge

    virtio-net 实现机制【一】（图文并茂）

    深入理解SR-IOV和IO虚拟化

    这里主要说的是TCP拥塞情况下的状态状态处理

    1. /* Process an event, which can update packets-in-flight not trivially.
    2.  * Main goal of this function is to calculate new estimate for left_out,
    3.  * taking into account both packets sitting in receiver's buffer and
    4.  * packets lost by network.
    5.  *
    6.  * Besides that it does CWND reduction, when packet loss is detected
    7.  * and changes state of machine.
    8.  *
    9.  * It does _not_ decide what to send, it is made in function
    10.  * tcp_xmit_retransmit_queue().
    11.  */
    12. static void tcp_fastretrans_alert(struct sock *sk, int pkts_acked, int flag)
    13. {
    14.          struct inet_connection_sock *icsk = inet_csk(sk);     
    15.          struct tcp_sock *tp = tcp_sk(sk);
    16.          int is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));  // 判断是不是重复的ACK
    17.          int do_lost = is_dupack || ((flag & FLAG_DATA_SACKED) &&    // 判断是不是丢包：若是重复ACK 或者 SACK而且提前确认中没有到的包数量>重拍指标
    18.                                      (tcp_fackets_out(tp) > tp->reordering)); // 后面会单独说说SACK和FACK内容，觉得总是理解不好
    19.          int fast_rexmit = 0;
    20.  
    21.          if (WARN_ON(!tp->packets_out && tp->sacked_out))  // 如果packet_out为0，那么不可能有sacked_out
    22.                  tp->sacked_out = 0;
    23.          if (WARN_ON(!tp->sacked_out && tp->fackets_out))
    24.                  tp->fackets_out = 0;
    25.  
    26.          /* Now state machine starts.   // 下面开始状态处理
    27.           * A. ECE, hence prohibit cwnd undoing, the reduction is required. */
    28.          if (flag & FLAG_ECE)           // 如果是ECE
    29.                  tp->prior_ssthresh = 0;// 禁止拥塞窗口撤销，并开始减小拥塞窗口
    30.  
    31.          /* B. In all the states check for reneging SACKs. */
    32.          if (tcp_check_sack_reneging(sk, flag))  // 检查ACK是不是确认了已经被SACK选择确认的包了
    33.                  return;
    34.  
    35.          /* C. Process data loss notification, provided it is valid. */
    36.          if (tcp_is_fack(tp) && (flag & FLAG_DATA_LOST) &&   // 提前确认、数据丢失
    37.              before(tp->snd_una, tp->high_seq) &&   // 我们需要注意high_seq 可以标志为LOST的段序号的最大值
    38.              icsk->icsk_ca_state != TCP_CA_Open &&  // 状态不是OPEN
    39.              tp->fackets_out > tp->reordering) {    // 同上面说的
    40.                  tcp_mark_head_lost(sk, tp->fackets_out - tp->reordering);   // 发现丢包，需要标志出丢失的包。 (1) 这个函数后面看
    41.                  NET_INC_STATS_BH(LINUX_MIB_TCPLOSS);
    42.          }
    43.  
    44.          /* D. Check consistency of the current state. */
    45.          tcp_verify_left_out(tp); // #define tcp_verify_left_out(tp) WARN_ON(tcp_left_out(tp) > tp->packets_out)
    46.                                   // 检查丢失的包应该比发送出去的包小，即确定确定left_out < packets_out
    47.          /* E. Check state exit conditions. State can be terminated
    48.           *    when high_seq is ACKed. */  // 下面检测状态退出条件！当high_seq 被确认的时候，这个状态就可以终止了
    49.          if (icsk->icsk_ca_state == TCP_CA_Open) {   // 如果是open状态
    50.                  BUG_TRAP(tp->retrans_out == 0);  // 重传数量应该=0才是合理的
    51.                  tp->retrans_stamp = 0;           // 将重传发送时间置0
    52.          } else if (!before(tp->snd_una, tp->high_seq)) {  // 如果high_seq已经被确认
    53.                  switch (icsk->icsk_ca_state) {  // 
    54.                  case TCP_CA_Loss:   // 
    55.                          icsk->icsk_retransmits = 0;    // 超时重传次数归零
    56.                          if (tcp_try_undo_recovery(sk)) // 尝试将前面的拥塞窗口的调整撤销，在这种情况下弄不清楚包的情况（2）
    57.                                  return;    // 如果使用了SACK，那么不管undo成功与否，都会返回Open态
    58.                          break;
    59.  
    60.                  case TCP_CA_CWR:   // 发生某些道路拥塞，需要减慢发送速度
    61.                          /* CWR is to be held something *above* high_seq
    62.                           * is ACKed for CWR bit to reach receiver. */
    63.                          if (tp->snd_una != tp->high_seq) {
    64.                                  tcp_complete_cwr(sk);               // 完成道路拥塞情况处理，就是减小cwnd（3）
    65.                                  tcp_set_ca_state(sk, TCP_CA_Open);  // 将状态设置成OPEN
    66.                          }
    67.                          break;
    68.  
    69.                  case TCP_CA_Disorder:
    70.                          tcp_try_undo_dsack(sk);     // 尝试撤销cwnd的减少，因为DSACK确认了所有的重传数据（4）
    71.                          if (!tp->undo_marker ||     // 跟踪了重传数据包？
    72.                              /* For SACK case do not Open to allow to undo
    73.                               * catching for all duplicate ACKs. */
    74.                              tcp_is_reno(tp) || tp->snd_una != tp->high_seq) {   // 没有SACK || 两者不同步
    75.                                  tp->undo_marker = 0;
    76.                                  tcp_set_ca_state(sk, TCP_CA_Open);   // 将状态转换成OPEN
    77.                          }
    78.                          break;
    79.  
    80.                  case TCP_CA_Recovery:
    81.                          if (tcp_is_reno(tp))   // 没有SACK
    82.                                  tcp_reset_reno_sack(tp); // sacked_out=0
    83.                          if (tcp_try_undo_recovery(sk))   // 尝试撤销
    84.                                  return;
    85.                          tcp_complete_cwr(sk);  // 完成处理
    86.                          break;
    87.                  }
    88.          }
    89.  
    90.          /* F. Process state. */
    91.          switch (icsk->icsk_ca_state) {
    92.          case TCP_CA_Recovery:
    93.                  if (!(flag & FLAG_SND_UNA_ADVANCED)) {     // snd_una没有改变
    94.                          if (tcp_is_reno(tp) && is_dupack)  // 不是SACK，而且是重复的ACK
    95.                                  tcp_add_reno_sack(sk);     // 接收到重复的ACK，tp->sacked_out++; 并且检查新的reorder问题（5）
    96.                  } else
    97.                          do_lost = tcp_try_undo_partial(sk, pkts_acked);   // 部分ACK接收并撤销窗口操作（6）注意返回的是是否需要重传表示
    98.                  break;                                                    // 1代表重传，0代表不需要重传
    99.          case TCP_CA_Loss:
    100.                  if (flag & FLAG_DATA_ACKED)  // 如果是数据确认
    101.                          icsk->icsk_retransmits = 0;  // 超时重传置次数0
    102.                  if (tcp_is_reno(tp) && flag & FLAG_SND_UNA_ADVANCED) // 没有ACK，&& snd_una改变了
    103.                          tcp_reset_reno_sack(tp);  // 重置sacked=0
    104.                  if (!tcp_try_undo_loss(sk)) {     // 尝试撤销拥塞调整，然后进入OPEN状态（7）
    105.                          tcp_moderate_cwnd(tp);    // 调整窗口（8）
    106.                          tcp_xmit_retransmit_queue(sk);  // 重传丢失的包（9）
    107.                          return;
    108.                  }
    109.                  if (icsk->icsk_ca_state != TCP_CA_Open)
    110.                          return;
    111.                  /* Loss is undone; fall through to processing in Open state. */
    112.          default:
    113.                  if (tcp_is_reno(tp)) {   // 么有SACK，那么就是RENO算法处理：收到三个dup-ACK(即sacked_out==3)，就开始重传
    114.                          if (flag & FLAG_SND_UNA_ADVANCED)  // 如果收到少于 3 个 dupack 后又收到累计确认，则会重置之前的 sacked_out 计数
    115.                                  tcp_reset_reno_sack(tp);   // 重新置0
    116.                          if (is_dupack)                     // 如果收到一个dup-ack，将sacked_out++
    117.                                  tcp_add_reno_sack(sk);
    118.                  }
    119.  
    120.                  if (icsk->icsk_ca_state == TCP_CA_Disorder)
    121.                          tcp_try_undo_dsack(sk);   // DSACK确认了所有重传数据
    122.  
    123.                  if (!tcp_time_to_recover(sk)) {   // 判断是否进入恢复状态
    124.                          tcp_try_to_open(sk, flag);// 如果不可以，那么会判断是否进入Open、Disorder、CWR等状态
    125.                          return;                   // 只有收到三个dup-ack时候，才进入快速回复，否则都返回
    126.                  }
    127.  
    128.                  /* MTU probe failure: don't reduce cwnd */
    129.                  if (icsk->icsk_ca_state < TCP_CA_CWR &&
    130.                      icsk->icsk_mtup.probe_size &&
    131.                      tp->snd_una == tp->mtu_probe.probe_seq_start) {
    132.                          tcp_mtup_probe_failed(sk);   // MTU探测失败
    133.                          /* Restores the reduction we did in tcp_mtup_probe() */
    134.                          tp->snd_cwnd++;
    135.                          tcp_simple_retransmit(sk);  // 做一个简单的转发，而不使用回退机制。用于路径MTU发现。 
    136.                          return;
    137.                  }
    138.                  // 说明已经收到第 3 个连续 dupack，此时 sacked_out = 3，进入恢复态
    139.                  /* Otherwise enter Recovery state */
    140.                  // 进入恢复状态
    141.                  if (tcp_is_reno(tp))
    142.                          NET_INC_STATS_BH(LINUX_MIB_TCPRENORECOVERY);
    143.                  else
    144.                          NET_INC_STATS_BH(LINUX_MIB_TCPSACKRECOVERY);
    145.  
    146.                  tp->high_seq = tp->snd_nxt;
    147.                  tp->prior_ssthresh = 0;
    148.                  tp->undo_marker = tp->snd_una;
    149.                  tp->undo_retrans = tp->retrans_out;
    150.  
    151.                  if (icsk->icsk_ca_state < TCP_CA_CWR) {
    152.                          if (!(flag & FLAG_ECE))
    153.                                  tp->prior_ssthresh = tcp_current_ssthresh(sk);  // 根据状态获取当前门限值
    154.                          tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);     // 更新
    155.                          TCP_ECN_queue_cwr(tp);
    156.                  }
    157.  
    158.                  tp->bytes_acked = 0;
    159.                  tp->snd_cwnd_cnt = 0;
    160.                  tcp_set_ca_state(sk, TCP_CA_Recovery);  // 键入恢复状态
    161.                  fast_rexmit = 1;  // 快速重传
    162.          }
    163.  
    164.          if (do_lost || (tcp_is_fack(tp) && tcp_head_timedout(sk))) // 如果丢失需要重传 || 超时重传
    165.                  tcp_update_scoreboard(sk, fast_rexmit);   // 标志丢失和超时的数据包，增加lost_out(10)
    166.          tcp_cwnd_down(sk, flag);     // 减小cwnd窗口（11）
    167.          tcp_xmit_retransmit_queue(sk);// 重传丢失包
    168.  }
    【文章福利】小编推荐自己的Linux内核技术交流群： 【977878001】整理一些个人觉得比较好得学习书籍、视频资料共享在群文件里面，有需要的可以自行添加哦！！！前100进群领取，额外赠送一份 价值699的内核资料包（含视频教程、电子书、实战项目及代码）

    内核资料直通车：Linux内核源码技术学习路线+视频教程代码资料

    学习直通车：Linux内核源码/内存调优/文件系统/进程管理/设备驱动/网络协议栈

    下面看一下里面的函数：

    先看：tcp_mark_head_lost：通过给丢失的数据包标志TCPCB_LOST，就可以表明哪些数据包需要重传。

    注意参数：packets = fackets_out - reordering，其实就是sacked_out + lost_out。被标志为LOST的段数不能超过packets。

    那么packets 就是标记丢失的包们数量

    1. /* Mark head of queue up as lost. With RFC3517 SACK, the packets is
    2.  * is against sacked "cnt", otherwise it's against facked "cnt"
    3.  */
    4. static void tcp_mark_head_lost(struct sock *sk, int packets)
    5. {
    6.          struct tcp_sock *tp = tcp_sk(sk);
    7.          struct sk_buff *skb;
    8.          int cnt, oldcnt;
    9.          int err;
    10.          unsigned int mss;
    11.  
    12.          BUG_TRAP(packets <= tp->packets_out);   // 丢失的包不可能比所有发出去的包的数量
    13.          if (tp->lost_skb_hint) {  // 如果已经有标识为丢失的段了 
    14.                  skb = tp->lost_skb_hint;  // 下一个需要标记的数据段
    15.                  cnt = tp->lost_cnt_hint;  // 已经标记了多少段
    16.          } else {
    17.                  skb = tcp_write_queue_head(sk);    // 获得链表的第一个结构元素
    18.                  cnt = 0;    // 初始化标记了0个数据
    19.          }
    20.          // 下面开始遍历
    21.          tcp_for_write_queue_from(skb, sk) {
    22.                  if (skb == tcp_send_head(sk))   // return sk->sk_send_head; 即snd_nxt，那么还没有发送不需要处理，break；
    23.                          break;
    24.                  /* TODO: do this better */
    25.                  /* this is not the most efficient way to do this... */
    26.                  tp->lost_skb_hint = skb;    // 更新丢失队列信息
    27.                  tp->lost_cnt_hint = cnt;
    28.  
    29.                  if (after(TCP_SKB_CB(skb)->end_seq, tp->high_seq))   // high_seq是最大的标记为LOST的号，不可以超过这个
    30.                          break;   // 若这个skb超过，退出
    31.  
    32.                  oldcnt = cnt;   // 保存cnt
    33.                  if (tcp_is_fack(tp) || tcp_is_reno(tp) ||
    34.                      (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
    35.                          cnt += tcp_skb_pcount(skb);   // 表示这个段已经被标记
    36.  
    37.                  if (cnt > packets) {
    38.                          if (tcp_is_sack(tp) || (oldcnt >= packets))   // 已经超过了丢失包数量，break
    39.                                  break;
    40.  
    41.                          mss = skb_shinfo(skb)->gso_size; // 得到MSS
    42.                          err = tcp_fragment(sk, skb, (packets - oldcnt) * mss, mss);   // 下面分配，前面说过了
    43.                          if (err < 0)
    44.                                  break;
    45.                          cnt = packets;
    46.                  }
    47.                  // 下面这一段就是做标记动作
    48.                  if (!(TCP_SKB_CB(skb)->sacked & (TCPCB_SACKED_ACKED|TCPCB_LOST))) {
    49.                          TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;   // 标识
    50.                          tp->lost_out += tcp_skb_pcount(skb);     // 丢失包+=
    51.                          tcp_verify_retransmit_hint(tp, skb);     // 其实就是标记这个丢失，加入重传标记队列
    52.                 }
    53.          }
    54.          tcp_verify_left_out(tp);
    55. }

    看一下tcp_verify_retransmit_hint函数：

    1. static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
    2. {
    3.          if ((tp->retransmit_skb_hint == NULL) ||
    4.              before(TCP_SKB_CB(skb)->seq,
    5.                     TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
    6.                  tp->retransmit_skb_hint = skb;    // 加入这个队列
    7.  
    8.          if (!tp->lost_out ||
    9.              after(TCP_SKB_CB(skb)->end_seq, tp->retransmit_high))   // 如果最后一个数据标号比high大，明显更新high
    10.                  tp->retransmit_high = TCP_SKB_CB(skb)->end_seq;
    11. }

    OK，再看一下这个函数tcp_try_undo_recovery：

    1. static int tcp_try_undo_recovery(struct sock *sk)
    2. {
    3.          struct tcp_sock *tp = tcp_sk(sk);
    4.  
    5.          if (tcp_may_undo(tp)) {  // 如果可以undo
    6.                  /* Happy end! We did not retransmit anything
    7.                   * or our original transmission succeeded.
    8.                   */
    9.                  DBGUNDO(sk, inet_csk(sk)->icsk_ca_state == TCP_CA_Loss ? "loss" : "retrans");
    10.                  tcp_undo_cwr(sk, 1);   // 具体处理
    11.                  if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss)
    12.                          NET_INC_STATS_BH(LINUX_MIB_TCPLOSSUNDO);
    13.                  else
    14.                          NET_INC_STATS_BH(LINUX_MIB_TCPFULLUNDO);
    15.                  tp->undo_marker = 0;
    16.          }
    17.          if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
    18.                  /* Hold old state until something *above* high_seq
    19.                   * is ACKed. For Reno it is MUST to prevent false
    20.                   * fast retransmits (RFC2582). SACK TCP is safe. */
    21.                  tcp_moderate_cwnd(tp);   // 更新窗口大小
    22.                  return 1;
    23.          }
    24.          tcp_set_ca_state(sk, TCP_CA_Open);
    25.          return 0;
    26. }

    OK看一下tcp_may_undo函数：检测能否撤销

    1. static inline bool tcp_may_undo(const struct tcp_sock *tp)
    2. {
    3.          return tp->undo_marker && (!tp->undo_retrans || tcp_packet_delayed(tp));
    4. }

    首先得有undo_marker标识才OK！然后undo_retrans的意思是最近的Recovery时间内重传的数据包个数，如果收到一个DSACK那么undo_retrans减一，如果最后等于0，那么说明都被确认了，没有必要重传，所以没有必要调整窗口。或tcp_packet_delayed(tp)条件。如下：

    1. static inline int tcp_packet_delayed(struct tcp_sock *tp)
    2. {
    3.          return !tp->retrans_stamp ||
    4.                  (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
    5.                   (__s32)(tp->rx_opt.rcv_tsecr - tp->retrans_stamp) < 0); // 接收ACK时间在重传数据之前
    6. }

    下面 看一下这个函数tcp_complete_cwr：

    1. static inline void tcp_complete_cwr(struct sock *sk)
    2. {
    3.          struct tcp_sock *tp = tcp_sk(sk);
    4.          tp->snd_cwnd = min(tp->snd_cwnd, tp->snd_ssthresh);   // 调整窗口
    5.          tp->snd_cwnd_stamp = tcp_time_stamp;
    6.          tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR); // 出发事件
    7. }

    1. /* CWND moderation, preventing bursts due to too big ACKs
    2.  * in dubious situations.
    3.  */
    4. static inline void tcp_moderate_cwnd(struct tcp_sock *tp)  // 修改窗口值
    5. {
    6.          tp->snd_cwnd = min(tp->snd_cwnd,
    7.                             tcp_packets_in_flight(tp) + tcp_max_burst(tp));  // 防止怀疑的ACK情况，所以取min值
    8.          tp->snd_cwnd_stamp = tcp_time_stamp;

    再看看这个函数tcp_try_undo_dsack：当DSACK确认所有的重传数据，那么undo_retrans=0，那么需要回复窗口原来的情况

    1. /* Try to undo cwnd reduction, because D-SACKs acked all retransmitted data */
    2. static void tcp_try_undo_dsack(struct sock *sk)
    3. {
    4.          struct tcp_sock *tp = tcp_sk(sk);
    5.  
    6.          if (tp->undo_marker && !tp->undo_retrans) {   // 所有的段都被确认了
    7.                  DBGUNDO(sk, "D-SACK");
    8.                  tcp_undo_cwr(sk, 1);                  // 撤销（1）
    9.                  tp->undo_marker = 0;
    10.                  NET_INC_STATS_BH(LINUX_MIB_TCPDSACKUNDO);
    11.          }
    12. }

    撤销函数

    1. static void tcp_undo_cwr(struct sock *sk, const int undo)
    2. {
    3.          struct tcp_sock *tp = tcp_sk(sk);
    4.  
    5.          if (tp->prior_ssthresh) {  // 如果保存了旧的门限值
    6.                  const struct inet_connection_sock *icsk = inet_csk(sk);
    7.  
    8.                  if (icsk->icsk_ca_ops->undo_cwnd)
    9.                          tp->snd_cwnd = icsk->icsk_ca_ops->undo_cwnd(sk);   // 这个函数可以自己添加
    10.                  else
    11.                          tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh << 1);  // 如果没有定义那个函数，那么做简单的处理
    12.  
    13.                  if (undo && tp->prior_ssthresh > tp->snd_ssthresh) {
    14.                          tp->snd_ssthresh = tp->prior_ssthresh;
    15.                          TCP_ECN_withdraw_cwr(tp);
    16.                  }
    17.          } else {   // 没有保存旧的阈值
    18.                  tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh);   // 
    19.          }
    20.          tcp_moderate_cwnd(tp);  // 上面已经说了
    21.          tp->snd_cwnd_stamp = tcp_time_stamp;
    22.  
    23.          /* There is something screwy going on with the retrans hints after
    24.             an undo */
    25.          tcp_clear_all_retrans_hints(tp);// 清空所有的重传信息
    26. }

    接收到重复的ACK，那么需要对sacked_out处理，看函数tcp_add_reno_sack：

    1. /* Emulate SACKs for SACKless connection: account for a new dupack. */
    2.  
    3. static void tcp_add_reno_sack(struct sock *sk)
    4. {
    5.          struct tcp_sock *tp = tcp_sk(sk);
    6.          tp->sacked_out++;       // 收到重复的ACK，那么这个值++
    7.          tcp_check_reno_reordering(sk, 0); // 检查是否有reordering（1）
    8.          tcp_verify_left_out(tp);   // 
    9. }

    看看这个检查reordering函数：

    1. /* If we receive more dupacks than we expected counting segments
    2.  * in assumption of absent reordering, interpret this as reordering.
    3.  * The only another reason could be bug in receiver TCP.
    4.  */
    5. static void tcp_check_reno_reordering(struct sock *sk, const int addend)
    6. {
    7.          struct tcp_sock *tp = tcp_sk(sk);
    8.          if (tcp_limit_reno_sacked(tp))   // 检查sack的数量是否超过限度
    9.                  tcp_update_reordering(sk, tp->packets_out + addend, 0); // 如果是reordering则更新reordering
    10. }

    1. /* Limits sacked_out so that sum with lost_out isn't ever larger than
    2.  * packets_out. Returns zero if sacked_out adjustement wasn't necessary.
    3.  */
    4. int tcp_limit_reno_sacked(struct tcp_sock *tp)  // 限制sacked_out目的是使得sacked_out + lost_out <= packeted_out
    5. {                                               
    6.          u32 holes;
    7.  
    8.          holes = max(tp->lost_out, 1U);       // 获得hole
    9.          holes = min(holes, tp->packets_out);
    10.  
    11.          if ((tp->sacked_out + holes) > tp->packets_out) {   // 如果大于发出的包，那么reordering就需要了
    12.                  tp->sacked_out = tp->packets_out - holes;   // 因为此处的dup-ack是reorder造成的
    13.                  return 1;
    14.          }
    15.          return 0;
    16. }

    下面看看更新reordering函数tcp_update_reordering

    1. static void tcp_update_reordering(struct sock *sk, const int metric,
    2.                                    const int ts)
    3. {
    4.          struct tcp_sock *tp = tcp_sk(sk);
    5.          if (metric > tp->reordering) {   // 如果现在的数量 > 之前的reorder
    6.                  tp->reordering = min(TCP_MAX_REORDERING, metric);    // 获得ordering值(注意不能超过最大设置值)
    7.  
    8.                  /* This exciting event is worth to be remembered. 8) */
    9.                  if (ts)
    10.                          NET_INC_STATS_BH(LINUX_MIB_TCPTSREORDER);         // 统计信息
    11.                  else if (tcp_is_reno(tp))
    12.                          NET_INC_STATS_BH(LINUX_MIB_TCPRENOREORDER);
    13.                  else if (tcp_is_fack(tp))
    14.                          NET_INC_STATS_BH(LINUX_MIB_TCPFACKREORDER);
    15.                  else
    16.                          NET_INC_STATS_BH(LINUX_MIB_TCPSACKREORDER);
    17. #if FASTRETRANS_DEBUG > 1
    18.                  printk(KERN_DEBUG "Disorder%d %d %u f%u s%u rr%d\n",
    19.                         tp->rx_opt.sack_ok, inet_csk(sk)->icsk_ca_state,
    20.                         tp->reordering,
    21.                         tp->fackets_out,
    22.                         tp->sacked_out,
    23.                         tp->undo_marker ? tp->undo_retrans : 0);
    24. #endif
    25.                  tcp_disable_fack(tp);       // 禁用fack(fack是基于有序的，因为已经使用order了，所以禁用fack)
    26.          }
    27. }

    下面再看一下这个tcp_try_undo_partial函数：在恢复状态，收到部分ACK确认，使用这个函数撤销拥塞调整。

    1. /* Undo during fast recovery after partial ACK. */
    2.  
    3. static int tcp_try_undo_partial(struct sock *sk, int acked)
    4. {
    5.          struct tcp_sock *tp = tcp_sk(sk);
    6.          /* Partial ACK arrived. Force Hoe's retransmit. */ // 收到部分ACK，对于SACK来说不需要重传，对于RENO需要
    7.          int failed = tcp_is_reno(tp) || (tcp_fackets_out(tp) > tp->reordering);  // 或者facked_out数量比reordering要大
    8.  
    9.          if (tcp_may_undo(tp)) {   // 是否可以调整（上面已说）
    10.                  /* Plain luck! Hole if filled with delayed
    11.                   * packet, rather than with a retransmit.
    12.                   */
    13.                  if (tp->retrans_out == 0)      // 重传包=0
    14.                          tp->retrans_stamp = 0; // 重置重传时间
    15.  
    16.                  tcp_update_reordering(sk, tcp_fackets_out(tp) + acked, 1);   // 需要更新reordering( 上面 )
    17.  
    18.                  DBGUNDO(sk, "Hoe");
    19.                  tcp_undo_cwr(sk, 0);   // 撤销操作( 上面 )
    20.                  NET_INC_STATS_BH(LINUX_MIB_TCPPARTIALUNDO);
    21.  
    22.                  /* So... Do not make Hoe's retransmit yet.
    23.                   * If the first packet was delayed, the rest
    24.                   * ones are most probably delayed as well.
    25.                   */
    26.                  failed = 0;   // 表示不用重传了，可以发送新的数据
    27.          }
    28.          return failed;  // 返回是否需要重传
    29. }

    下面继续看tcp_try_undo_loss函数：收到部分确认之后，从loss状态撤销窗口调整

    1. /* Undo during loss recovery after partial ACK. */
    2. static int tcp_try_undo_loss(struct sock *sk)
    3. {
    4.          struct tcp_sock *tp = tcp_sk(sk);
    5.  
    6.          if (tcp_may_undo(tp)) {  // 如果可以undo
    7.                  struct sk_buff *skb;
    8.                  tcp_for_write_queue(skb, sk) {    // 遍历整个发送queue
    9.                          if (skb == tcp_send_head(sk))  // 直到还没有发送的数据头之前(前面的都已经发送)
    10.                                  break;
    11.                          TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;  // 清除LOST标记
    12.                  }
    13.  
    14.                  tcp_clear_all_retrans_hints(tp);   // 清除所有的重传信息
    15.  
    16.                  DBGUNDO(sk, "partial loss");
    17.                  tp->lost_out = 0;      // 重置
    18.                  tcp_undo_cwr(sk, 1);   // 撤销窗口调整
    19.                  NET_INC_STATS_BH(LINUX_MIB_TCPLOSSUNDO);
    20.                  inet_csk(sk)->icsk_retransmits = 0;
    21.                  tp->undo_marker = 0;
    22.                  if (tcp_is_sack(tp))
    23.                          tcp_set_ca_state(sk, TCP_CA_Open);  // 设置状态OPEN
    24.                  return 1;
    25.          }
    26.          return 0;
    27. }

    下面看一下tcp_update_scoreboard函数：其实就是更新lost包数量，这个涉及到不同的算法不一样的结果，没有SACK(reno)，有SACK，有FACK情况

    1) 没有SACK：每次收到重复的ACK或部分ack时，标志一个包为丢失。

    2) 有SACK：sacked_out - reordering > 0 时候，标记为这么多丢失，若小于0，标记为1个丢失(前提是有重传标识)

    3) 有FACK：fackets_out - reordering >0 时候，标记为这么多丢失，若小于0，标记为1个丢失

    ( 注意：小于0的情况是因为考虑到reordering情况 )

    1. /* Account newly detected lost packet(s) */
    2.  
    3. static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
    4. {
    5.          struct tcp_sock *tp = tcp_sk(sk);
    6.  
    7.          if (tcp_is_reno(tp)) {   // 最普通的，没有SACK情况
    8.                  tcp_mark_head_lost(sk, 1);   // 标记为一个丢失
    9.          } else if (tcp_is_fack(tp)) {    // 如果是fack
    10.                  int lost = tp->fackets_out - tp->reordering;  // 判断这个值大小
    11.                  if (lost <= 0)
    12.                          lost = 1;  // 小于0指标记一个
    13.                  tcp_mark_head_lost(sk, lost);  // 否则标记所有的
    14.          } else {   // 仅仅有SACK情况
    15.                  int sacked_upto = tp->sacked_out - tp->reordering;
    16.                  if (sacked_upto < fast_rexmit)
    17.                          sacked_upto = fast_rexmit;
    18.                  tcp_mark_head_lost(sk, sacked_upto);   // 同上
    19.          }
    20.  
    21.          /* New heuristics: it is possible only after we switched
    22.           * to restart timer each time when something is ACKed.
    23.           * Hence, we can detect timed out packets during fast
    24.           * retransmit without falling to slow start.
    25.           */
    26.          if (tcp_is_fack(tp) && tcp_head_timedout(sk)) {   // 下面检查超时包( 先检查第一个数据包是否超时 )
    27.                  struct sk_buff *skb;
    28.  
    29.                  skb = tp->scoreboard_skb_hint ? tp->scoreboard_skb_hint
    30.                          : tcp_write_queue_head(sk);
    31.  
    32.                  tcp_for_write_queue_from(skb, sk) {
    33.                          if (skb == tcp_send_head(sk))
    34.                                  break;
    35.                          if (!tcp_skb_timedout(sk, skb))  // 检查所有的超时包，没有超时的就break
    36.                                  break;
    37.  
    38.                          if (!(TCP_SKB_CB(skb)->sacked & (TCPCB_SACKED_ACKED|TCPCB_LOST))) {
    39.                                  TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;   // 标记为lost
    40.                                  tp->lost_out += tcp_skb_pcount(skb);     // 增加lost数量
    41.                                  tcp_verify_retransmit_hint(tp, skb);     
    42.                          }
    43.                  }
    44.  
    45.                  tp->scoreboard_skb_hint = skb;
    46.  
    47.                 tcp_verify_left_out(tp);
    48.          }
    49. }

    下面继续看这个减小窗口函数：tcp_cwnd_down，

    1. /* Decrease cwnd each second ack. */ // 每收到2个确认将拥塞窗口减1，直到拥塞窗口等于慢启动阈值。
    2. static void tcp_cwnd_down(struct sock *sk, int flag)
    3. {
    4.          struct tcp_sock *tp = tcp_sk(sk);
    5.          int decr = tp->snd_cwnd_cnt + 1;  // 计数器
    6.  
    7.          if ((flag & (FLAG_ANY_PROGRESS | FLAG_DSACKING_ACK)) ||
    8.              (tcp_is_reno(tp) && !(flag & FLAG_NOT_DUP))) {
    9.                  tp->snd_cwnd_cnt = decr & 1;// 因为此处只可能是0,1三个值，这样的操作其实就是切换值，例如现在是第一个ACK，即之前的snd_cwnd_cnt=0，decr=1，那么1&1=1，将snd_cwnd_cnt赋值为1；第二个ACK到来，decr=2，则2&1=0，相当于又将snd_cwnd_cnt初始化为0，因为两个ACK就需要处理一次。
    10.                  decr >>= 1;   // 除以2，是判断是第一个ACK，还是第二个；第一个的话值=0，下面不会执行，是2的话=1，下面一句会执行
    11.  
    12.                  if (decr && tp->snd_cwnd > tcp_cwnd_min(sk)) // 如果是第二个ACK && 比最小的门限值还大一点，那么还需要减小cwnd
    13.                          tp->snd_cwnd -= decr;  // 减小一个，^_^
    14.  
    15.                  tp->snd_cwnd = min(tp->snd_cwnd, tcp_packets_in_flight(tp) + 1);  // 用于微调，和外面的数据包数量比较
    16.                  tp->snd_cwnd_stamp = tcp_time_stamp;    // 改变时间戳
    17.          } 
    18. }

     

  • 相关阅读:
    探究map为什么不能遍历的同时进行增删操作
    Rust 错误处理
    十、网络编程之 poll 详解.md
    Go - 用户服务和Web服务
    docker的常用命令（持续更新中）
    AR贴纸特效SDK，无缝贴合的虚拟体验
    bert----学习笔记
    分布式重点知识总结
    上线就破100W！京东面试官的Spring高级源码手抄本，真不能再细了
    Greenplum学习笔记——第二部分：集群部署
  • 原文地址：https://blog.csdn.net/m0_74282605/article/details/128203167