TCP之timestamps选项

默认情况下内核是开启timestamps选项的，如下tcp_sk_init函数中对sysctl_tcp_timestamps的初始化。

static int __net_init tcp_sk_init(struct net *net)
{
    net->ipv4.sysctl_tcp_timestamps = 1;

也可通过PROC文件tcp_timestamps控制选项行为，tcp_timestamps值为0时，表示关闭timestamps选项；值为1时，表示使能RFC1323（最新-RFC7323）中定义的timestamps选项，并且使用随机偏移值与timesstamp叠加，以抵御攻击。最后，当tcp_timestamps值为2时，仅开启timestamps选项，不使用偏移值。

$ cat /proc/sys/net/ipv4/tcp_timestamps
1

TSopt定义

如下所示，TSopt选项包含2个4字节的时间戳值，其中TSval为发送端的当前时间戳；而TSecr为最近接收到的对端所发送报文的TSopt选项中包含的TSval时间戳值，并且只有在TCP头部ACK标志置位时，携带的TSecr值才有效，否则，将此字段清零。接收端在收到ACK标志未设置的报文时，将忽略TSopt选项中的TSecr字段。

   TCP Timestamps option (TSopt):

   Kind: 8

   Length: 10 bytes

          +-------+-------+---------------------+---------------------+
          |Kind=8 |  10   |   TS Value (TSval)  |TS Echo Reply (TSecr)|
          +-------+-------+---------------------+---------------------+
              1       1              4                     4

TSopt选项的支持能力在连接建立阶段进行协商，如果SYN报文中携带了TSopt，并且，SYN+ACK报文中也携带了TSopt，才能成功完成TSopt的协商。如果SYN报文中未携带TSopt，服务端不能在SYN+ACK回复报文中携带TSopt。TSopt协商成功之后，所有的报文都必须携带TSopt选项数据，如果接收到一个未携带TSopt的报文，应将其丢弃。连接复位RST报文，不强制要求携带TSopt选项数据。

如果TSopt能力未协商成功，但在后续接收到了携带有TSopt的报文，应忽略TSopt选项数据，报文正常处理。

SYN报文中的TSopt

TCP客户端使用tcp_v4_connect函数发起连接建立过程，这里，由secure_tcp_ts_off函数根据源地址和目的地址，以及随机生成的秘钥进行hash计算得到一个偏移值。如上所述，如果sysctl_tcp_timestamps值不等于1，tsoffset偏移值为零。

int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
    if (likely(!tp->repair)) {
        tp->tsoffset = secure_tcp_ts_off(sock_net(sk),
                         inet->inet_saddr, inet->inet_daddr);
    }
    
    err = tcp_connect(sk);

在函数tcp_connect中，使用tcp_mstamp_refresh函数，保存发送时间戳到tcp_mstamp（实际上其表示最近一次发送/接收的时间，单位时毫秒）。并且由变量retrans_stamp保存SYN报文的发送时间戳。

int tcp_connect(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);

    tcp_connect_init(sk);

    tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN);
    tcp_mstamp_refresh(tp);
    tp->retrans_stamp = tcp_time_stamp(tp);

如下为函数tcp_mstamp_refresh，注意，tcp_mstamp时间戳使用的是微秒单位，以上的retrans_stamp时间戳使用的是毫秒为单位，即TCP时钟。但是两者的时间戳是相同的。另外，在tcp_closk_cahe变量中缓存了此刻的纳秒为单位的时间戳。tcp_mstamp_refresh函数中的if判断，保证了时间戳的值是单向递增的。

变量tcp_mstamp主要用于RTT的估算过程。

void tcp_mstamp_refresh(struct tcp_sock *tp)
{      
    u64 val = tcp_clock_ns();

    if (val > tp->tcp_clock_cache)
        tp->tcp_clock_cache = val;

    val = div_u64(val, NSEC_PER_USEC);
    if (val > tp->tcp_mstamp)
        tp->tcp_mstamp = val; 
}
static inline u32 tcp_time_stamp(const struct tcp_sock *tp)
{
    return div_u64(tp->tcp_mstamp, USEC_PER_SEC / TCP_TS_HZ);
} 

