On Tue, May 16, 2017 at 5:00 PM, Eric Dumazet <eduma...@google.com> wrote: > TCP Timestamps option is defined in RFC 7323 > > Traditionally on linux, it has been tied to the internal > 'jiffies' variable, because it had been a cheap and good enough > generator. > > For TCP flows on the Internet, 1 ms resolution would be much better > than 4ms or 10ms (HZ=250 or HZ=100 respectively) > > For TCP flows in the DC, Google has used usec resolution for more > than two years with great success [1] > > Receive size autotuning (DRS) is indeed more precise and converges > faster to optimal window size. > > This patch converts tp->tcp_mstamp to a plain u64 value storing > a 1 usec TCP clock. > > This choice will allow us to upstream the 1 usec TS option as > discussed in IETF 97. > > [1] > https://www.ietf.org/proceedings/97/slides/slides-97-tcpm-tcp-options-for-low-latency-00.pdf > > Signed-off-by: Eric Dumazet <eduma...@google.com>
Acked-by: Soheil Hassas Yeganeh <soh...@google.com> > --- > include/linux/skbuff.h | 62 +------------------------- > include/linux/tcp.h | 22 ++++----- > include/net/tcp.h | 59 ++++++++++++++++++++---- > net/ipv4/syncookies.c | 8 ++-- > net/ipv4/tcp.c | 4 +- > net/ipv4/tcp_bbr.c | 22 ++++----- > net/ipv4/tcp_input.c | 96 > ++++++++++++++++++++-------------------- > net/ipv4/tcp_ipv4.c | 17 +++---- > net/ipv4/tcp_lp.c | 12 ++--- > net/ipv4/tcp_minisocks.c | 4 +- > net/ipv4/tcp_output.c | 16 +++---- > net/ipv4/tcp_rate.c | 16 +++---- > net/ipv4/tcp_recovery.c | 23 +++++----- > net/ipv4/tcp_timer.c | 8 ++-- > net/ipv6/syncookies.c | 2 +- > net/ipv6/tcp_ipv6.c | 4 +- > net/netfilter/nf_synproxy_core.c | 2 +- > 17 files changed, 178 insertions(+), 199 deletions(-) > > diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h > index > bfc7892f6c33c9fdfb7c0d8110f80cfb12d1ae61..7c0cb2ce8b01a9be366d8cdb7e3661f65ebff3c9 > 100644 > --- a/include/linux/skbuff.h > +++ b/include/linux/skbuff.h > @@ -506,66 +506,6 @@ typedef unsigned int sk_buff_data_t; > typedef unsigned char *sk_buff_data_t; > #endif > > -/** > - * struct skb_mstamp - multi resolution time stamps > - * @stamp_us: timestamp in us resolution > - * @stamp_jiffies: timestamp in jiffies > - */ > -struct skb_mstamp { > - union { > - u64 v64; > - struct { > - u32 stamp_us; > - u32 stamp_jiffies; > - }; > - }; > -}; > - > -/** > - * skb_mstamp_get - get current timestamp > - * @cl: place to store timestamps > - */ > -static inline void skb_mstamp_get(struct skb_mstamp *cl) > -{ > - u64 val = local_clock(); > - > - do_div(val, NSEC_PER_USEC); > - cl->stamp_us = (u32)val; > - cl->stamp_jiffies = (u32)jiffies; > -} > - > -/** > - * skb_mstamp_delta - compute the difference in usec between two skb_mstamp > - * @t1: pointer to newest sample > - * @t0: pointer to oldest sample > - */ > -static inline u32 skb_mstamp_us_delta(const struct skb_mstamp *t1, > - const struct skb_mstamp *t0) > -{ > - s32 delta_us = t1->stamp_us - t0->stamp_us; > - u32 delta_jiffies = t1->stamp_jiffies - t0->stamp_jiffies; > - > - /* If delta_us is negative, this might be because interval is too big, > - * or local_clock() drift is too big : fallback using jiffies. > - */ > - if (delta_us <= 0 || > - delta_jiffies >= (INT_MAX / (USEC_PER_SEC / HZ))) > - > - delta_us = jiffies_to_usecs(delta_jiffies); > - > - return delta_us; > -} > - > -static inline bool skb_mstamp_after(const struct skb_mstamp *t1, > - const struct skb_mstamp *t0) > -{ > - s32 diff = t1->stamp_jiffies - t0->stamp_jiffies; > - > - if (!diff) > - diff = t1->stamp_us - t0->stamp_us; > - return diff > 0; > -} > - > /** > * struct sk_buff - socket buffer > * @next: Next buffer in list > @@ -646,7 +586,7 @@ struct sk_buff { > > union { > ktime_t tstamp; > - struct skb_mstamp skb_mstamp; > + u64 skb_mstamp; > }; > }; > struct rb_node rbnode; /* used in netem & tcp stack */ > diff --git a/include/linux/tcp.h b/include/linux/tcp.h > index > 22854f0284347a3bb047709478525ee5a9dd9b36..542ca1ae02c4f64833b287c0fd744283ee518909 > 100644 > --- a/include/linux/tcp.h > +++ b/include/linux/tcp.h > @@ -123,7 +123,7 @@ struct tcp_request_sock_ops; > struct tcp_request_sock { > struct inet_request_sock req; > const struct tcp_request_sock_ops *af_specific; > - struct skb_mstamp snt_synack; /* first SYNACK sent time > */ > + u64 snt_synack; /* first SYNACK sent time > */ > bool tfo_listener; > u32 txhash; > u32 rcv_isn; > @@ -211,7 +211,7 @@ struct tcp_sock { > > /* Information of the most recently (s)acked skb */ > struct tcp_rack { > - struct skb_mstamp mstamp; /* (Re)sent time of the skb */ > + u64 mstamp; /* (Re)sent time of the skb */ > u32 rtt_us; /* Associated RTT */ > u32 end_seq; /* Ending TCP sequence of the skb */ > u8 advanced; /* mstamp advanced since last lost marking */ > @@ -240,7 +240,7 @@ struct tcp_sock { > u32 tlp_high_seq; /* snd_nxt at the time of TLP retransmit. */ > > /* RTT measurement */ > - struct skb_mstamp tcp_mstamp; /* most recent packet received/sent */ > + u64 tcp_mstamp; /* most recent packet received/sent */ > u32 srtt_us; /* smoothed round trip time << 3 in usecs */ > u32 mdev_us; /* medium deviation */ > u32 mdev_max_us; /* maximal mdev for the last rtt period */ > @@ -280,8 +280,8 @@ struct tcp_sock { > u32 delivered; /* Total data packets delivered incl. rexmits > */ > u32 lost; /* Total data packets lost incl. rexmits */ > u32 app_limited; /* limited until "delivered" reaches this val > */ > - struct skb_mstamp first_tx_mstamp; /* start of window send phase */ > - struct skb_mstamp delivered_mstamp; /* time we reached "delivered" */ > + u64 first_tx_mstamp; /* start of window send phase */ > + u64 delivered_mstamp; /* time we reached "delivered" */ > u32 rate_delivered; /* saved rate sample: packets delivered */ > u32 rate_interval_us; /* saved rate sample: time elapsed */ > > @@ -335,16 +335,16 @@ struct tcp_sock { > > /* Receiver side RTT estimation */ > struct { > - u32 rtt_us; > - u32 seq; > - struct skb_mstamp time; > + u32 rtt_us; > + u32 seq; > + u64 time; > } rcv_rtt_est; > > /* Receiver queue space */ > struct { > - int space; > - u32 seq; > - struct skb_mstamp time; > + int space; > + u32 seq; > + u64 time; > } rcvq_space; > > /* TCP-specific MTU probe information. */ > diff --git a/include/net/tcp.h b/include/net/tcp.h > index > 5b2932b8363fb8546322ebff7c74663139b3371d..82462db97183abebb33628eb5e04a5c5f04ea873 > 100644 > --- a/include/net/tcp.h > +++ b/include/net/tcp.h > @@ -519,7 +519,7 @@ static inline u32 tcp_cookie_time(void) > u32 __cookie_v4_init_sequence(const struct iphdr *iph, const struct tcphdr > *th, > u16 *mssp); > __u32 cookie_v4_init_sequence(const struct sk_buff *skb, __u16 *mss); > -__u32 cookie_init_timestamp(struct request_sock *req); > +u64 cookie_init_timestamp(struct request_sock *req); > bool cookie_timestamp_decode(struct tcp_options_received *opt); > bool cookie_ecn_ok(const struct tcp_options_received *opt, > const struct net *net, const struct dst_entry *dst); > @@ -706,14 +706,55 @@ void tcp_send_window_probe(struct sock *sk); > */ > #define tcp_jiffies32 ((u32)jiffies) > > -/* Generator for TCP TS option (RFC 7323) > - * Currently tied to 'jiffies' but will soon be driven by 1 ms clock. > +/* > + * Deliver a 32bit value for TCP timestamp option (RFC 7323) > + * It is no longer tied to jiffies, but to 1 ms clock. > + * Note: double check if you want to use tcp_jiffies32 instead of this. > + */ > +#define TCP_TS_HZ 1000 > + > +static inline u64 tcp_clock_ns(void) > +{ > + return local_clock(); > +} > + > +static inline u64 tcp_clock_us(void) > +{ > + return div_u64(tcp_clock_ns(), NSEC_PER_USEC); > +} > + > +/* This should only be used in contexts where tp->tcp_mstamp is up to date */ > +static inline u32 tcp_time_stamp(const struct tcp_sock *tp) > +{ > + return div_u64(tp->tcp_mstamp, USEC_PER_SEC / TCP_TS_HZ); > +} > + > +/* Could use tcp_clock_us() / 1000, but this version uses a single divide */ > +static inline u32 tcp_time_stamp_raw(void) > +{ > + return div_u64(tcp_clock_ns(), NSEC_PER_SEC / TCP_TS_HZ); > +} > + > + > +/* Refresh 1us clock of a TCP socket, > + * ensuring monotically increasing values. > */ > -#define tcp_time_stamp ((__u32)(jiffies)) > +static inline void tcp_mstamp_refresh(struct tcp_sock *tp) > +{ > + u64 val = tcp_clock_us(); > + > + if (val > tp->tcp_mstamp) > + tp->tcp_mstamp = val; > +} > + > +static inline u32 tcp_stamp_us_delta(u64 t1, u64 t0) > +{ > + return max_t(s64, t1 - t0, 0); > +} > > static inline u32 tcp_skb_timestamp(const struct sk_buff *skb) > { > - return skb->skb_mstamp.stamp_jiffies; > + return div_u64(skb->skb_mstamp, USEC_PER_SEC / TCP_TS_HZ); > } > > > @@ -778,9 +819,9 @@ struct tcp_skb_cb { > /* pkts S/ACKed so far upon tx of skb, incl retrans: > */ > __u32 delivered; > /* start of send pipeline phase */ > - struct skb_mstamp first_tx_mstamp; > + u64 first_tx_mstamp; > /* when we reached the "delivered" count */ > - struct skb_mstamp delivered_mstamp; > + u64 delivered_mstamp; > } tx; /* only used for outgoing skbs */ > union { > struct inet_skb_parm h4; > @@ -896,7 +937,7 @@ struct ack_sample { > * A sample is invalid if "delivered" or "interval_us" is negative. > */ > struct rate_sample { > - struct skb_mstamp prior_mstamp; /* starting timestamp for interval */ > + u64 prior_mstamp; /* starting timestamp for interval */ > u32 prior_delivered; /* tp->delivered at "prior_mstamp" */ > s32 delivered; /* number of packets delivered over interval > */ > long interval_us; /* time for tp->delivered to incr "delivered" > */ > @@ -1862,7 +1903,7 @@ void tcp_init(void); > /* tcp_recovery.c */ > extern void tcp_rack_mark_lost(struct sock *sk); > extern void tcp_rack_advance(struct tcp_sock *tp, u8 sacked, u32 end_seq, > - const struct skb_mstamp *xmit_time); > + u64 xmit_time); > extern void tcp_rack_reo_timeout(struct sock *sk); > > /* > diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c > index > 0257d965f11119acf8c55888d6e672d171ef5f08..6426250a58ea1afb29b673c00bb9d58bd3d21122 > 100644 > --- a/net/ipv4/syncookies.c > +++ b/net/ipv4/syncookies.c > @@ -66,10 +66,10 @@ static u32 cookie_hash(__be32 saddr, __be32 daddr, __be16 > sport, __be16 dport, > * Since subsequent timestamps use the normal tcp_time_stamp value, we > * must make sure that the resulting initial timestamp is <= tcp_time_stamp. > */ > -__u32 cookie_init_timestamp(struct request_sock *req) > +u64 cookie_init_timestamp(struct request_sock *req) > { > struct inet_request_sock *ireq; > - u32 ts, ts_now = tcp_time_stamp; > + u32 ts, ts_now = tcp_time_stamp_raw(); > u32 options = 0; > > ireq = inet_rsk(req); > @@ -88,7 +88,7 @@ __u32 cookie_init_timestamp(struct request_sock *req) > ts <<= TSBITS; > ts |= options; > } > - return ts; > + return (u64)ts * (USEC_PER_SEC / TCP_TS_HZ); > } > > > @@ -343,7 +343,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct > sk_buff *skb) > ireq->wscale_ok = tcp_opt.wscale_ok; > ireq->tstamp_ok = tcp_opt.saw_tstamp; > req->ts_recent = tcp_opt.saw_tstamp ? tcp_opt.rcv_tsval : 0; > - treq->snt_synack.v64 = 0; > + treq->snt_synack = 0; > treq->tfo_listener = false; > > ireq->ir_iif = inet_request_bound_dev_if(sk, skb); > diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c > index > 85005480052626c5769ef100a868c88fad803f75..b5d18484746daa9189ade316fa9ffc17be30cb60 > 100644 > --- a/net/ipv4/tcp.c > +++ b/net/ipv4/tcp.c > @@ -2706,7 +2706,7 @@ static int do_tcp_setsockopt(struct sock *sk, int level, > if (!tp->repair) > err = -EPERM; > else > - tp->tsoffset = val - tcp_time_stamp; > + tp->tsoffset = val - tcp_time_stamp_raw(); > break; > case TCP_REPAIR_WINDOW: > err = tcp_repair_set_window(tp, optval, optlen); > @@ -3072,7 +3072,7 @@ static int do_tcp_getsockopt(struct sock *sk, int level, > break; > > case TCP_TIMESTAMP: > - val = tcp_time_stamp + tp->tsoffset; > + val = tcp_time_stamp_raw() + tp->tsoffset; > break; > case TCP_NOTSENT_LOWAT: > val = tp->notsent_lowat; > diff --git a/net/ipv4/tcp_bbr.c b/net/ipv4/tcp_bbr.c > index > 40dc4fc5f6acba91634290e1cacde69a3584248f..dbcc9352a48f07a12484e45f3baf0a733e244f75 > 100644 > --- a/net/ipv4/tcp_bbr.c > +++ b/net/ipv4/tcp_bbr.c > @@ -91,7 +91,7 @@ struct bbr { > struct minmax bw; /* Max recent delivery rate in pkts/uS << 24 > */ > u32 rtt_cnt; /* count of packet-timed rounds elapsed */ > u32 next_rtt_delivered; /* scb->tx.delivered at end of round */ > - struct skb_mstamp cycle_mstamp; /* time of this cycle phase start */ > + u64 cycle_mstamp; /* time of this cycle phase start */ > u32 mode:3, /* current bbr_mode in state machine */ > prev_ca_state:3, /* CA state on previous ACK */ > packet_conservation:1, /* use packet conservation? */ > @@ -411,7 +411,7 @@ static bool bbr_is_next_cycle_phase(struct sock *sk, > struct tcp_sock *tp = tcp_sk(sk); > struct bbr *bbr = inet_csk_ca(sk); > bool is_full_length = > - skb_mstamp_us_delta(&tp->delivered_mstamp, > &bbr->cycle_mstamp) > > + tcp_stamp_us_delta(tp->delivered_mstamp, bbr->cycle_mstamp) > > bbr->min_rtt_us; > u32 inflight, bw; > > @@ -497,7 +497,7 @@ static void bbr_reset_lt_bw_sampling_interval(struct sock > *sk) > struct tcp_sock *tp = tcp_sk(sk); > struct bbr *bbr = inet_csk_ca(sk); > > - bbr->lt_last_stamp = tp->delivered_mstamp.stamp_jiffies; > + bbr->lt_last_stamp = div_u64(tp->delivered_mstamp, USEC_PER_MSEC); > bbr->lt_last_delivered = tp->delivered; > bbr->lt_last_lost = tp->lost; > bbr->lt_rtt_cnt = 0; > @@ -551,7 +551,7 @@ static void bbr_lt_bw_sampling(struct sock *sk, const > struct rate_sample *rs) > struct bbr *bbr = inet_csk_ca(sk); > u32 lost, delivered; > u64 bw; > - s32 t; > + u32 t; > > if (bbr->lt_use_bw) { /* already using long-term rate, lt_bw? */ > if (bbr->mode == BBR_PROBE_BW && bbr->round_start && > @@ -603,15 +603,15 @@ static void bbr_lt_bw_sampling(struct sock *sk, const > struct rate_sample *rs) > return; > > /* Find average delivery rate in this sampling interval. */ > - t = (s32)(tp->delivered_mstamp.stamp_jiffies - bbr->lt_last_stamp); > - if (t < 1) > - return; /* interval is less than one jiffy, so wait */ > - t = jiffies_to_usecs(t); > - /* Interval long enough for jiffies_to_usecs() to return a bogus 0? */ > - if (t < 1) { > + t = div_u64(tp->delivered_mstamp, USEC_PER_MSEC) - bbr->lt_last_stamp; > + if ((s32)t < 1) > + return; /* interval is less than one ms, so wait */ > + /* Check if can multiply without overflow */ > + if (t >= ~0U / USEC_PER_MSEC) { > bbr_reset_lt_bw_sampling(sk); /* interval too long; reset */ > return; > } > + t *= USEC_PER_MSEC; > bw = (u64)delivered * BW_UNIT; > do_div(bw, t); > bbr_lt_bw_interval_done(sk, bw); > @@ -825,7 +825,7 @@ static void bbr_init(struct sock *sk) > bbr->idle_restart = 0; > bbr->full_bw = 0; > bbr->full_bw_cnt = 0; > - bbr->cycle_mstamp.v64 = 0; > + bbr->cycle_mstamp = 0; > bbr->cycle_idx = 0; > bbr_reset_lt_bw_sampling(sk); > bbr_reset_startup_mode(sk); > diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c > index > 10e6775464f647a65ea0d19c10b421f9cd38923d..9a5a9e8eda899666501cca06b37948ab64ae79b2 > 100644 > --- a/net/ipv4/tcp_input.c > +++ b/net/ipv4/tcp_input.c > @@ -441,7 +441,7 @@ void tcp_init_buffer_space(struct sock *sk) > tcp_sndbuf_expand(sk); > > tp->rcvq_space.space = tp->rcv_wnd; > - skb_mstamp_get(&tp->tcp_mstamp); > + tcp_mstamp_refresh(tp); > tp->rcvq_space.time = tp->tcp_mstamp; > tp->rcvq_space.seq = tp->copied_seq; > > @@ -555,11 +555,11 @@ static inline void tcp_rcv_rtt_measure(struct tcp_sock > *tp) > { > u32 delta_us; > > - if (tp->rcv_rtt_est.time.v64 == 0) > + if (tp->rcv_rtt_est.time == 0) > goto new_measure; > if (before(tp->rcv_nxt, tp->rcv_rtt_est.seq)) > return; > - delta_us = skb_mstamp_us_delta(&tp->tcp_mstamp, > &tp->rcv_rtt_est.time); > + delta_us = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcv_rtt_est.time); > tcp_rcv_rtt_update(tp, delta_us, 1); > > new_measure: > @@ -571,13 +571,15 @@ static inline void tcp_rcv_rtt_measure_ts(struct sock > *sk, > const struct sk_buff *skb) > { > struct tcp_sock *tp = tcp_sk(sk); > + > if (tp->rx_opt.rcv_tsecr && > (TCP_SKB_CB(skb)->end_seq - > - TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss)) > - tcp_rcv_rtt_update(tp, > - jiffies_to_usecs(tcp_time_stamp - > - tp->rx_opt.rcv_tsecr), > - 0); > + TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss)) { > + u32 delta = tcp_time_stamp(tp) - tp->rx_opt.rcv_tsecr; > + u32 delta_us = delta * (USEC_PER_SEC / TCP_TS_HZ); > + > + tcp_rcv_rtt_update(tp, delta_us, 0); > + } > } > > /* > @@ -590,7 +592,7 @@ void tcp_rcv_space_adjust(struct sock *sk) > int time; > int copied; > > - time = skb_mstamp_us_delta(&tp->tcp_mstamp, &tp->rcvq_space.time); > + time = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcvq_space.time); > if (time < (tp->rcv_rtt_est.rtt_us >> 3) || tp->rcv_rtt_est.rtt_us == > 0) > return; > > @@ -1134,8 +1136,8 @@ struct tcp_sacktag_state { > * that was SACKed. RTO needs the earliest RTT to stay conservative, > * but congestion control should still get an accurate delay signal. > */ > - struct skb_mstamp first_sackt; > - struct skb_mstamp last_sackt; > + u64 first_sackt; > + u64 last_sackt; > struct rate_sample *rate; > int flag; > }; > @@ -1200,7 +1202,7 @@ static u8 tcp_sacktag_one(struct sock *sk, > struct tcp_sacktag_state *state, u8 sacked, > u32 start_seq, u32 end_seq, > int dup_sack, int pcount, > - const struct skb_mstamp *xmit_time) > + u64 xmit_time) > { > struct tcp_sock *tp = tcp_sk(sk); > int fack_count = state->fack_count; > @@ -1242,9 +1244,9 @@ static u8 tcp_sacktag_one(struct sock *sk, > state->reord); > if (!after(end_seq, tp->high_seq)) > state->flag |= FLAG_ORIG_SACK_ACKED; > - if (state->first_sackt.v64 == 0) > - state->first_sackt = *xmit_time; > - state->last_sackt = *xmit_time; > + if (state->first_sackt == 0) > + state->first_sackt = xmit_time; > + state->last_sackt = xmit_time; > } > > if (sacked & TCPCB_LOST) { > @@ -1304,7 +1306,7 @@ static bool tcp_shifted_skb(struct sock *sk, struct > sk_buff *skb, > */ > tcp_sacktag_one(sk, state, TCP_SKB_CB(skb)->sacked, > start_seq, end_seq, dup_sack, pcount, > - &skb->skb_mstamp); > + skb->skb_mstamp); > tcp_rate_skb_delivered(sk, skb, state->rate); > > if (skb == tp->lost_skb_hint) > @@ -1356,8 +1358,8 @@ static bool tcp_shifted_skb(struct sock *sk, struct > sk_buff *skb, > tcp_advance_highest_sack(sk, skb); > > tcp_skb_collapse_tstamp(prev, skb); > - if (unlikely(TCP_SKB_CB(prev)->tx.delivered_mstamp.v64)) > - TCP_SKB_CB(prev)->tx.delivered_mstamp.v64 = 0; > + if (unlikely(TCP_SKB_CB(prev)->tx.delivered_mstamp)) > + TCP_SKB_CB(prev)->tx.delivered_mstamp = 0; > > tcp_unlink_write_queue(skb, sk); > sk_wmem_free_skb(sk, skb); > @@ -1587,7 +1589,7 @@ static struct sk_buff *tcp_sacktag_walk(struct sk_buff > *skb, struct sock *sk, > TCP_SKB_CB(skb)->end_seq, > dup_sack, > tcp_skb_pcount(skb), > - &skb->skb_mstamp); > + skb->skb_mstamp); > tcp_rate_skb_delivered(sk, skb, state->rate); > > if (!before(TCP_SKB_CB(skb)->seq, > @@ -2936,9 +2938,12 @@ static inline bool tcp_ack_update_rtt(struct sock *sk, > const int flag, > * See draft-ietf-tcplw-high-performance-00, section 3.3. > */ > if (seq_rtt_us < 0 && tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr && > - flag & FLAG_ACKED) > - seq_rtt_us = ca_rtt_us = jiffies_to_usecs(tcp_time_stamp - > - > tp->rx_opt.rcv_tsecr); > + flag & FLAG_ACKED) { > + u32 delta = tcp_time_stamp(tp) - tp->rx_opt.rcv_tsecr; > + u32 delta_us = delta * (USEC_PER_SEC / TCP_TS_HZ); > + > + seq_rtt_us = ca_rtt_us = delta_us; > + } > if (seq_rtt_us < 0) > return false; > > @@ -2960,12 +2965,8 @@ void tcp_synack_rtt_meas(struct sock *sk, struct > request_sock *req) > { > long rtt_us = -1L; > > - if (req && !req->num_retrans && tcp_rsk(req)->snt_synack.v64) { > - struct skb_mstamp now; > - > - skb_mstamp_get(&now); > - rtt_us = skb_mstamp_us_delta(&now, &tcp_rsk(req)->snt_synack); > - } > + if (req && !req->num_retrans && tcp_rsk(req)->snt_synack) > + rtt_us = tcp_stamp_us_delta(tcp_clock_us(), > tcp_rsk(req)->snt_synack); > > tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, rtt_us, -1L, rtt_us); > } > @@ -3003,7 +3004,7 @@ void tcp_rearm_rto(struct sock *sk) > struct sk_buff *skb = tcp_write_queue_head(sk); > const u32 rto_time_stamp = > tcp_skb_timestamp(skb) + rto; > - s32 delta = (s32)(rto_time_stamp - tcp_time_stamp); > + s32 delta = (s32)(rto_time_stamp - tcp_jiffies32); > /* delta may not be positive if the socket is locked > * when the retrans timer fires and is rescheduled. > */ > @@ -3060,9 +3061,8 @@ static int tcp_clean_rtx_queue(struct sock *sk, int > prior_fackets, > struct tcp_sacktag_state *sack) > { > const struct inet_connection_sock *icsk = inet_csk(sk); > - struct skb_mstamp first_ackt, last_ackt; > + u64 first_ackt, last_ackt; > struct tcp_sock *tp = tcp_sk(sk); > - struct skb_mstamp *now = &tp->tcp_mstamp; > u32 prior_sacked = tp->sacked_out; > u32 reord = tp->packets_out; > bool fully_acked = true; > @@ -3075,7 +3075,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, int > prior_fackets, > bool rtt_update; > int flag = 0; > > - first_ackt.v64 = 0; > + first_ackt = 0; > > while ((skb = tcp_write_queue_head(sk)) && skb != tcp_send_head(sk)) { > struct tcp_skb_cb *scb = TCP_SKB_CB(skb); > @@ -3106,8 +3106,8 @@ static int tcp_clean_rtx_queue(struct sock *sk, int > prior_fackets, > flag |= FLAG_RETRANS_DATA_ACKED; > } else if (!(sacked & TCPCB_SACKED_ACKED)) { > last_ackt = skb->skb_mstamp; > - WARN_ON_ONCE(last_ackt.v64 == 0); > - if (!first_ackt.v64) > + WARN_ON_ONCE(last_ackt == 0); > + if (!first_ackt) > first_ackt = last_ackt; > > last_in_flight = TCP_SKB_CB(skb)->tx.in_flight; > @@ -3122,7 +3122,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, int > prior_fackets, > tp->delivered += acked_pcount; > if (!tcp_skb_spurious_retrans(tp, skb)) > tcp_rack_advance(tp, sacked, scb->end_seq, > - &skb->skb_mstamp); > + skb->skb_mstamp); > } > if (sacked & TCPCB_LOST) > tp->lost_out -= acked_pcount; > @@ -3165,13 +3165,13 @@ static int tcp_clean_rtx_queue(struct sock *sk, int > prior_fackets, > if (skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)) > flag |= FLAG_SACK_RENEGING; > > - if (likely(first_ackt.v64) && !(flag & FLAG_RETRANS_DATA_ACKED)) { > - seq_rtt_us = skb_mstamp_us_delta(now, &first_ackt); > - ca_rtt_us = skb_mstamp_us_delta(now, &last_ackt); > + if (likely(first_ackt) && !(flag & FLAG_RETRANS_DATA_ACKED)) { > + seq_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, first_ackt); > + ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, last_ackt); > } > - if (sack->first_sackt.v64) { > - sack_rtt_us = skb_mstamp_us_delta(now, &sack->first_sackt); > - ca_rtt_us = skb_mstamp_us_delta(now, &sack->last_sackt); > + if (sack->first_sackt) { > + sack_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, > sack->first_sackt); > + ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, > sack->last_sackt); > } > sack->rate->rtt_us = ca_rtt_us; /* RTT of last (S)ACKed packet, or -1 > */ > rtt_update = tcp_ack_update_rtt(sk, flag, seq_rtt_us, sack_rtt_us, > @@ -3201,7 +3201,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, int > prior_fackets, > tp->fackets_out -= min(pkts_acked, tp->fackets_out); > > } else if (skb && rtt_update && sack_rtt_us >= 0 && > - sack_rtt_us > skb_mstamp_us_delta(now, &skb->skb_mstamp)) { > + sack_rtt_us > tcp_stamp_us_delta(tp->tcp_mstamp, > skb->skb_mstamp)) { > /* Do not re-arm RTO if the sack RTT is measured from data > sent > * after when the head was last (re)transmitted. Otherwise the > * timeout may continue to extend in loss recovery. > @@ -3553,7 +3553,7 @@ static int tcp_ack(struct sock *sk, const struct > sk_buff *skb, int flag) > int acked = 0; /* Number of packets newly acked */ > int rexmit = REXMIT_NONE; /* Flag to (re)transmit to recover losses */ > > - sack_state.first_sackt.v64 = 0; > + sack_state.first_sackt = 0; > sack_state.rate = &rs; > > /* We very likely will need to access write queue head. */ > @@ -5356,7 +5356,7 @@ void tcp_rcv_established(struct sock *sk, struct > sk_buff *skb, > { > struct tcp_sock *tp = tcp_sk(sk); > > - skb_mstamp_get(&tp->tcp_mstamp); > + tcp_mstamp_refresh(tp); > if (unlikely(!sk->sk_rx_dst)) > inet_csk(sk)->icsk_af_ops->sk_rx_dst_set(sk, skb); > /* > @@ -5672,7 +5672,7 @@ static int tcp_rcv_synsent_state_process(struct sock > *sk, struct sk_buff *skb, > > if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr && > !between(tp->rx_opt.rcv_tsecr, tp->retrans_stamp, > - tcp_time_stamp)) { > + tcp_time_stamp(tp))) { > NET_INC_STATS(sock_net(sk), > LINUX_MIB_PAWSACTIVEREJECTED); > goto reset_and_undo; > @@ -5917,7 +5917,7 @@ int tcp_rcv_state_process(struct sock *sk, struct > sk_buff *skb) > > case TCP_SYN_SENT: > tp->rx_opt.saw_tstamp = 0; > - skb_mstamp_get(&tp->tcp_mstamp); > + tcp_mstamp_refresh(tp); > queued = tcp_rcv_synsent_state_process(sk, skb, th); > if (queued >= 0) > return queued; > @@ -5929,7 +5929,7 @@ int tcp_rcv_state_process(struct sock *sk, struct > sk_buff *skb) > return 0; > } > > - skb_mstamp_get(&tp->tcp_mstamp); > + tcp_mstamp_refresh(tp); > tp->rx_opt.saw_tstamp = 0; > req = tp->fastopen_rsk; > if (req) { > @@ -6202,7 +6202,7 @@ static void tcp_openreq_init(struct request_sock *req, > req->cookie_ts = 0; > tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq; > tcp_rsk(req)->rcv_nxt = TCP_SKB_CB(skb)->seq + 1; > - skb_mstamp_get(&tcp_rsk(req)->snt_synack); > + tcp_rsk(req)->snt_synack = tcp_clock_us(); > tcp_rsk(req)->last_oow_ack_time = 0; > req->mss = rx_opt->mss_clamp; > req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0; > diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c > index > d8fe25db79f223e3fde85882effd2ac6ec15f8ca..191b2f78b19d2c8d62c59cc046bd608687679619 > 100644 > --- a/net/ipv4/tcp_ipv4.c > +++ b/net/ipv4/tcp_ipv4.c > @@ -376,8 +376,9 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) > struct sock *sk; > struct sk_buff *skb; > struct request_sock *fastopen; > - __u32 seq, snd_una; > - __u32 remaining; > + u32 seq, snd_una; > + s32 remaining; > + u32 delta_us; > int err; > struct net *net = dev_net(icmp_skb->dev); > > @@ -483,12 +484,12 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info) > skb = tcp_write_queue_head(sk); > BUG_ON(!skb); > > - skb_mstamp_get(&tp->tcp_mstamp); > + tcp_mstamp_refresh(tp); > + delta_us = (u32)(tp->tcp_mstamp - skb->skb_mstamp); > remaining = icsk->icsk_rto - > - min(icsk->icsk_rto, > - tcp_time_stamp - tcp_skb_timestamp(skb)); > + usecs_to_jiffies(delta_us); > > - if (remaining) { > + if (remaining > 0) { > inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, > remaining, TCP_RTO_MAX); > } else { > @@ -812,7 +813,7 @@ static void tcp_v4_timewait_ack(struct sock *sk, struct > sk_buff *skb) > tcp_v4_send_ack(sk, skb, > tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt, > tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, > - tcp_time_stamp + tcptw->tw_ts_offset, > + tcp_time_stamp_raw() + tcptw->tw_ts_offset, > tcptw->tw_ts_recent, > tw->tw_bound_dev_if, > tcp_twsk_md5_key(tcptw), > @@ -840,7 +841,7 @@ static void tcp_v4_reqsk_send_ack(const struct sock *sk, > struct sk_buff *skb, > tcp_v4_send_ack(sk, skb, seq, > tcp_rsk(req)->rcv_nxt, > req->rsk_rcv_wnd >> inet_rsk(req)->rcv_wscale, > - tcp_time_stamp + tcp_rsk(req)->ts_off, > + tcp_time_stamp_raw() + tcp_rsk(req)->ts_off, > req->ts_recent, > 0, > tcp_md5_do_lookup(sk, (union tcp_md5_addr > *)&ip_hdr(skb)->daddr, > diff --git a/net/ipv4/tcp_lp.c b/net/ipv4/tcp_lp.c > index > ef3122abb3734a63011fba035f7a7aae431da8de..ae10ed64fe13c5278161f92ccecb51653c87db5e > 100644 > --- a/net/ipv4/tcp_lp.c > +++ b/net/ipv4/tcp_lp.c > @@ -37,7 +37,7 @@ > #include <net/tcp.h> > > /* resolution of owd */ > -#define LP_RESOL 1000 > +#define LP_RESOL TCP_TS_HZ > > /** > * enum tcp_lp_state > @@ -147,9 +147,9 @@ static u32 tcp_lp_remote_hz_estimator(struct sock *sk) > tp->rx_opt.rcv_tsecr == lp->local_ref_time) > goto out; > > - m = HZ * (tp->rx_opt.rcv_tsval - > - lp->remote_ref_time) / (tp->rx_opt.rcv_tsecr - > - lp->local_ref_time); > + m = TCP_TS_HZ * > + (tp->rx_opt.rcv_tsval - lp->remote_ref_time) / > + (tp->rx_opt.rcv_tsecr - lp->local_ref_time); > if (m < 0) > m = -m; > > @@ -194,7 +194,7 @@ static u32 tcp_lp_owd_calculator(struct sock *sk) > if (lp->flag & LP_VALID_RHZ) { > owd = > tp->rx_opt.rcv_tsval * (LP_RESOL / lp->remote_hz) - > - tp->rx_opt.rcv_tsecr * (LP_RESOL / HZ); > + tp->rx_opt.rcv_tsecr * (LP_RESOL / TCP_TS_HZ); > if (owd < 0) > owd = -owd; > } > @@ -264,7 +264,7 @@ static void tcp_lp_pkts_acked(struct sock *sk, const > struct ack_sample *sample) > { > struct tcp_sock *tp = tcp_sk(sk); > struct lp *lp = inet_csk_ca(sk); > - u32 now = tcp_time_stamp; > + u32 now = tcp_time_stamp(tp); > u32 delta; > > if (sample->rtt_us > 0) > diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c > index > 6504f1082bdfda77bfc1b53d0d85928e5083a24e..d0642df7304452b57d2bc7f92a0a0c6d821553d3 > 100644 > --- a/net/ipv4/tcp_minisocks.c > +++ b/net/ipv4/tcp_minisocks.c > @@ -455,7 +455,7 @@ struct sock *tcp_create_openreq_child(const struct sock > *sk, > newtp->fackets_out = 0; > newtp->snd_ssthresh = TCP_INFINITE_SSTHRESH; > newtp->tlp_high_seq = 0; > - newtp->lsndtime = treq->snt_synack.stamp_jiffies; > + newtp->lsndtime = tcp_jiffies32; > newsk->sk_txhash = treq->txhash; > newtp->last_oow_ack_time = 0; > newtp->total_retrans = req->num_retrans; > @@ -526,7 +526,7 @@ struct sock *tcp_create_openreq_child(const struct sock > *sk, > newtp->fastopen_req = NULL; > newtp->fastopen_rsk = NULL; > newtp->syn_data_acked = 0; > - newtp->rack.mstamp.v64 = 0; > + newtp->rack.mstamp = 0; > newtp->rack.advanced = 0; > > __TCP_INC_STATS(sock_net(sk), TCP_MIB_PASSIVEOPENS); > diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c > index > 65472e931a0b79f7078a4da7db802dfcc32c7621..478f75baee31d28b4e3122f7635cd1addf20cb98 > 100644 > --- a/net/ipv4/tcp_output.c > +++ b/net/ipv4/tcp_output.c > @@ -1962,7 +1962,7 @@ static bool tcp_tso_should_defer(struct sock *sk, > struct sk_buff *skb, > > head = tcp_write_queue_head(sk); > > - age = skb_mstamp_us_delta(&tp->tcp_mstamp, &head->skb_mstamp); > + age = tcp_stamp_us_delta(tp->tcp_mstamp, head->skb_mstamp); > /* If next ACK is likely to come too late (half srtt), do not defer */ > if (age < (tp->srtt_us >> 4)) > goto send_now; > @@ -2279,7 +2279,7 @@ static bool tcp_write_xmit(struct sock *sk, unsigned > int mss_now, int nonagle, > } > > max_segs = tcp_tso_segs(sk, mss_now); > - skb_mstamp_get(&tp->tcp_mstamp); > + tcp_mstamp_refresh(tp); > while ((skb = tcp_send_head(sk))) { > unsigned int limit; > > @@ -3095,7 +3095,7 @@ void tcp_send_active_reset(struct sock *sk, gfp_t > priority) > skb_reserve(skb, MAX_TCP_HEADER); > tcp_init_nondata_skb(skb, tcp_acceptable_seq(sk), > TCPHDR_ACK | TCPHDR_RST); > - skb_mstamp_get(&tcp_sk(sk)->tcp_mstamp); > + tcp_mstamp_refresh(tcp_sk(sk)); > /* Send it off. */ > if (tcp_transmit_skb(sk, skb, 0, priority)) > NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTFAILED); > @@ -3191,10 +3191,10 @@ struct sk_buff *tcp_make_synack(const struct sock > *sk, struct dst_entry *dst, > memset(&opts, 0, sizeof(opts)); > #ifdef CONFIG_SYN_COOKIES > if (unlikely(req->cookie_ts)) > - skb->skb_mstamp.stamp_jiffies = cookie_init_timestamp(req); > + skb->skb_mstamp = cookie_init_timestamp(req); > else > #endif > - skb_mstamp_get(&skb->skb_mstamp); > + skb->skb_mstamp = tcp_clock_us(); > > #ifdef CONFIG_TCP_MD5SIG > rcu_read_lock(); > @@ -3453,8 +3453,8 @@ int tcp_connect(struct sock *sk) > return -ENOBUFS; > > tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN); > - skb_mstamp_get(&tp->tcp_mstamp); > - tp->retrans_stamp = tp->tcp_mstamp.stamp_jiffies; > + tcp_mstamp_refresh(tp); > + tp->retrans_stamp = tcp_time_stamp(tp); > tcp_connect_queue_skb(sk, buff); > tcp_ecn_send_syn(sk, buff); > > @@ -3615,7 +3615,7 @@ void tcp_send_window_probe(struct sock *sk) > { > if (sk->sk_state == TCP_ESTABLISHED) { > tcp_sk(sk)->snd_wl1 = tcp_sk(sk)->rcv_nxt - 1; > - skb_mstamp_get(&tcp_sk(sk)->tcp_mstamp); > + tcp_mstamp_refresh(tcp_sk(sk)); > tcp_xmit_probe_skb(sk, 0, LINUX_MIB_TCPWINPROBE); > } > } > diff --git a/net/ipv4/tcp_rate.c b/net/ipv4/tcp_rate.c > index > c6a9fa8946462100947ab62d86464ff8f99565c2..ad99569d4c1e2c7f0522645217a6f42e0c4155d6 > 100644 > --- a/net/ipv4/tcp_rate.c > +++ b/net/ipv4/tcp_rate.c > @@ -78,7 +78,7 @@ void tcp_rate_skb_delivered(struct sock *sk, struct sk_buff > *skb, > struct tcp_sock *tp = tcp_sk(sk); > struct tcp_skb_cb *scb = TCP_SKB_CB(skb); > > - if (!scb->tx.delivered_mstamp.v64) > + if (!scb->tx.delivered_mstamp) > return; > > if (!rs->prior_delivered || > @@ -89,9 +89,9 @@ void tcp_rate_skb_delivered(struct sock *sk, struct sk_buff > *skb, > rs->is_retrans = scb->sacked & TCPCB_RETRANS; > > /* Find the duration of the "send phase" of this window: */ > - rs->interval_us = skb_mstamp_us_delta( > - &skb->skb_mstamp, > - &scb->tx.first_tx_mstamp); > + rs->interval_us = tcp_stamp_us_delta( > + skb->skb_mstamp, > + scb->tx.first_tx_mstamp); > > /* Record send time of most recently ACKed packet: */ > tp->first_tx_mstamp = skb->skb_mstamp; > @@ -101,7 +101,7 @@ void tcp_rate_skb_delivered(struct sock *sk, struct > sk_buff *skb, > * we don't need to reset since it'll be freed soon. > */ > if (scb->sacked & TCPCB_SACKED_ACKED) > - scb->tx.delivered_mstamp.v64 = 0; > + scb->tx.delivered_mstamp = 0; > } > > /* Update the connection delivery information and generate a rate sample. */ > @@ -125,7 +125,7 @@ void tcp_rate_gen(struct sock *sk, u32 delivered, u32 > lost, > rs->acked_sacked = delivered; /* freshly ACKed or SACKed */ > rs->losses = lost; /* freshly marked lost */ > /* Return an invalid sample if no timing information is available. */ > - if (!rs->prior_mstamp.v64) { > + if (!rs->prior_mstamp) { > rs->delivered = -1; > rs->interval_us = -1; > return; > @@ -138,8 +138,8 @@ void tcp_rate_gen(struct sock *sk, u32 delivered, u32 > lost, > * longer phase. > */ > snd_us = rs->interval_us; /* send phase > */ > - ack_us = skb_mstamp_us_delta(&tp->tcp_mstamp, > - &rs->prior_mstamp); /* ack phase */ > + ack_us = tcp_stamp_us_delta(tp->tcp_mstamp, > + rs->prior_mstamp); /* ack phase */ > rs->interval_us = max(snd_us, ack_us); > > /* Normally we expect interval_us >= min-rtt. > diff --git a/net/ipv4/tcp_recovery.c b/net/ipv4/tcp_recovery.c > index > cd72b3d3879e88181c8a4639f0334a24e4cda852..fe9a493d02082d3830f37854d5f169f769844ffb > 100644 > --- a/net/ipv4/tcp_recovery.c > +++ b/net/ipv4/tcp_recovery.c > @@ -17,12 +17,9 @@ static void tcp_rack_mark_skb_lost(struct sock *sk, struct > sk_buff *skb) > } > } > > -static bool tcp_rack_sent_after(const struct skb_mstamp *t1, > - const struct skb_mstamp *t2, > - u32 seq1, u32 seq2) > +static bool tcp_rack_sent_after(u64 t1, u64 t2, u32 seq1, u32 seq2) > { > - return skb_mstamp_after(t1, t2) || > - (t1->v64 == t2->v64 && after(seq1, seq2)); > + return t1 > t2 || (t1 == t2 && after(seq1, seq2)); > } > > /* RACK loss detection (IETF draft draft-ietf-tcpm-rack-01): > @@ -72,14 +69,14 @@ static void tcp_rack_detect_loss(struct sock *sk, u32 > *reo_timeout) > scb->sacked & TCPCB_SACKED_ACKED) > continue; > > - if (tcp_rack_sent_after(&tp->rack.mstamp, &skb->skb_mstamp, > + if (tcp_rack_sent_after(tp->rack.mstamp, skb->skb_mstamp, > tp->rack.end_seq, scb->end_seq)) { > /* Step 3 in draft-cheng-tcpm-rack-00.txt: > * A packet is lost if its elapsed time is beyond > * the recent RTT plus the reordering window. > */ > - u32 elapsed = skb_mstamp_us_delta(&tp->tcp_mstamp, > - &skb->skb_mstamp); > + u32 elapsed = tcp_stamp_us_delta(tp->tcp_mstamp, > + skb->skb_mstamp); > s32 remaining = tp->rack.rtt_us + reo_wnd - elapsed; > > if (remaining < 0) { > @@ -127,16 +124,16 @@ void tcp_rack_mark_lost(struct sock *sk) > * draft-cheng-tcpm-rack-00.txt > */ > void tcp_rack_advance(struct tcp_sock *tp, u8 sacked, u32 end_seq, > - const struct skb_mstamp *xmit_time) > + u64 xmit_time) > { > u32 rtt_us; > > - if (tp->rack.mstamp.v64 && > - !tcp_rack_sent_after(xmit_time, &tp->rack.mstamp, > + if (tp->rack.mstamp && > + !tcp_rack_sent_after(xmit_time, tp->rack.mstamp, > end_seq, tp->rack.end_seq)) > return; > > - rtt_us = skb_mstamp_us_delta(&tp->tcp_mstamp, xmit_time); > + rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, xmit_time); > if (sacked & TCPCB_RETRANS) { > /* If the sacked packet was retransmitted, it's ambiguous > * whether the retransmission or the original (or the prior > @@ -152,7 +149,7 @@ void tcp_rack_advance(struct tcp_sock *tp, u8 sacked, u32 > end_seq, > return; > } > tp->rack.rtt_us = rtt_us; > - tp->rack.mstamp = *xmit_time; > + tp->rack.mstamp = xmit_time; > tp->rack.end_seq = end_seq; > tp->rack.advanced = 1; > } > diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c > index > 6629f47aa7f0182ece7873afcc3daa6f0019e228..27a667bce8060e6b2290fe636c27a79d0d593b48 > 100644 > --- a/net/ipv4/tcp_timer.c > +++ b/net/ipv4/tcp_timer.c > @@ -153,8 +153,8 @@ static bool retransmits_timed_out(struct sock *sk, > unsigned int timeout, > bool syn_set) > { > - unsigned int linear_backoff_thresh, start_ts; > unsigned int rto_base = syn_set ? TCP_TIMEOUT_INIT : TCP_RTO_MIN; > + unsigned int linear_backoff_thresh, start_ts; > > if (!inet_csk(sk)->icsk_retransmits) > return false; > @@ -172,7 +172,7 @@ static bool retransmits_timed_out(struct sock *sk, > timeout = ((2 << linear_backoff_thresh) - 1) * > rto_base + > (boundary - linear_backoff_thresh) * > TCP_RTO_MAX; > } > - return (tcp_time_stamp - start_ts) >= timeout; > + return (tcp_time_stamp(tcp_sk(sk)) - start_ts) >= > jiffies_to_msecs(timeout); > } > > /* A write timeout has occurred. Process the after effects. */ > @@ -341,7 +341,7 @@ static void tcp_probe_timer(struct sock *sk) > if (!start_ts) > tcp_send_head(sk)->skb_mstamp = tp->tcp_mstamp; > else if (icsk->icsk_user_timeout && > - (s32)(tcp_time_stamp - start_ts) > icsk->icsk_user_timeout) > + (s32)(tcp_time_stamp(tp) - start_ts) > > icsk->icsk_user_timeout) > goto abort; > > max_probes = sock_net(sk)->ipv4.sysctl_tcp_retries2; > @@ -561,7 +561,7 @@ void tcp_write_timer_handler(struct sock *sk) > goto out; > } > > - skb_mstamp_get(&tcp_sk(sk)->tcp_mstamp); > + tcp_mstamp_refresh(tcp_sk(sk)); > event = icsk->icsk_pending; > > switch (event) { > diff --git a/net/ipv6/syncookies.c b/net/ipv6/syncookies.c > index > 5abc3692b9011b140816dc4ce6223e79e5defddb..971823359f5b98da46c39b86c9ddcefd14df8559 > 100644 > --- a/net/ipv6/syncookies.c > +++ b/net/ipv6/syncookies.c > @@ -211,7 +211,7 @@ struct sock *cookie_v6_check(struct sock *sk, struct > sk_buff *skb) > ireq->wscale_ok = tcp_opt.wscale_ok; > ireq->tstamp_ok = tcp_opt.saw_tstamp; > req->ts_recent = tcp_opt.saw_tstamp ? tcp_opt.rcv_tsval : 0; > - treq->snt_synack.v64 = 0; > + treq->snt_synack = 0; > treq->rcv_isn = ntohl(th->seq) - 1; > treq->snt_isn = cookie; > treq->ts_off = 0; > diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c > index > 4f4310a36a0481e2bd068e39285011ff28377ea5..233edfabe1dbceaeb6cdd42a2bb379072aeee361 > 100644 > --- a/net/ipv6/tcp_ipv6.c > +++ b/net/ipv6/tcp_ipv6.c > @@ -949,7 +949,7 @@ static void tcp_v6_timewait_ack(struct sock *sk, struct > sk_buff *skb) > > tcp_v6_send_ack(sk, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt, > tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, > - tcp_time_stamp + tcptw->tw_ts_offset, > + tcp_time_stamp_raw() + tcptw->tw_ts_offset, > tcptw->tw_ts_recent, tw->tw_bound_dev_if, > tcp_twsk_md5_key(tcptw), > tw->tw_tclass, cpu_to_be32(tw->tw_flowlabel)); > > @@ -971,7 +971,7 @@ static void tcp_v6_reqsk_send_ack(const struct sock *sk, > struct sk_buff *skb, > tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt, > tcp_rsk(req)->rcv_nxt, > req->rsk_rcv_wnd >> inet_rsk(req)->rcv_wscale, > - tcp_time_stamp + tcp_rsk(req)->ts_off, > + tcp_time_stamp_raw() + tcp_rsk(req)->ts_off, > req->ts_recent, sk->sk_bound_dev_if, > tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr), > 0, 0); > diff --git a/net/netfilter/nf_synproxy_core.c > b/net/netfilter/nf_synproxy_core.c > index > a504e87c6ddff1b1266a901549256f29dc1973d1..49bd8bb16b1817e9e06ee64c889e78a923bfd375 > 100644 > --- a/net/netfilter/nf_synproxy_core.c > +++ b/net/netfilter/nf_synproxy_core.c > @@ -152,7 +152,7 @@ void synproxy_init_timestamp_cookie(const struct > xt_synproxy_info *info, > struct synproxy_options *opts) > { > opts->tsecr = opts->tsval; > - opts->tsval = tcp_time_stamp & ~0x3f; > + opts->tsval = tcp_time_stamp_raw() & ~0x3f; > > if (opts->options & XT_SYNPROXY_OPT_WSCALE) { > opts->tsval |= opts->wscale; > -- > 2.13.0.303.g4ebf302169-goog >