0
点赞
收藏
分享

微信扫一扫

tcpack--4延时ack

TCP在收到数据后必须发送ACK给对端,但如果每收到一个包就给一个ACK的话会使得网络中被注入过多报文。TCP的做法是在收到数据时不立即发送ACK,而是设置一个定时器,如果在定时器超时之前有数据发送给对端,则ACK会被携带在数据中捎带过去;超时则由定时器发送ACK。这样就减少了报文的发送,提高了协议的效率。

延迟确认

在tcp_transmit_skb 中如果skb->len != tcp_header_size 也就是有载荷时,就会调用下述函数处理延迟确认事宜

/* Congestion state accounting after a packet has been sent.
如果此时距离最近接收到数据包的时间间隔足够短,
说明双方处于你来我往的双向数据传输中,就进入延迟确认模式
icsk->icsk_ack.ato在ACK的发送过程中扮演了重要角色,作用是??
A:ato为ACK Timeout,指ACK的超时时间。但延迟确认定时器的超时时间为icsk->icsk_ack.timeout,
ato只是计算timeout的一个中间变量,会根接收到的数据包的时间间隔来做动态调整。
一般如果接收到的数据包的时间间隔变小,ato也会相应的变小。
如果接收到的数据包的时间间隔变大,ato也会相应的变大。
ato的最小值为40ms,ato的最大值一般为200ms或一个RTT。
所以在实际传输过程中,我们看到的ACK的超时时间,是处于40ms ~ min(200ms, RTT)之间的
在tcp_send_delayed_ack()中会把ato赋值给icsk->icsk_ack.timeout,用作延迟确认定时器的超时时间。
*/
static void tcp_event_data_sent(struct tcp_sock *tp,
struct sock *sk)
{
struct inet_connection_sock *icsk = inet_csk(sk);
const u32 now = tcp_time_stamp;

if (tcp_packets_in_flight(tp) == 0)
tcp_ca_event(sk, CA_EVENT_TX_START);/* first transmit when no packets in flight */

tp->lsndtime = now;/* 更新最近发送数据包的时间*/

/* If it is a reply for ato after last received
* packet, enter pingpong mode.
*///如果距离上次接收到数据包的时间在ato内,则进入延迟确认模式
if ((u32)(now - icsk->icsk_ack.lrcvtime) < icsk->icsk_ack.ato)
icsk->icsk_ack.pingpong = 1;
}

 

延时确认定时器

icsk->icsk_delack_timer的激活函数为inet_csk_reset_xmit_timer(),此函数共负责了5个定时器的激活工作。延迟确认定时器的另一个激活函数为tcp_send_delayed_ack(),用于判断发送快速确认还是延迟确认。

else if (what == ICSK_TIME_DACK) {
icsk->icsk_ack.pending |= ICSK_ACK_TIMER;/* 延迟确认定时器启动标志 */
icsk->icsk_ack.timeout = jiffies + when;//Delay ACK定时器超时时刻
sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
}
/**
* tcp_delack_timer() - The TCP delayed ACK timeout handler
* @data: Pointer to the current socket. (gets casted to struct sock *)
*
* This function gets (indirectly) called when the kernel timer for a TCP packet
* of this socket expires. Calls tcp_delack_timer_handler() to do the actual work.
*
* Returns: Nothing (void)
*/
static void tcp_delack_timer(unsigned long data)
{
struct sock *sk = (struct sock *)data;

bh_lock_sock(sk); /* 传输控制块未被锁定 */
// 处于下半部
if (!sock_owned_by_user(sk)) {
tcp_delack_timer_handler(sk);/* 调用超时处理函数 */
} else {
/*
如果延迟确认定时器触发时,发现用户进程正在使用此socket,就把blocked置为1。
* 之后在接收到新数据、或者将数据复制到用户空间之后,会马上发送ACK。
*/
inet_csk(sk)->icsk_ack.blocked = 1;
__NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOCKED);
/* deleguate our work to tcp_release_cb()
if (flags & TCPF_DELACK_TIMER_DEFERRED) {
tcp_delack_timer_handler(sk);
__sock_put(sk);
}
*///设置标记,等应用程序release_sock的时候调用tcp_delack_timer_handler
if (!test_and_set_bit(TCP_DELACK_TIMER_DEFERRED, &sk->sk_tsq_flags))//如果delack推迟执行,也会处理prequeue队列
sock_hold(sk);
}
bh_unlock_sock(sk);
sock_put(sk);
}
/* Called with BH disabled */
void tcp_delack_timer_handler(struct sock *sk)
{
struct tcp_sock *tp = tcp_sk(sk);
struct inet_connection_sock *icsk = inet_csk(sk);

sk_mem_reclaim_partial(sk);
/* 关闭或者监听状态 || 未启动延迟ack定时器*/
if (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)) ||
!(icsk->icsk_ack.pending & ICSK_ACK_TIMER))
goto out;
/* 尚未达到超时时间,重新设定定时器 */
if (time_after(icsk->icsk_ack.timeout, jiffies)) {
sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
goto out;
}
icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER; /* 清除延迟ack标记 */

