18版本对于每个SACK块，都是从重传队列头开始遍历。37版本则可以选择性的遍历重传队列的某一部分，忽略
SACK块间的间隙、或者已经cache过的部分。这主要是通过tcp_sacktag_skip()和tcp_sacktag_walk()完成的。
tcp_sacktag_skip()可以直接找到包含某个序号的skb，通常用于定位SACK块的开头。
tcp_sacktag_walk()则遍历两个序号之间的skb，通常用于遍历一个SACK块。
本文主要内容：SACK的遍历函数tcp_sacktag_skip()和tcp_sacktag_walk()。
Author：zhangskd
tcp_sacktag_skip
从当前skb开始遍历，查找skip_to_seq序号对应的skb，同时统计fackets_out。
这样可以从当前包，直接遍历到某个块的start_seq，而不用从头开始遍历，也可以跳过块间的间隙。
/* Avoid all extra work that is being done by sacktag while walking in a normal way */
static struct sk_buff *tcp_sacktag_skip(struct sk_buff *skb, struct sock *sk,
struct tcp_sacktag_state *state, u32 skip_to_seq)
{
tcp_for_write_queue_from(skb, sk) {
if (skb == tcp_send_head(sk)) /* 到了发送队列头，即下一个将要发送的数据包 */
break;
if (after(TCP_SKB_CB(skb)->end_seq, skip_to_seq)) /* 找到包含skip_to_seq序号的数据包了 */
break;
state->fack_count += tcp_skb_pcount(skb); /* 统计fackets_out个数 */
}
return skb; /* 返回包含skip_to_seq的skb */
}
tcp_sacktag_walk
遍历一个SACK块，如果SACK块包含了多个连续的skb，那么先尝试合并这些段。
为什么要合并呢？因为下次遍历的时候，要遍历的包个数就减少了，能提高效率。
如果skb完全包含在块中，则调用tcp_sacktag_one更新该段的记分牌。
static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
struct tcp_sack_block *next_dup,
struct tcp_sacktag_state *state,
u32 start_seq, u32 end_seq,
int dup_sack_in)
{
struct tcp_sock *tp = tcp_sk(sk);
struct sk_buff *tmp;
tcp_for_write_queue_from(skb, sk) {
int in_sack = 0;
int dup_sack = dup_sack_in;
if (skb == tcp_send_head(sk)) /* 遍历到发送队列头了 */
break;
if (! before(TCP_SKB_CB(skb)->seq, end_seq)) /* skb序号超过SACK块了 */
break;
/* 如果下一个块是DSACK，且此skb可能包含在其中 */
if ((next_dup != NULL) &&
before(TCP_SKB_CB(skb)->seq, next_dup->end_seq)) {
/* 此skb是否完全包含在DSACK块中 */
in_sack = tcp_match_skb_to_sack(sk, skb, next_dup->start_seq, next_dup->end_seq);
if (in_sack > 0)
dup_sack = 1; /* 表示这个skb被DSACK */
}
if (in_sack <= 0) {
/* 一个SACK块可能包括多个skb，尝试把这些连续的skb合并 */
tmp = tcp_shift_skb_data(sk, skb, state, start_seq, end_seq, dup_sack);
if (tmp != NULL) { /* 合并成功 */
if (tmp != skb) { /* tmp和当前段地址不同，则跳到合并后的段处理 */
skb = tmp;
continue;
}
in_sack = 0;
} else { /* 合并不成功，单独处理这个段 */
in_sack = tcp_match_skb_to_sack(sk, skb, start_seq, end_seq); /* 段是否完全包含在块中 */
}
}
if (unlikely(in_sack < 0))
break;
/* 如果这个段完全包含在块中，进行处理 */
if (in_sack) {
/* 就是在这里：标志这个段的记分牌！*/
TCP_SKB_CB(skb)->sacked = tcp_sacktag_one(skb, sk, state, dup_sack, tcp_skb_pcount(skb));
/* 如果当前skb的开始序列号大于被SACK的包的最高初始序列号 */
if (! before(TCP_SKB_CB(skb)->seq, tcp_highest_sack_seq(tp)))
tcp_advance_highest_sack(sk, skb); /*把highest_sack设为skb->next */
}
state->fack_count += tcp_skb_pcount(skb); /* 更新fackets_out */
}
return skb; /* 遍历到此skb退出 */
}
tcp_match_skb_to_sack()用于检查一个数据段是否完全包含在一个SACK块中，主要考虑到GSO分段。
/* Check if skb is fully within the SACK block.
* In presence of GSO skbs, the incoming SACK may not exactly match but we can find smaller MSS
* aligned portion of it that matches. Therefore we might need to fragment which may fail and creates
* some hassle (caller must handle error case returns).
* FIXME: this could be merged to shift decision code
*/
static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb, u32 start_seq, u32 end_seq)
{
int in_sack, err;
unsigned int pkt_len;
unsigned int mss;
/* 如果start_seq <= skb->seq < skb->end_seq <= end_seq，说明skb完全包含在SACK块中 */
in_sack = ! after(start_seq, TCP_SKB_CB(skb)->seq) &&
! before(end_seq, TCP_SKB_CB(skb)->end_seq);
/* 如果有GSO分段，skb可能部分包含在块中 */
if (tcp_skb_pcount(skb) > 1 && ! in_sack &&
after(TCP_SKB_CB(skb)->end_seq, start_seq)) {
mss = tcp_skb_mss(skb);
in_sack = ! after(start_seq, TCP_SKB_CB(skb)->seq); /* 前半部在块中 */
/* 这里根据skb->seq和start_seq的大小，分情况处理 */
if (! in_sack) { /* 后半部在块中 */
pkt_len = start_seq - TCP_SKB_CB(skb)->seq; /* skb在块之前的部分 */
if (pkt_len < mss)
pkt_len = mss;
} else {
pkt_len = end_seq - TCP_SKB_CB(skb)->seq; /* skb在块内的部分 */
if (pkt_len < mss)
return -EINVAL;
}
/* Round if necessary so that SACKs cover only full MSSes and/or the remaining
* small portion (if present)
*/
if (pkt_len > mss) {
unsigned int new_len = (pkt_len / mss) * mss;
if (! in_sack && new_len < pkt_len) {
new_len += mss;
if (new_len > skb->len)
return 0;
}
pkt_len = new_len;
}
err = tcp_fragment(sk, skb, pkt_len, mss); /* 把skb分为两个包，SACK块内的和SACK块外的 */
}
return in_sack;
}
tcp_shift_skb_data()尝试把SACK块内的多个包合成一个，可以提升遍历效率。
一个SACK块可能包括多个skb，尝试把这些连续的skb合成一个。
/* Try to collapsing SACK blocks spanning across multiple skbs to a single skb. */
static struct sk_buff *tcp_shift_skb_data(struct sock *sk, struct sk_buff *skb,
struct tcp_sacktag_state *state,
u32 start_seq, u32 end_seq, int dup_sack)
{
struct tcp_sock *tp = tcp_sk(sk);
struct sk_buff *prev;
int mss;
int pcount = 0;
int len;
int in_sack;
if (! sk_can_gso(sk))
goto fallback;
...
fallback:
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
return NULL;
}