在SYN报文发送处理函数__tcp_transmit_skb中，由于SYN报文为首个报文，tcp_wstamp_ns为零，skb_mstamp_ns的取值为tcp_closk_cache的值，即在以上tcp_mstamp_refresh函数中缓存的以纳秒表示的时间戳。在函数tcp_syn_options中，将使用此时间戳为TSopt的TSval赋值。

static int __tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, gfp_t gfp_mask, u32 rcv_nxt)
{
    prior_wstamp = tp->tcp_wstamp_ns;
    tp->tcp_wstamp_ns = max(tp->tcp_wstamp_ns, tp->tcp_clock_cache);

    skb->skb_mstamp_ns = tp->tcp_wstamp_ns;

    memset(&opts, 0, sizeof(opts));

    if (unlikely(tcb->tcp_flags & TCPHDR_SYN))
        tcp_options_size = tcp_syn_options(sk, skb, &opts, &md5);
		
    err = icsk->icsk_af_ops->queue_xmit(sk, skb, &inet->cork.fl);

    if (!err && oskb) {
        tcp_update_skb_after_send(sk, oskb, prior_wstamp);
        tcp_rate_skb_sent(sk, oskb);
    }

如下函数tcp_syn_options为SYN报文添加选项数据，如果sysctl_tcp_timestamps为真，将添加TSopt数据。其中，TSval的值为时间戳加上偏移值，这里tcp_skb_timestamp返回的时间戳单位为毫秒（TCP时钟）；而TSecr等于零，但是对于此套接口非首次发起连接的情况，TSecr的值有可能不为零。

static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb,
                struct tcp_out_options *opts, struct tcp_md5sig_key **md5)
{
    struct tcp_sock *tp = tcp_sk(sk);

    if (likely(sock_net(sk)->ipv4.sysctl_tcp_timestamps && !*md5)) {
        opts->options |= OPTION_TS;
        opts->tsval = tcp_skb_timestamp(skb) + tp->tsoffset;
        opts->tsecr = tp->rx_opt.ts_recent;
        remaining -= TCPOLEN_TSTAMP_ALIGNED;
    }
static inline u32 tcp_skb_timestamp(const struct sk_buff *skb)
{  
    return div_u64(skb->skb_mstamp_ns, NSEC_PER_SEC / TCP_TS_HZ);
}

SYN报文TSopt处理和SYNACK报文的TSopt

在接收到SYN报文之后，函数tcp_conn_request处理此请求，其中与TSopt相关的有三个部分：一是解析报文TCP选项数据；二是request_sock结构初始化；最后是初始化本地TSopt的偏移值。

int tcp_conn_request(struct request_sock_ops *rsk_ops, const struct tcp_request_sock_ops *af_ops,
             struct sock *sk, struct sk_buff *skb)
{
    tcp_parse_options(sock_net(sk), skb, &tmp_opt, 0, want_cookie ? NULL : &foc);

    tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
    tcp_openreq_init(req, &tmp_opt, skb, sk);