if (!skb_queue_empty(&tp->ucopy.prequeue)) { /* prequeue队列不为空 */
struct sk_buff *skb;

__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSCHEDULERFAILED);
/* 数据包出队,调用接收函数tcp_v4_do_rcv处理包 */
while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
sk_backlog_rcv(sk, skb);
/* 消耗的内存清0 */
tp->ucopy.memory = 0;
}
/* 有ack需要发送 */
if (inet_csk_ack_scheduled(sk)) {
if (!icsk->icsk_ack.pingpong) {//不能延时,但却有ack被推迟了
/* Delayed ACK missed: inflate ATO. 即时ack模式 计算超时时间*/
icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1, icsk->icsk_rto);
} else { /* 延迟ack模式 */
/* Delayed ACK missed: leave pingpong mode and
* deflate ATO.
*/ /* 重置超时时间以及设置为快速ack模式 */
icsk->icsk_ack.pingpong = 0;
icsk->icsk_ack.ato = TCP_ATO_MIN;
}
tcp_send_ack(sk); /* 发送ack */
__NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKS);
}

out:
if (tcp_under_memory_pressure(sk))
sk_mem_reclaim(sk);
}

 

  注意 tcp_recvmsg读完sk_receive_queue之后,如果没有读满应用程序缓存,则会处理prequeue和backlog队列,并从中读取。
另外,及时读满了缓存,也会在函数退出前,处理prequeue和backlog队列。

  • 为什么不在协议栈中直接处理?
  1. cache的角度
    prequeue和backlog都是为了在应用程序上下文去处理数据包。
    因为softirq上下文和应用程序上下文之间切换,会造成cache刷新。
    比如ksoftirqd和应用程序不在一个cpu上; 或是协议栈处理完后通知应用程序,应用程序被唤醒,同样会造成造成cache刷新
  2. ack的角度
    如果直接在协议栈快速处理包,则很可能导致快速ack,使对方快速达到很大的发送速率,但是本地用户进程可能并不活跃,就会导致接收缓存满了,对方瞬间停止发送。 造成很明显的抖动。
    因此在应用程序处理数据包和ack的发送,可以反映用户进程的实时情况。
    但同时对突发的小包和需要低延迟的消息,放入prequeue中,也会造成非常不好的影响
  3. 锁的角度
    softirq中不能睡眠,也不应该跟应用程序抢锁, 如果tcp_recvmsg读取一大块内存,tcp_v4_rcv就需要很久才能抢到锁。
    因此使用prequeue就可以避免这样的情况。

​​http://www.cnhalo.net/2016/07/13/linux-tcp-prequeue-backlog/​​

综上所述:应用层也会支持处理数据包,处理数据包后reales_sock时 也会调用 延时确认定时器

if (flags & TCPF_DELACK_TIMER_DEFERRED) {
tcp_delack_timer_handler(sk);
__sock_put(sk);
}

 

  设置延迟ACK的时机主要有以下几个:

(1)发送SYN后收到SYN|ACK时:​​tcp_rcv_synsent_state_process​​==》​​inet_csk_reset_xmit_timer ​​设置延迟ACK定时器,超时时间200ms

 

(2)发送ACK时无法申请skb:​​tcp_send_ack​​---》

 (3)有数据放入prequeue队列中时:

(4)调用__tcp_ack_snd_check函数发送ACK时满足一下条件

(1)收到少于一个MSS的数据或通告窗口缩小

 

(2)没有处于快速ACK模式

 

(3)无乱序数据

 

http代理服务器(3-4-7层代理)-网络事件库公共组件、内核kernel驱动 摄像头驱动 tcpip网络协议栈、netfilter、bridge 好像看过!!!! 但行好事 莫问前程 --身高体重180的胖子

举报

相关推荐

0 条评论