| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Date: Wed, 17 May 2017 09:51:48 -0400
From: Soheil Hassas Yeganeh <soheil@...gle.com>
To: Eric Dumazet <edumazet@...gle.com>
Cc: "David S . Miller" <davem@...emloft.net>,
Neal Cardwell <ncardwell@...gle.com>,
Yuchung Cheng <ycheng@...gle.com>,
Wei Wang <weiwan@...gle.com>, netdev <netdev@...r.kernel.org>,
Eric Dumazet <eric.dumazet@...il.com>
Subject: Re: [PATCH net-next 15/15] tcp: switch TCP TS option (RFC 7323) to
1ms clock
On Tue, May 16, 2017 at 5:00 PM, Eric Dumazet <edumazet@...gle.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 <edumazet@...gle.com>
Acked-by: Soheil Hassas Yeganeh <soheil@...gle.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
>
Powered by blists - more mailing lists