    if (tmp_opt.tstamp_ok)
        tcp_rsk(req)->ts_off = af_ops->init_ts_off(net, skb);

首先，看一下TSopt字段的解析，如下函数tcp_parse_options，在连接建立阶段，即estab为零时，如果本地的sysctl_tcp_timestamps设置为真，将对报文的TSopt进行解析，否则，本地不支持TSopt，无需解析对端的TSopt字段数据。

另外，在连接建立之后，根据tstamp_ok字段判断TSopt是否协商成功，参考以上函数tcp_conn_request，如果此处正确解析对端TSopt，将设置tstamp_ok标志。

void tcp_parse_options(const struct net *net, const struct sk_buff *skb,
               struct tcp_options_received *opt_rx, int estab, struct tcp_fastopen_cookie *foc)
{
     case TCPOPT_TIMESTAMP:
         if ((opsize == TCPOLEN_TIMESTAMP) && ((estab && opt_rx->tstamp_ok) ||
              (!estab && net->ipv4.sysctl_tcp_timestamps))) {
             opt_rx->saw_tstamp = 1;
             opt_rx->rcv_tsval = get_unaligned_be32(ptr);
             opt_rx->rcv_tsecr = get_unaligned_be32(ptr + 4);
         }
         break;

其次，在inet_request_sock初始化过程中，将在其成员tstamp_ok中保存TSopt协商结果。在ts_recent中保存对端报文中的TSval时间戳值，用于之后在TSopt的TSecr中返回给客户端。

static void tcp_openreq_init(struct request_sock *req, const struct tcp_options_received *rx_opt,
                 struct sk_buff *skb, const struct sock *sk)
{
    struct inet_request_sock *ireq = inet_rsk(req);

    req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
    ireq->tstamp_ok = rx_opt->tstamp_ok;

最后，如果TSopt协商成功，对于IPv4而言，函数tcp_v4_init_ts_off将初始化服务端的TS偏移值，但是如果sysctl_tcp_timestamps不等于1，偏移值赋值为零。

static u32 tcp_v4_init_ts_off(const struct net *net, const struct sk_buff *skb)
{
    return secure_tcp_ts_off(net, ip_hdr(skb)->daddr, ip_hdr(skb)->saddr);
}
u32 secure_tcp_ts_off(const struct net *net, __be32 saddr, __be32 daddr)
{                  
    if (net->ipv4.sysctl_tcp_timestamps != 1)
        return 0;  

    ts_secret_init();
    return siphash_2u32((__force u32)saddr, (__force u32)daddr, &ts_secret);
}

在回复SYN+ACK报文时，函数tcp_make_synack使用tcp_clock_ns获取到当前时刻的纳秒值，保存于skb_mstamp_ns变量中。之后，由函数tcp_synack_options初始化选项字段。

struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst,
                struct request_sock *req,...)
{
#ifdef CONFIG_SYN_COOKIES
    if (unlikely(req->cookie_ts))
        skb->skb_mstamp_ns = cookie_init_timestamp(req);
    else
#endif
        skb->skb_mstamp_ns = tcp_clock_ns();

    tcp_header_size = tcp_synack_options(sk, req, mss, skb, &opts, md5, foc) + sizeof(*th);

此时，根据新创建的inet_request_sock结构中标示TSopt协商成功的标志tstamp_ok，将TSecr赋值为以上tcp_openreq_init函数中赋值的ts_recent变量的值，而本地的TSval值为tcp_skb_timestamp的返回值和ts_off的和。

static unsigned int tcp_synack_options(const struct sock *sk, struct request_sock *req,
                       unsigned int mss, struct sk_buff *skb,
                       struct tcp_out_options *opts,...)
{
    struct inet_request_sock *ireq = inet_rsk(req);

    if (likely(ireq->tstamp_ok)) {
        opts->options |= OPTION_TS;
        opts->tsval = tcp_skb_timestamp(skb) + tcp_rsk(req)->ts_off;
        opts->tsecr = req->ts_recent;
        remaining -= TCPOLEN_TSTAMP_ALIGNED;
    }

如下函数tcp_skb_timestamp，将skb_mstamp_ns中的纳秒值转换为timestamps的毫秒值（TCP时钟）。

#define TCP_TS_HZ   1000

static inline u32 tcp_skb_timestamp(const struct sk_buff *skb)
{   
    return div_u64(skb->skb_mstamp_ns, NSEC_PER_SEC / TCP_TS_HZ);
} 

SYNACK报文TSopt处理

TCP客户端在接收到SYNACK报文之后，由函数tcp_rcv_synsent_state_process进行处理，tcp_parse_options负责解析选项信息，如果TSopt选项解析完成，saw_tstamp为真，并且服务端返回的TSecr值不为零，减去偏移值tsoffset，即得到本端原始的时间戳值。

static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th)
{
    ...
    tcp_parse_options(sock_net(sk), skb, &tp->rx_opt, 0, &foc);
    if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
        tp->rx_opt.rcv_tsecr -= tp->tsoffset;

    if (th->ack) {
        if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
            !between(tp->rx_opt.rcv_tsecr, tp->retrans_stamp, tcp_time_stamp(tp))) {
            NET_INC_STATS(sock_net(sk), LINUX_MIB_PAWSACTIVEREJECTED);
            goto reset_and_undo;
        }
        if (tp->rx_opt.saw_tstamp) {
            tp->rx_opt.tstamp_ok       = 1;
            tp->tcp_header_len = sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
            tp->advmss      -= TCPOLEN_TSTAMP_ALIGNED;
            tcp_store_ts_recent(tp);
        }

在函数tcp_connect中使用retrans_stamp保存了SYN报文的时间戳，而tcp_time_stamp返回的为套接口最近发送或接收报文的时间戳，如在函数tcp_rcv_state_process中对此时间戳的更新（tcp_mstamp_refresh），因此，TSecr应当位于retrans_stamp和tcp_mstamp两者之间。此三个时间戳值的单位都是毫秒。函数tcp_mstamp_refresh也将更新tcp_clock_cache缓存值。

int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
{
    switch (sk->sk_state) {
    case TCP_SYN_SENT:
        tp->rx_opt.saw_tstamp = 0;
        tcp_mstamp_refresh(tp);
        queued = tcp_rcv_synsent_state_process(sk, skb, th);

在处理函数tcp_rcv_synsent_state_process中，TSopt选项协商完成，设置标志位tstamp_ok，并且，在函数tcp_store_ts_recent中，将服务端SYNACK报文中的TSval值保存在ts_recent变量中，记录下ts_recent更新时刻的时间戳（ts_recent_stamp）。

static void tcp_store_ts_recent(struct tcp_sock *tp)
{   
    tp->rx_opt.ts_recent = tp->rx_opt.rcv_tsval;
    tp->rx_opt.ts_recent_stamp = ktime_get_seconds();
} 

TCP客户端回复的ACK报文（第三个握手报文）以SYN报文一样，由函数__tcp_transmit_skb负责发送。通常情况下skb_mstamp_ns的值由tcp_clock_cache决定，稍后介绍例外情况。由于不是SYN报文，此时使用函数tcp_established_options设置TCP选项数据。

static int __tcp_transmit_skb(struct sock *sk, struct sk_buff *skb,
                  int clone_it, gfp_t gfp_mask, u32 rcv_nxt)
{
    const struct inet_connection_sock *icsk = inet_csk(sk);

    tp = tcp_sk(sk);

    prior_wstamp = tp->tcp_wstamp_ns;
    tp->tcp_wstamp_ns = max(tp->tcp_wstamp_ns, tp->tcp_clock_cache);
    skb->skb_mstamp_ns = tp->tcp_wstamp_ns;

    memset(&opts, 0, sizeof(opts));

    if (unlikely(tcb->tcp_flags & TCPHDR_SYN))
        tcp_options_size = tcp_syn_options(sk, skb, &opts, &md5);
    else
        tcp_options_size = tcp_established_options(sk, skb, &opts, &md5);

以下函数tcp_established_options，首先判断TSopt是否协商成功；其次，将记录在ts_recent中的服务端时间戳赋值到TSecr字段，返回给服务端；之后，本端的时间戳值TSval设置为当前时间加上偏移值tsoffset。之前介绍了tcp_skb_timestamp函数的作用是将skb_mstamp_ns变量表示的纳秒值转换为毫秒值。

static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb,
                    struct tcp_out_options *opts, struct tcp_md5sig_key **md5)
{       
    struct tcp_sock *tp = tcp_sk(sk);

    if (likely(tp->rx_opt.tstamp_ok)) {
        opts->options |= OPTION_TS;
        opts->tsval = skb ? tcp_skb_timestamp(skb) + tp->tsoffset : 0;
        opts->tsecr = tp->rx_opt.ts_recent;
        size += TCPOLEN_TSTAMP_ALIGNED;
    }

ACK报文TSopt选项

函数tcp_check_req首先对ACK报文进行相应的检查，这里仅关注TSopt相关的部分，如果ACK报文中携带有TSopt选项（saw_tstamp为真），将request_sock中保存的上次客户端通过的时间戳ts_recent赋值到tcp_options_received结构的tmp_opt变量的成员ts_recent中，随后的PAWS检查函数，将比较此时间戳与当前ACK报文中时间戳的大小，以便判断是否是重复的报文。

另外，在设置ts_recent的同时，设置了时间戳ts_recent_stamp，这里其单位为秒。num_timeout为SYNACK超时重传的次数。之后，根据报文中TSopt字段的TSval值更新ts_recent值，记录下客户端ACK报文中的时间戳。

struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
               struct request_sock *req, bool fastopen, bool *req_stolen)
{
    tmp_opt.saw_tstamp = 0;
    if (th->doff > (sizeof(struct tcphdr)>>2)) {
        tcp_parse_options(sock_net(sk), skb, &tmp_opt, 0, NULL);

        if (tmp_opt.saw_tstamp) {
            tmp_opt.ts_recent = req->ts_recent;
            if (tmp_opt.rcv_tsecr)
                tmp_opt.rcv_tsecr -= tcp_rsk(req)->ts_off;
            /* We do not store true stamp, but it is not required,
             * it can be estimated (approximately) from another data.
             */
            tmp_opt.ts_recent_stamp = ktime_get_seconds() - ((TCP_TIMEOUT_INIT/HZ)<<req->num_timeout);
            paws_reject = tcp_paws_reject(&tmp_opt, th->rst);
        }
    }
	...
    /* In sequence, PAWS is OK. */

    if (tmp_opt.saw_tstamp && !after(TCP_SKB_CB(skb)->seq, tcp_rsk(req)->rcv_nxt))
        req->ts_recent = tmp_opt.rcv_tsval;
    child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL, req, &own_req);

在tcp_v4_syn_recv_sock函数中，将使用tcp_create_openreq_child创建子套接口，将TSopt相关的数据保存到新套接口中。比如，TSopt协商标志tstamp_ok，客户端的时间戳ts_recent，以及本端的偏移值tsoffset。

在函数inet_csk_clone_lock中，将子套接口的状态设置为了TCP_SYN_RECV，稍后将用到此状态。

struct sock *tcp_create_openreq_child(const struct sock *sk, struct request_sock *req, struct sk_buff *skb)
{
    struct sock *newsk = inet_csk_clone_lock(sk, req, GFP_ATOMIC);
    const struct inet_request_sock *ireq = inet_rsk(req);
    struct tcp_request_sock *treq = tcp_rsk(req);

    newtp->rx_opt.tstamp_ok = ireq->tstamp_ok;

    if (newtp->rx_opt.tstamp_ok) {
        newtp->rx_opt.ts_recent = req->ts_recent;
        newtp->rx_opt.ts_recent_stamp = ktime_get_seconds();
        newtp->tcp_header_len = sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
    } else {
        newtp->rx_opt.ts_recent_stamp = 0;
        newtp->tcp_header_len = sizeof(struct tcphdr);
    }
    newtp->tsoffset = treq->ts_off;

在接收状态机函数tcp_rcv_state_process中，首先由函数tcp_mstamp_refresh更新套接口中的缓存时间戳tcp_clock_cache，之后由tcp_ack函数处理ACK报文，最后子套接口的状态已经设置为了TCP_SYN_RECV，此处将其更改为TCP_ESTABLISHED。

int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
{
    tcp_mstamp_refresh(tp);
    tp->rx_opt.saw_tstamp = 0;

    if (!th->ack && !th->rst && !th->syn)
        goto discard;
    if (!tcp_validate_incoming(sk, skb, th, 0))
        return 0;

    /* step 5: check the ACK field */
    acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH |
                      FLAG_UPDATE_TS_RECENT | FLAG_NO_CHALLENGE_ACK) > 0;

    switch (sk->sk_state) {
    case TCP_SYN_RECV:
        ...
        tcp_set_state(sk, TCP_ESTABLISHED);
    }

由于在调用tcp_ack函数时，指定了FLAG_UPDATE_TS_RECENT选项，调用函数tcp_replace_ts_recent对其进行更新。

static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
{
    /* ts_recent update must be made after we are sure that the packet is in window.
     */
    if (flag & FLAG_UPDATE_TS_RECENT)
        tcp_replace_ts_recent(tp, TCP_SKB_CB(skb)->seq);

最终，函数tcp_store_ts_recent使用选项结构rx_opt中保存的TSval值更新ts_recent时间戳。

static void tcp_store_ts_recent(struct tcp_sock *tp)
{
    tp->rx_opt.ts_recent = tp->rx_opt.rcv_tsval;
    tp->rx_opt.ts_recent_stamp = ktime_get_seconds();
}
static void tcp_replace_ts_recent(struct tcp_sock *tp, u32 seq)
{
    if (tp->rx_opt.saw_tstamp && !after(seq, tp->rcv_wup)) {
        /* PAWS bug workaround wrt. ACK frames, the PAWS discard
         * extra check below makes sure this can only happen for pure ACK frames.  -DaveM
         * Not only, also it occurs for expired timestamps.
         */
        if (tcp_paws_check(&tp->rx_opt, 0))
            tcp_store_ts_recent(tp);
    }
}

TSval取值

在连接建立之后，函数tcp_established_options负责为TSopt选项赋值，以下可见TSval的值由skb_mstamp_ns和tsoffset偏移值组成。

static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb,
                    struct tcp_out_options *opts,...)
{
    if (likely(tp->rx_opt.tstamp_ok)) {
        opts->options |= OPTION_TS;
        opts->tsval = skb ? tcp_skb_timestamp(skb) + tp->tsoffset : 0;
        opts->tsecr = tp->rx_opt.ts_recent;
        size += TCPOLEN_TSTAMP_ALIGNED;
    }
static inline u32 tcp_skb_timestamp(const struct sk_buff *skb)
{   
    return div_u64(skb->skb_mstamp_ns, NSEC_PER_SEC / TCP_TS_HZ);
} 

在发送函数__tcp_transmit_skb中，skb_mstamp_ns的值等于tcp_wstamp_ns和tcp_clock_cache两者中的最大值。

static int __tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, gfp_t gfp_mask, u32 rcv_nxt)
{
    prior_wstamp = tp->tcp_wstamp_ns;
    tp->tcp_wstamp_ns = max(tp->tcp_wstamp_ns, tp->tcp_clock_cache);

    skb->skb_mstamp_ns = tp->tcp_wstamp_ns;

    if (unlikely(tcb->tcp_flags & TCPHDR_SYN))
    else
        tcp_options_size = tcp_established_options(sk, skb, &opts, &md5);

    err = icsk->icsk_af_ops->queue_xmit(sk, skb, &inet->cork.fl);

    if (!err && oskb) {
        tcp_update_skb_after_send(sk, oskb, prior_wstamp);
        tcp_rate_skb_sent(sk, oskb);
    }

由函数tcp_write_xmit可知，在发送之前，其使用tcp_mstamp_refresh函数，将tcp_clock_cache时间戳值更新到了当前时刻。所以，通过情况下，tcp_clock_cache的值大于tcp_wstamp_ns。

static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle, int push_one, gfp_t gfp)
{
    tcp_mstamp_refresh(tp);

    while ((skb = tcp_send_head(sk))) {
        ...
        if (unlikely(tcp_transmit_skb(sk, skb, 1, gfp)))
            break;

如下函数tcp_update_skb_after_send，其在报文发送之后被调用，以确定下一个报文的发送时间戳。由于Pacing的存在，报文并不一定在tcp_write_xmit调用的时刻被发送出去。而函数tcp_update_skb_after_send根据Pacing速率和报文长度，估算出下一个报文的发送时刻，保存在tcp_wstamp_ns中，此种情况下，其有可能大于tcp_clock_cache的值。所以TSval的值取两者之间较大值。

static void tcp_update_skb_after_send(struct sock *sk, struct sk_buff *skb, u64 prior_wstamp)
{
    struct tcp_sock *tp = tcp_sk(sk);

    skb->skb_mstamp_ns = tp->tcp_wstamp_ns;
    if (sk->sk_pacing_status != SK_PACING_NONE) {
        unsigned long rate = sk->sk_pacing_rate;

        /* Original sch_fq does not pace first 10 MSS Note that tp->data_segs_out overflows after 2^32 packets,
         * this is a minor annoyance.
         */
        if (rate != ~0UL && rate && tp->data_segs_out >= 10) {
            u64 len_ns = div64_ul((u64)skb->len * NSEC_PER_SEC, rate);
            u64 credit = tp->tcp_wstamp_ns - prior_wstamp;

            /* take into account OS jitter */
            len_ns -= min_t(u64, len_ns / 2, credit);
            tp->tcp_wstamp_ns += len_ns;
        }
    }
    list_move_tail(&skb->tcp_tsorted_anchor, &tp->tsorted_sent_queue);

TSecr值的选取

由以上的介绍可知，TSecr的值取自ts_recent变量。RFC7323中规定ts_recent的更新需满足以下公式,即接收报文中的TSval大于等于本地上次记录的ts_recent值，并且，接收报文的序号小于等于本地最近ACK字段请求的序号：

            SEG.TSval >= TS.Recent and SEG.SEQ <= Last.ACK.sent

        then SEG.TSval is copied to TS.Recent; otherwise, it is ignored.

在quickack模式下，一个报文对应一个ACK，必然满足以上的条件。在延迟ACK模式下，例如接收到两个数据报文之后，回复一个ACK，只有第一个数据报文满足以上条件，第二个数据报文的序号将大于Last.ACK.sent。另外，当接收到一个乱序报文时，其序号也将大于Last.ACK.sent的值，乱序报文的TSval将不用做更新ts_recent。

变量ts_recent的值通常情况下由函数tcp_store_ts_recent进行更新，并且记录下更新时间（ts_recent_stamp），更新时间由PAWS检查时使用。

static void tcp_store_ts_recent(struct tcp_sock *tp)
{
    tp->rx_opt.ts_recent = tp->rx_opt.rcv_tsval;
    tp->rx_opt.ts_recent_stamp = ktime_get_seconds();
}

在连接建立之后，函数tcp_rcv_established处理接收报文，首先看一下在TCP快速接收路径中ts_recent时间戳的更新。前提是报文中的TSval值必须大于当前记录的ts_recent值，再者看一下第二个条件SEG.SEQ <= Last.ACK.sent的判断，在内核中对应seq<=rcv_wup，而在此快速路径中，seq是等于rcv_nxt的，即rcv_nxt<=rcv_wup，最后rcv_wup变量表示的是上一次窗口更新时的rcv_nxt的值，必然有rcv_nxt>=rcv_wup，所以，仅需要判断rcv_nxt是否等于rcv_wup。

另外，对于报文长度len，小于tcp_header_len指定长度（其中包含TCPOLEN_TSTAMP_ALIGNED长度）的报文，说明其中未携带TSopt字段数据，将其丢弃。

void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
{
    if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
        TCP_SKB_CB(skb)->seq == tp->rcv_nxt &&
        !after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt)) {
		
        if (tcp_header_len == sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) {
            if (!tcp_parse_aligned_timestamp(tp, th)) /* No? Slow path! */
                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) < 0)
                goto slow_path;
        }
		
        if (len <= tcp_header_len) { /* 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);
            } else { /* Header too small */
                TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
                goto discard;
            }

对于TCP慢速路径，将在tcp_ack中更新ts_recent时间戳，以上也将进行了接收，其参数FLAG_UPDATE_TS_RECENT指明了这一点。

slow_path:
    if (len < (th->doff << 2) || tcp_checksum_complete(skb))
        goto csum_error;

    if (!th->ack && !th->rst && !th->syn)
        goto discard;

    /*  Standard slow path. */
    if (!tcp_validate_incoming(sk, skb, th, 1))
        return;
step5:
    if (tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) < 0)
        goto discard;

tcp_ack使用函数tcp_replace_ts_recent更新ts_recent的值，以下函数实现可见，两个if语句确保负荷RFC7323中的规定。

static void tcp_replace_ts_recent(struct tcp_sock *tp, u32 seq)
{
    if (tp->rx_opt.saw_tstamp && !after(seq, tp->rcv_wup)) {
        /* PAWS bug workaround wrt. ACK frames, the PAWS discard
         * extra check below makes sure this can only happen for pure ACK frames.  -DaveM
         *
         * Not only, also it occurs for expired timestamps.
         */

        if (tcp_paws_check(&tp->rx_opt, 0))
            tcp_store_ts_recent(tp);
    }

RFC7323中对ts_recent的更新定义，目的再有帮助对端能够更好的计算连接RTT值。例如，对于延迟ACK的情况，ts_recent使用的是最早的未确认报文中携带的TSval的值，这将使得对端计算的RTT值变大，降低对端进行重传的风险。反之，如果使用最近一个接收到的报文中的TSval值，对端计算的RTT值将减小，进一步导致RTO值减小，容易造成对较早发送报文进行不必要的重传。

TIMEWAIT套接口TSopt

套接口在进入TIMEWAIT状态（子状态可能为TCP_FIN_WAIT2）之后，分配新的inet_timewait_sock结构套接口，随将TSopt相关记录：ts_recent、ts_recent_stamp和tsoffset赋值到新的套接口中。

void tcp_time_wait(struct sock *sk, int state, int timeo)
{
    const struct inet_connection_sock *icsk = inet_csk(sk);
    struct inet_timewait_sock *tw;

    tw = inet_twsk_alloc(sk, tcp_death_row, state);
    if (tw) {
        struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
        const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1);
        struct inet_sock *inet = inet_sk(sk);

        tcptw->tw_ts_recent = tp->rx_opt.ts_recent;
        tcptw->tw_ts_recent_stamp = tp->rx_opt.ts_recent_stamp;
        tcptw->tw_ts_offset = tp->tsoffset;

如下所示为TIMEWAIT套接口状态机处理函数tcp_timewait_state_process，其中对TSopt数据的处理与以上介绍的一致。

enum tcp_tw_status
tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb, const struct tcphdr *th)
{
    struct tcp_options_received tmp_opt;
    struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
    bool paws_reject = false;

    tmp_opt.saw_tstamp = 0;
    if (th->doff > (sizeof(*th) >> 2) && tcptw->tw_ts_recent_stamp) {
        tcp_parse_options(twsk_net(tw), skb, &tmp_opt, 0, NULL);

        if (tmp_opt.saw_tstamp) {
            if (tmp_opt.rcv_tsecr)
                tmp_opt.rcv_tsecr -= tcptw->tw_ts_offset;
            tmp_opt.ts_recent   = tcptw->tw_ts_recent;
            tmp_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
            paws_reject = tcp_paws_reject(&tmp_opt, th->rst);
        }
    }

内核版本 5.0