[Devel] [PATCH RHEL7 COMMIT] ve/net: Revert "ve/net: Virtualize tcp_time_stamp"
Konstantin Khorenko
khorenko at virtuozzo.com
Mon Dec 28 02:35:53 PST 2015
On 12/28/2015 12:58 PM, Konstantin Khorenko wrote:
> The commit is pushed to "branch-rh7-3.10.0-229.7.2.vz7.9.x-ovz" and will appear at https://src.openvz.org/scm/ovz/vzkernel.git
> after rh7-3.10.0-229.7.2.vz7.9.17
The comment is wrong: the patch had been applied to rebased kernel (only),
so it will be available in branch-rh7-3.10.0-237.3.1.vz7.10.x-ovz
> ------>
> commit a14cdd2c8d11dc07bc4b6438fd0ceb995b0497e7
> Author: Kirill Tkhai <ktkhai at odin.com>
> Date: Mon Dec 28 13:58:20 2015 +0400
>
> ve/net: Revert "ve/net: Virtualize tcp_time_stamp"
>
> This reverts commit f54381c3801c3612822b5687960603cee1bf1e6e
> ("ve/net: Virtualize tcp_time_stamp").
>
> which is not need after ms commits:
>
> ee684b6f2830047d19877e5547989740f18b1a5d
> ("tcp: send packets with a socket timestamp")
> 93be6ce0e91b6a94783e012b1857a347a5e6e9f2
> ("tcp: set and get per-socket timestamp")
> ceaa1fef65a7c2e017b260b879b310dd24888083
> ("tcp: adding a per-socket timestamp offset")
>
> These patches are applied in rh 3.10.0-327.3.1.el7 kernel.
>
> https://jira.sw.ru/browse/PSBM-42305
>
> Signed-off-by: Kirill Tkhai <ktkhai at virtuozzo.com>
> ---
> include/linux/ve.h | 1 -
> include/net/netfilter/nf_conntrack_synproxy.h | 3 +-
> include/net/tcp.h | 16 +++-----
> kernel/ve/ve.c | 1 -
> net/dccp/ccids/ccid2.c | 8 ++--
> net/ipv4/netfilter/ipt_SYNPROXY.c | 2 +-
> net/ipv4/syncookies.c | 4 +-
> net/ipv4/tcp.c | 8 ++--
> net/ipv4/tcp_bic.c | 10 ++---
> net/ipv4/tcp_cubic.c | 14 +++----
> net/ipv4/tcp_htcp.c | 2 +-
> net/ipv4/tcp_input.c | 58 +++++++++++++--------------
> net/ipv4/tcp_ipv4.c | 12 +++---
> net/ipv4/tcp_lp.c | 8 ++--
> net/ipv4/tcp_metrics.c | 2 +-
> net/ipv4/tcp_output.c | 38 +++++++++---------
> net/ipv4/tcp_timer.c | 12 +++---
> net/ipv4/tcp_westwood.c | 6 +--
> net/ipv6/netfilter/ip6t_SYNPROXY.c | 2 +-
> net/ipv6/tcp_ipv6.c | 6 +--
> net/netfilter/nf_synproxy_core.c | 5 +--
> 21 files changed, 104 insertions(+), 114 deletions(-)
>
> diff --git a/include/linux/ve.h b/include/linux/ve.h
> index 87450c1..0cffd4c 100644
> --- a/include/linux/ve.h
> +++ b/include/linux/ve.h
> @@ -88,7 +88,6 @@ struct ve_struct {
> struct timespec start_timespec; /* monotonic time */
> struct timespec real_start_timespec; /* boot based time */
> u64 start_jiffies; /* Deprecated */
> - u32 jiffies_fixup;
>
> struct kstat_lat_pcpu_struct sched_lat_ve;
>
> diff --git a/include/net/netfilter/nf_conntrack_synproxy.h b/include/net/netfilter/nf_conntrack_synproxy.h
> index 6ce2360..6793614 100644
> --- a/include/net/netfilter/nf_conntrack_synproxy.h
> +++ b/include/net/netfilter/nf_conntrack_synproxy.h
> @@ -63,8 +63,7 @@ unsigned int synproxy_options_size(const struct synproxy_options *opts);
> void synproxy_build_options(struct tcphdr *th,
> const struct synproxy_options *opts);
>
> -void synproxy_init_timestamp_cookie(struct sock *sk,
> - const struct xt_synproxy_info *info,
> +void synproxy_init_timestamp_cookie(const struct xt_synproxy_info *info,
> struct synproxy_options *opts);
> void synproxy_check_timestamp_cookie(struct synproxy_options *opts);
>
> diff --git a/include/net/tcp.h b/include/net/tcp.h
> index 05a5252..22b8d43 100644
> --- a/include/net/tcp.h
> +++ b/include/net/tcp.h
> @@ -546,7 +546,7 @@ static inline __u32 cookie_v4_init_sequence(struct sock *sk,
> }
> #endif
>
> -extern __u32 cookie_init_timestamp(struct sock *sk, struct request_sock *req);
> +extern __u32 cookie_init_timestamp(struct request_sock *req);
> extern bool cookie_check_timestamp(struct tcp_options_received *opt,
> struct net *net, bool *ecn_ok);
>
> @@ -725,12 +725,7 @@ void tcp_send_window_probe(struct sock *sk);
> * to use only the low 32-bits of jiffies and hide the ugly
> * casts with the following macro.
> */
> -static inline u32 tcp_time_stamp(const struct sock *sk)
> -{
> - struct ve_struct *ve = sock_net(sk)->owner_ve;
> -
> - return (__u32)(jiffies) + ve->jiffies_fixup;
> -}
> +#define tcp_time_stamp ((__u32)(jiffies))
>
> #define tcp_flag_byte(th) (((u_int8_t *)th)[13])
>
> @@ -1154,7 +1149,7 @@ static inline void tcp_synack_rtt_meas(struct sock *sk,
> {
> if (tcp_rsk(req)->snt_synack)
> tcp_valid_rtt_meas(sk,
> - tcp_time_stamp(sk) - tcp_rsk(req)->snt_synack);
> + tcp_time_stamp - tcp_rsk(req)->snt_synack);
> }
>
> extern void tcp_enter_memory_pressure(struct sock *sk);
> @@ -1176,11 +1171,10 @@ static inline int keepalive_probes(const struct tcp_sock *tp)
>
> static inline u32 keepalive_time_elapsed(const struct tcp_sock *tp)
> {
> - const struct sock *sk = (struct sock *)tp;
> const struct inet_connection_sock *icsk = &tp->inet_conn;
>
> - return min_t(u32, tcp_time_stamp(sk) - icsk->icsk_ack.lrcvtime,
> - tcp_time_stamp(sk) - tp->rcv_tstamp);
> + return min_t(u32, tcp_time_stamp - icsk->icsk_ack.lrcvtime,
> + tcp_time_stamp - tp->rcv_tstamp);
> }
>
> static inline int tcp_fin_time(const struct sock *sk)
> diff --git a/kernel/ve/ve.c b/kernel/ve/ve.c
> index 8f5f905..8f59d01 100644
> --- a/kernel/ve/ve.c
> +++ b/kernel/ve/ve.c
> @@ -64,7 +64,6 @@ static DEFINE_PER_CPU(struct kstat_lat_pcpu_snap_struct, ve0_lat_stats);
> struct ve_struct ve0 = {
> .ve_name = "0",
> .start_jiffies = INITIAL_JIFFIES,
> - .jiffies_fixup = 0,
> RCU_POINTER_INITIALIZER(ve_ns, &init_nsproxy),
> .ve_netns = &init_net,
> .is_running = 1,
> diff --git a/net/dccp/ccids/ccid2.c b/net/dccp/ccids/ccid2.c
> index eca2f0a..f053198 100644
> --- a/net/dccp/ccids/ccid2.c
> +++ b/net/dccp/ccids/ccid2.c
> @@ -233,7 +233,7 @@ static void ccid2_hc_tx_packet_sent(struct sock *sk, unsigned int len)
> {
> struct dccp_sock *dp = dccp_sk(sk);
> struct ccid2_hc_tx_sock *hc = ccid2_hc_tx_sk(sk);
> - const u32 now = ccid2_time_stamp(sk);
> + const u32 now = ccid2_time_stamp;
> struct ccid2_seq *next;
>
> /* slow-start after idle periods (RFC 2581, RFC 2861) */
> @@ -466,7 +466,7 @@ static void ccid2_new_ack(struct sock *sk, struct ccid2_seq *seqp,
> * The cleanest solution is to not use the ccid2s_sent field at all
> * and instead use DCCP timestamps: requires changes in other places.
> */
> - ccid2_rtt_estimator(sk, ccid2_time_stamp(sk) - seqp->ccid2s_sent);
> + ccid2_rtt_estimator(sk, ccid2_time_stamp - seqp->ccid2s_sent);
> }
>
> static void ccid2_congestion_event(struct sock *sk, struct ccid2_seq *seqp)
> @@ -478,7 +478,7 @@ static void ccid2_congestion_event(struct sock *sk, struct ccid2_seq *seqp)
> return;
> }
>
> - hc->tx_last_cong = ccid2_time_stamp(sk);
> + hc->tx_last_cong = ccid2_time_stamp;
>
> hc->tx_cwnd = hc->tx_cwnd / 2 ? : 1U;
> hc->tx_ssthresh = max(hc->tx_cwnd, 2U);
> @@ -731,7 +731,7 @@ static int ccid2_hc_tx_init(struct ccid *ccid, struct sock *sk)
>
> hc->tx_rto = DCCP_TIMEOUT_INIT;
> hc->tx_rpdupack = -1;
> - hc->tx_last_cong = hc->tx_lsndtime = hc->tx_cwnd_stamp = ccid2_time_stamp(sk);
> + hc->tx_last_cong = hc->tx_lsndtime = hc->tx_cwnd_stamp = ccid2_time_stamp;
> hc->tx_cwnd_used = 0;
> setup_timer(&hc->tx_rtotimer, ccid2_hc_tx_rto_expire,
> (unsigned long)sk);
> diff --git a/net/ipv4/netfilter/ipt_SYNPROXY.c b/net/ipv4/netfilter/ipt_SYNPROXY.c
> index f67dc09..a313c3f 100644
> --- a/net/ipv4/netfilter/ipt_SYNPROXY.c
> +++ b/net/ipv4/netfilter/ipt_SYNPROXY.c
> @@ -280,7 +280,7 @@ synproxy_tg4(struct sk_buff *skb, const struct xt_action_param *par)
>
> opts.options &= info->options;
> if (opts.options & XT_SYNPROXY_OPT_TIMESTAMP)
> - synproxy_init_timestamp_cookie(skb->sk, info, &opts);
> + synproxy_init_timestamp_cookie(info, &opts);
> else
> opts.options &= ~(XT_SYNPROXY_OPT_WSCALE |
> XT_SYNPROXY_OPT_SACK_PERM |
> diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
> index d7db4f6..3b64c59 100644
> --- a/net/ipv4/syncookies.c
> +++ b/net/ipv4/syncookies.c
> @@ -64,10 +64,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 sock *sk, struct request_sock *req)
> +__u32 cookie_init_timestamp(struct request_sock *req)
> {
> struct inet_request_sock *ireq;
> - u32 ts, ts_now = tcp_time_stamp(sk);
> + u32 ts, ts_now = tcp_time_stamp;
> u32 options = 0;
>
> ireq = inet_rsk(req);
> diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
> index 2d73a57..e853cfa 100644
> --- a/net/ipv4/tcp.c
> +++ b/net/ipv4/tcp.c
> @@ -1143,7 +1143,7 @@ new_segment:
> * already been sent.
> */
> if (tp->repair)
> - TCP_SKB_CB(skb)->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(skb)->when = tcp_time_stamp;
>
> /*
> * Check whether we can use HW checksum.
> @@ -2552,7 +2552,7 @@ static int do_tcp_setsockopt(struct sock *sk, int level,
> if (!tp->repair)
> err = -EPERM;
> else
> - tp->tsoffset = val - tcp_time_stamp(sk);
> + tp->tsoffset = val - tcp_time_stamp;
> break;
> default:
> err = -ENOPROTOOPT;
> @@ -2592,7 +2592,7 @@ void tcp_get_info(const struct sock *sk, struct tcp_info *info)
> {
> const struct tcp_sock *tp = tcp_sk(sk);
> const struct inet_connection_sock *icsk = inet_csk(sk);
> - u32 now = tcp_time_stamp(sk);
> + u32 now = tcp_time_stamp;
>
> memset(info, 0, sizeof(*info));
>
> @@ -2768,7 +2768,7 @@ static int do_tcp_getsockopt(struct sock *sk, int level,
> val = jiffies_to_msecs(icsk->icsk_user_timeout);
> break;
> case TCP_TIMESTAMP:
> - val = tcp_time_stamp(sk) + tp->tsoffset;
> + val = tcp_time_stamp + tp->tsoffset;
> break;
> default:
> return -ENOPROTOOPT;
> diff --git a/net/ipv4/tcp_bic.c b/net/ipv4/tcp_bic.c
> index 184f5ef..f45e1c2 100644
> --- a/net/ipv4/tcp_bic.c
> +++ b/net/ipv4/tcp_bic.c
> @@ -83,17 +83,17 @@ static void bictcp_init(struct sock *sk)
> /*
> * Compute congestion window to use.
> */
> -static inline void bictcp_update(struct sock *sk, struct bictcp *ca, u32 cwnd)
> +static inline void bictcp_update(struct bictcp *ca, u32 cwnd)
> {
> if (ca->last_cwnd == cwnd &&
> - (s32)(tcp_time_stamp(sk) - ca->last_time) <= HZ / 32)
> + (s32)(tcp_time_stamp - ca->last_time) <= HZ / 32)
> return;
>
> ca->last_cwnd = cwnd;
> - ca->last_time = tcp_time_stamp(sk);
> + ca->last_time = tcp_time_stamp;
>
> if (ca->epoch_start == 0) /* record the beginning of an epoch */
> - ca->epoch_start = tcp_time_stamp(sk);
> + ca->epoch_start = tcp_time_stamp;
>
> /* start off normal */
> if (cwnd <= low_window) {
> @@ -151,7 +151,7 @@ static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
> if (tp->snd_cwnd <= tp->snd_ssthresh)
> tcp_slow_start(tp);
> else {
> - bictcp_update(sk, ca, tp->snd_cwnd);
> + bictcp_update(ca, tp->snd_cwnd);
> tcp_cong_avoid_ai(tp, ca->cnt);
> }
>
> diff --git a/net/ipv4/tcp_cubic.c b/net/ipv4/tcp_cubic.c
> index 1441cf1..b6ae92a 100644
> --- a/net/ipv4/tcp_cubic.c
> +++ b/net/ipv4/tcp_cubic.c
> @@ -204,7 +204,7 @@ static u32 cubic_root(u64 a)
> /*
> * Compute congestion window to use.
> */
> -static inline void bictcp_update(struct sock *sk, struct bictcp *ca, u32 cwnd)
> +static inline void bictcp_update(struct bictcp *ca, u32 cwnd)
> {
> u32 delta, bic_target, max_cnt;
> u64 offs, t;
> @@ -212,14 +212,14 @@ static inline void bictcp_update(struct sock *sk, struct bictcp *ca, u32 cwnd)
> ca->ack_cnt++; /* count the number of ACKs */
>
> if (ca->last_cwnd == cwnd &&
> - (s32)(tcp_time_stamp(sk) - ca->last_time) <= HZ / 32)
> + (s32)(tcp_time_stamp - ca->last_time) <= HZ / 32)
> return;
>
> ca->last_cwnd = cwnd;
> - ca->last_time = tcp_time_stamp(sk);
> + ca->last_time = tcp_time_stamp;
>
> if (ca->epoch_start == 0) {
> - ca->epoch_start = tcp_time_stamp(sk); /* record the beginning of an epoch */
> + ca->epoch_start = tcp_time_stamp; /* record the beginning of an epoch */
> ca->ack_cnt = 1; /* start counting */
> ca->tcp_cwnd = cwnd; /* syn with cubic */
>
> @@ -250,7 +250,7 @@ static inline void bictcp_update(struct sock *sk, struct bictcp *ca, u32 cwnd)
> * if the cwnd < 1 million packets !!!
> */
>
> - t = (s32)(tcp_time_stamp(sk) - ca->epoch_start);
> + t = (s32)(tcp_time_stamp - ca->epoch_start);
> t += msecs_to_jiffies(ca->delay_min >> 3);
> /* change the unit from HZ to bictcp_HZ */
> t <<= BICTCP_HZ;
> @@ -317,7 +317,7 @@ static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
> bictcp_hystart_reset(sk);
> tcp_slow_start(tp);
> } else {
> - bictcp_update(sk, ca, tp->snd_cwnd);
> + bictcp_update(ca, tp->snd_cwnd);
> tcp_cong_avoid_ai(tp, ca->cnt);
> }
>
> @@ -416,7 +416,7 @@ static void bictcp_acked(struct sock *sk, u32 cnt, s32 rtt_us)
> return;
>
> /* Discard delay samples right after fast recovery */
> - if (ca->epoch_start && (s32)(tcp_time_stamp(sk) - ca->epoch_start) < HZ)
> + if (ca->epoch_start && (s32)(tcp_time_stamp - ca->epoch_start) < HZ)
> return;
>
> delay = (rtt_us << 3) / USEC_PER_MSEC;
> diff --git a/net/ipv4/tcp_htcp.c b/net/ipv4/tcp_htcp.c
> index a826d1f..c1a8175 100644
> --- a/net/ipv4/tcp_htcp.c
> +++ b/net/ipv4/tcp_htcp.c
> @@ -103,7 +103,7 @@ static void measure_achieved_throughput(struct sock *sk, u32 pkts_acked, s32 rtt
> const struct inet_connection_sock *icsk = inet_csk(sk);
> const struct tcp_sock *tp = tcp_sk(sk);
> struct htcp *ca = inet_csk_ca(sk);
> - u32 now = tcp_time_stamp(sk);
> + u32 now = tcp_time_stamp;
>
> if (icsk->icsk_ca_state == TCP_CA_Open)
> ca->pkts_acked = pkts_acked;
> diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
> index 11ba8f4..84d34c1 100644
> --- a/net/ipv4/tcp_input.c
> +++ b/net/ipv4/tcp_input.c
> @@ -402,7 +402,7 @@ void tcp_init_buffer_space(struct sock *sk)
> tp->window_clamp = max(2 * tp->advmss, maxwin - tp->advmss);
>
> tp->rcv_ssthresh = min(tp->rcv_ssthresh, tp->window_clamp);
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
> }
>
> /* 5. Recalculate window clamp after socket hit its memory bounds. */
> @@ -491,17 +491,17 @@ static void tcp_rcv_rtt_update(struct tcp_sock *tp, u32 sample, int win_dep)
> tp->rcv_rtt_est.rtt = new_sample;
> }
>
> -static inline void tcp_rcv_rtt_measure(struct sock *sk, struct tcp_sock *tp)
> +static inline void tcp_rcv_rtt_measure(struct tcp_sock *tp)
> {
> if (tp->rcv_rtt_est.time == 0)
> goto new_measure;
> if (before(tp->rcv_nxt, tp->rcv_rtt_est.seq))
> return;
> - tcp_rcv_rtt_update(tp, tcp_time_stamp(sk) - tp->rcv_rtt_est.time, 1);
> + tcp_rcv_rtt_update(tp, tcp_time_stamp - tp->rcv_rtt_est.time, 1);
>
> new_measure:
> tp->rcv_rtt_est.seq = tp->rcv_nxt + tp->rcv_wnd;
> - tp->rcv_rtt_est.time = tcp_time_stamp(sk);
> + tp->rcv_rtt_est.time = tcp_time_stamp;
> }
>
> static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
> @@ -511,7 +511,7 @@ static inline void tcp_rcv_rtt_measure_ts(struct sock *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, tcp_time_stamp(sk) - tp->rx_opt.rcv_tsecr, 0);
> + tcp_rcv_rtt_update(tp, tcp_time_stamp - tp->rx_opt.rcv_tsecr, 0);
> }
>
> /*
> @@ -527,7 +527,7 @@ void tcp_rcv_space_adjust(struct sock *sk)
> if (tp->rcvq_space.time == 0)
> goto new_measure;
>
> - time = tcp_time_stamp(sk) - tp->rcvq_space.time;
> + time = tcp_time_stamp - tp->rcvq_space.time;
> if (time < (tp->rcv_rtt_est.rtt >> 3) || tp->rcv_rtt_est.rtt == 0)
> return;
>
> @@ -567,7 +567,7 @@ void tcp_rcv_space_adjust(struct sock *sk)
>
> new_measure:
> tp->rcvq_space.seq = tp->copied_seq;
> - tp->rcvq_space.time = tcp_time_stamp(sk);
> + tp->rcvq_space.time = tcp_time_stamp;
> }
>
> /* There is something which you must keep in mind when you analyze the
> @@ -590,9 +590,9 @@ static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
>
> tcp_measure_rcv_mss(sk, skb);
>
> - tcp_rcv_rtt_measure(sk, tp);
> + tcp_rcv_rtt_measure(tp);
>
> - now = tcp_time_stamp(sk);
> + now = tcp_time_stamp;
>
> if (!icsk->icsk_ack.ato) {
> /* The _first_ data packet received, initialize
> @@ -1882,7 +1882,7 @@ void tcp_enter_loss(struct sock *sk, int how)
> }
> tp->snd_cwnd = 1;
> tp->snd_cwnd_cnt = 0;
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
>
> tcp_clear_retrans_partial(tp);
>
> @@ -1999,7 +1999,7 @@ static bool tcp_pause_early_retransmit(struct sock *sk, int flag)
> static inline int tcp_skb_timedout(const struct sock *sk,
> const struct sk_buff *skb)
> {
> - return tcp_time_stamp(sk) - TCP_SKB_CB(skb)->when > inet_csk(sk)->icsk_rto;
> + return tcp_time_stamp - TCP_SKB_CB(skb)->when > inet_csk(sk)->icsk_rto;
> }
>
> static inline int tcp_head_timedout(const struct sock *sk)
> @@ -2288,11 +2288,11 @@ static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
> /* CWND moderation, preventing bursts due to too big ACKs
> * in dubious situations.
> */
> -static inline void tcp_moderate_cwnd(struct sock *sk, struct tcp_sock *tp)
> +static inline void tcp_moderate_cwnd(struct tcp_sock *tp)
> {
> tp->snd_cwnd = min(tp->snd_cwnd,
> tcp_packets_in_flight(tp) + tcp_max_burst(tp));
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
> }
>
> /* Nothing was retransmitted or returned timestamp is less
> @@ -2385,7 +2385,7 @@ static void tcp_undo_cwr(struct sock *sk, const bool undo_ssthresh)
> } else {
> tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh);
> }
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
> }
>
> static inline bool tcp_may_undo(const struct tcp_sock *tp)
> @@ -2418,7 +2418,7 @@ static bool tcp_try_undo_recovery(struct sock *sk)
> /* Hold old state until something *above* high_seq
> * is ACKed. For Reno it is MUST to prevent false
> * fast retransmits (RFC2582). SACK TCP is safe. */
> - tcp_moderate_cwnd(sk, tp);
> + tcp_moderate_cwnd(tp);
> if (!tcp_any_retrans_done(sk))
> tp->retrans_stamp = 0;
> return true;
> @@ -2556,7 +2556,7 @@ static inline void tcp_end_cwnd_reduction(struct sock *sk)
> if (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR ||
> (tp->undo_marker && tp->snd_ssthresh < TCP_INFINITE_SSTHRESH)) {
> tp->snd_cwnd = tp->snd_ssthresh;
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
> }
> tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
> }
> @@ -2603,7 +2603,7 @@ static void tcp_try_to_open(struct sock *sk, int flag, int newly_acked_sacked)
> if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
> tcp_try_keep_open(sk);
> if (inet_csk(sk)->icsk_ca_state != TCP_CA_Open)
> - tcp_moderate_cwnd(sk, tp);
> + tcp_moderate_cwnd(tp);
> } else {
> tcp_cwnd_reduction(sk, newly_acked_sacked, 0);
> }
> @@ -2628,7 +2628,7 @@ static void tcp_mtup_probe_success(struct sock *sk)
> tcp_mss_to_mtu(sk, tp->mss_cache) /
> icsk->icsk_mtup.probe_size;
> tp->snd_cwnd_cnt = 0;
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
> tp->snd_ssthresh = tcp_current_ssthresh(sk);
>
> icsk->icsk_mtup.search_low = icsk->icsk_mtup.probe_size;
> @@ -2914,7 +2914,7 @@ static void tcp_ack_saw_tstamp(struct sock *sk, int flag)
> */
> struct tcp_sock *tp = tcp_sk(sk);
>
> - tcp_valid_rtt_meas(sk, tcp_time_stamp(sk) - tp->rx_opt.rcv_tsecr);
> + tcp_valid_rtt_meas(sk, tcp_time_stamp - tp->rx_opt.rcv_tsecr);
> }
>
> static void tcp_ack_no_tstamp(struct sock *sk, u32 seq_rtt, int flag)
> @@ -2949,7 +2949,7 @@ static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
> {
> const struct inet_connection_sock *icsk = inet_csk(sk);
> icsk->icsk_ca_ops->cong_avoid(sk, ack, in_flight);
> - tcp_sk(sk)->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tcp_sk(sk)->snd_cwnd_stamp = tcp_time_stamp;
> }
>
> /* Restart timer after forward progress on connection.
> @@ -2975,7 +2975,7 @@ void tcp_rearm_rto(struct sock *sk)
> icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
> struct sk_buff *skb = tcp_write_queue_head(sk);
> const u32 rto_time_stamp = TCP_SKB_CB(skb)->when + rto;
> - s32 delta = (s32)(rto_time_stamp - tcp_time_stamp(sk));
> + s32 delta = (s32)(rto_time_stamp - tcp_time_stamp);
> /* delta may not be positive if the socket is locked
> * when the retrans timer fires and is rescheduled.
> */
> @@ -3036,7 +3036,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
> struct tcp_sock *tp = tcp_sk(sk);
> const struct inet_connection_sock *icsk = inet_csk(sk);
> struct sk_buff *skb;
> - u32 now = tcp_time_stamp(sk);
> + u32 now = tcp_time_stamp;
> int fully_acked = true;
> int flag = 0;
> u32 pkts_acked = 0;
> @@ -3437,7 +3437,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
> */
> sk->sk_err_soft = 0;
> icsk->icsk_probes_out = 0;
> - tp->rcv_tstamp = tcp_time_stamp(sk);
> + tp->rcv_tstamp = tcp_time_stamp;
> if (!prior_packets)
> goto no_queue;
>
> @@ -4725,7 +4725,7 @@ void tcp_cwnd_application_limited(struct sock *sk)
> }
> tp->snd_cwnd_used = 0;
> }
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
> }
>
> static bool tcp_should_expand_sndbuf(const struct sock *sk)
> @@ -4773,7 +4773,7 @@ static void tcp_new_space(struct sock *sk)
> sndmem *= 2 * demanded;
> if (sndmem > sk->sk_sndbuf)
> sk->sk_sndbuf = min(sndmem, sysctl_tcp_wmem[2]);
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
> }
>
> sk->sk_write_space(sk);
> @@ -5287,7 +5287,7 @@ void tcp_finish_connect(struct sock *sk, struct sk_buff *skb)
> /* Prevent spurious tcp_cwnd_restart() on first data
> * packet.
> */
> - tp->lsndtime = tcp_time_stamp(sk);
> + tp->lsndtime = tcp_time_stamp;
>
> tcp_init_buffer_space(sk);
>
> @@ -5374,7 +5374,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(sk))) {
> + tcp_time_stamp)) {
> NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSACTIVEREJECTED);
> goto reset_and_undo;
> }
> @@ -5471,7 +5471,7 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
> * to stand against the temptation 8) --ANK
> */
> inet_csk_schedule_ack(sk);
> - icsk->icsk_ack.lrcvtime = tcp_time_stamp(sk);
> + icsk->icsk_ack.lrcvtime = tcp_time_stamp;
> tcp_enter_quickack_mode(sk);
> inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
> TCP_DELACK_MAX, TCP_RTO_MAX);
> @@ -5716,7 +5716,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
> /* Prevent spurious tcp_cwnd_restart() on
> * first data packet.
> */
> - tp->lsndtime = tcp_time_stamp(sk);
> + tp->lsndtime = tcp_time_stamp;
>
> tcp_initialize_rcv_mss(sk);
> tcp_fast_path_on(tp);
> diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
> index a946e9b..b8e2dd3 100644
> --- a/net/ipv4/tcp_ipv4.c
> +++ b/net/ipv4/tcp_ipv4.c
> @@ -442,7 +442,7 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
> BUG_ON(!skb);
>
> remaining = icsk->icsk_rto - min(icsk->icsk_rto,
> - tcp_time_stamp(sk) - TCP_SKB_CB(skb)->when);
> + tcp_time_stamp - TCP_SKB_CB(skb)->when);
>
> if (remaining) {
> inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
> @@ -786,7 +786,7 @@ static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
> tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
> tcptw->tw_rcv_wnd >>
> (tw->tw_rcv_wscale & TW_WSCALE_MASK),
> - tcp_time_stamp(sk) + tcptw->tw_ts_offset,
> + tcp_time_stamp + tcptw->tw_ts_offset,
> tcptw->tw_ts_recent,
> tw->tw_bound_dev_if,
> tcp_twsk_md5_key(tcptw),
> @@ -806,7 +806,7 @@ static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
> tcp_v4_send_ack(skb, (sk->sk_state == TCP_LISTEN) ?
> tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
> tcp_rsk(req)->rcv_nxt, req->rcv_wnd,
> - tcp_time_stamp(sk),
> + tcp_time_stamp,
> req->ts_recent,
> 0,
> tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&ip_hdr(skb)->daddr,
> @@ -845,7 +845,7 @@ static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
> ireq->opt);
> err = net_xmit_eval(err);
> if (!tcp_rsk(req)->snt_synack && !err)
> - tcp_rsk(req)->snt_synack = tcp_time_stamp(sk);
> + tcp_rsk(req)->snt_synack = tcp_time_stamp;
> }
>
> return err;
> @@ -1376,7 +1376,7 @@ static int tcp_v4_conn_req_fastopen(struct sock *sk,
> ireq->ir_rmt_addr, ireq->opt);
> err = net_xmit_eval(err);
> if (!err)
> - tcp_rsk(req)->snt_synack = tcp_time_stamp(sk);
> + tcp_rsk(req)->snt_synack = tcp_time_stamp;
> /* XXX (TFO) - is it ok to ignore error and continue? */
>
> spin_lock(&queue->fastopenq->lock);
> @@ -1597,7 +1597,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
> if (err || want_cookie)
> goto drop_and_free;
>
> - tcp_rsk(req)->snt_synack = tcp_time_stamp(sk);
> + tcp_rsk(req)->snt_synack = tcp_time_stamp;
> tcp_rsk(req)->listener = NULL;
> /* Add the request_sock to the SYN table */
> inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
> diff --git a/net/ipv4/tcp_lp.c b/net/ipv4/tcp_lp.c
> index 7d5da92..72f7218 100644
> --- a/net/ipv4/tcp_lp.c
> +++ b/net/ipv4/tcp_lp.c
> @@ -269,11 +269,11 @@ static void tcp_lp_pkts_acked(struct sock *sk, u32 num_acked, s32 rtt_us)
> tcp_lp_rtt_sample(sk, rtt_us);
>
> /* calc inference */
> - if (tcp_time_stamp(sk) > tp->rx_opt.rcv_tsecr)
> - lp->inference = 3 * (tcp_time_stamp(sk) - tp->rx_opt.rcv_tsecr);
> + if (tcp_time_stamp > tp->rx_opt.rcv_tsecr)
> + lp->inference = 3 * (tcp_time_stamp - tp->rx_opt.rcv_tsecr);
>
> /* test if within inference */
> - if (lp->last_drop && (tcp_time_stamp(sk) - lp->last_drop < lp->inference))
> + if (lp->last_drop && (tcp_time_stamp - lp->last_drop < lp->inference))
> lp->flag |= LP_WITHIN_INF;
> else
> lp->flag &= ~LP_WITHIN_INF;
> @@ -310,7 +310,7 @@ static void tcp_lp_pkts_acked(struct sock *sk, u32 num_acked, s32 rtt_us)
> tp->snd_cwnd = max(tp->snd_cwnd >> 1U, 1U);
>
> /* record this drop time */
> - lp->last_drop = tcp_time_stamp(sk);
> + lp->last_drop = tcp_time_stamp;
> }
>
> static struct tcp_congestion_ops tcp_lp __read_mostly = {
> diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c
> index 935cb33..40cbb0b 100644
> --- a/net/ipv4/tcp_metrics.c
> +++ b/net/ipv4/tcp_metrics.c
> @@ -534,7 +534,7 @@ reset:
> tp->snd_cwnd = 1;
> else
> tp->snd_cwnd = tcp_init_cwnd(tp, dst);
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
> }
>
> bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst, bool paws_check)
> diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
> index 02419aa..8aa908c 100644
> --- a/net/ipv4/tcp_output.c
> +++ b/net/ipv4/tcp_output.c
> @@ -138,7 +138,7 @@ static __u16 tcp_advertise_mss(struct sock *sk)
> static void tcp_cwnd_restart(struct sock *sk, const struct dst_entry *dst)
> {
> struct tcp_sock *tp = tcp_sk(sk);
> - s32 delta = tcp_time_stamp(sk) - tp->lsndtime;
> + s32 delta = tcp_time_stamp - tp->lsndtime;
> u32 restart_cwnd = tcp_init_cwnd(tp, dst);
> u32 cwnd = tp->snd_cwnd;
>
> @@ -150,7 +150,7 @@ static void tcp_cwnd_restart(struct sock *sk, const struct dst_entry *dst)
> while ((delta -= inet_csk(sk)->icsk_rto) > 0 && cwnd > restart_cwnd)
> cwnd >>= 1;
> tp->snd_cwnd = max(cwnd, restart_cwnd);
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
> tp->snd_cwnd_used = 0;
> }
>
> @@ -159,7 +159,7 @@ static void tcp_event_data_sent(struct tcp_sock *tp,
> struct sock *sk)
> {
> struct inet_connection_sock *icsk = inet_csk(sk);
> - const u32 now = tcp_time_stamp(sk);
> + const u32 now = tcp_time_stamp;
> const struct dst_entry *dst = __sk_dst_get(sk);
>
> if (sysctl_tcp_slow_start_after_idle &&
> @@ -1355,14 +1355,14 @@ static void tcp_cwnd_validate(struct sock *sk)
> if (tp->packets_out >= tp->snd_cwnd) {
> /* Network is feed fully. */
> tp->snd_cwnd_used = 0;
> - tp->snd_cwnd_stamp = tcp_time_stamp(sk);
> + tp->snd_cwnd_stamp = tcp_time_stamp;
> } else {
> /* Network starves. */
> if (tp->packets_out > tp->snd_cwnd_used)
> tp->snd_cwnd_used = tp->packets_out;
>
> if (sysctl_tcp_slow_start_after_idle &&
> - (s32)(tcp_time_stamp(sk) - tp->snd_cwnd_stamp) >= inet_csk(sk)->icsk_rto)
> + (s32)(tcp_time_stamp - tp->snd_cwnd_stamp) >= inet_csk(sk)->icsk_rto)
> tcp_cwnd_application_limited(sk);
> }
> }
> @@ -1775,7 +1775,7 @@ static int tcp_mtu_probe(struct sock *sk)
>
> /* We're ready to send. If this fails, the probe will
> * be resegmented into mss-sized pieces by tcp_write_xmit(). */
> - TCP_SKB_CB(nskb)->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(nskb)->when = tcp_time_stamp;
> if (!tcp_transmit_skb(sk, nskb, 1, GFP_ATOMIC)) {
> /* Decrement cwnd here because we are sending
> * effectively two packets. */
> @@ -1895,7 +1895,7 @@ static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
> unlikely(tso_fragment(sk, skb, limit, mss_now, gfp)))
> break;
>
> - TCP_SKB_CB(skb)->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(skb)->when = tcp_time_stamp;
>
> if (unlikely(tcp_transmit_skb(sk, skb, 1, gfp)))
> break;
> @@ -1971,10 +1971,10 @@ bool tcp_schedule_loss_probe(struct sock *sk)
> timeout = max_t(u32, timeout, msecs_to_jiffies(10));
>
> /* If RTO is shorter, just schedule TLP in its place. */
> - tlp_time_stamp = tcp_time_stamp(sk) + timeout;
> + tlp_time_stamp = tcp_time_stamp + timeout;
> rto_time_stamp = (u32)inet_csk(sk)->icsk_timeout;
> if ((s32)(tlp_time_stamp - rto_time_stamp) > 0) {
> - s32 delta = rto_time_stamp - tcp_time_stamp(sk);
> + s32 delta = rto_time_stamp - tcp_time_stamp;
> if (delta > 0)
> timeout = delta;
> }
> @@ -2372,7 +2372,7 @@ int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb)
> /* Make a copy, if the first transmission SKB clone we made
> * is still in somebody's hands, else make a clone.
> */
> - TCP_SKB_CB(skb)->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(skb)->when = tcp_time_stamp;
>
> /* make sure skb->data is aligned on arches that require it
> * and check if ack-trimming & collapsing extended the headroom
> @@ -2617,7 +2617,7 @@ void tcp_send_active_reset(struct sock *sk, gfp_t priority)
> tcp_init_nondata_skb(skb, tcp_acceptable_seq(sk),
> TCPHDR_ACK | TCPHDR_RST);
> /* Send it off. */
> - TCP_SKB_CB(skb)->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(skb)->when = tcp_time_stamp;
> if (tcp_transmit_skb(sk, skb, 0, priority))
> NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTFAILED);
>
> @@ -2656,7 +2656,7 @@ int tcp_send_synack(struct sock *sk)
> TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ACK;
> TCP_ECN_send_synack(tcp_sk(sk), skb);
> }
> - TCP_SKB_CB(skb)->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(skb)->when = tcp_time_stamp;
> return tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
> }
>
> @@ -2721,10 +2721,10 @@ struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst,
> memset(&opts, 0, sizeof(opts));
> #ifdef CONFIG_SYN_COOKIES
> if (unlikely(req->cookie_ts))
> - TCP_SKB_CB(skb)->when = cookie_init_timestamp(sk, req);
> + TCP_SKB_CB(skb)->when = cookie_init_timestamp(req);
> else
> #endif
> - TCP_SKB_CB(skb)->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(skb)->when = tcp_time_stamp;
> tcp_header_size = tcp_synack_options(sk, req, mss, skb, &opts, &md5,
> foc) + sizeof(*th);
>
> @@ -2827,7 +2827,7 @@ void tcp_connect_init(struct sock *sk)
> if (likely(!tp->repair))
> tp->rcv_nxt = 0;
> else
> - tp->rcv_tstamp = tcp_time_stamp(sk);
> + tp->rcv_tstamp = tcp_time_stamp;
> tp->rcv_wup = tp->rcv_nxt;
> tp->copied_seq = tp->rcv_nxt;
>
> @@ -2961,7 +2961,7 @@ int tcp_connect(struct sock *sk)
> skb_reserve(buff, MAX_TCP_HEADER);
>
> tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN);
> - tp->retrans_stamp = TCP_SKB_CB(buff)->when = tcp_time_stamp(sk);
> + tp->retrans_stamp = TCP_SKB_CB(buff)->when = tcp_time_stamp;
> tcp_connect_queue_skb(sk, buff);
> TCP_ECN_send_syn(sk, buff);
>
> @@ -3068,7 +3068,7 @@ void tcp_send_ack(struct sock *sk)
> tcp_init_nondata_skb(buff, tcp_acceptable_seq(sk), TCPHDR_ACK);
>
> /* Send it off, this clears delayed acks for us. */
> - TCP_SKB_CB(buff)->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(buff)->when = tcp_time_stamp;
> tcp_transmit_skb(sk, buff, 0, sk_gfp_atomic(sk, GFP_ATOMIC));
> }
>
> @@ -3100,7 +3100,7 @@ static int tcp_xmit_probe_skb(struct sock *sk, int urgent)
> * send it.
> */
> tcp_init_nondata_skb(skb, tp->snd_una - !urgent, TCPHDR_ACK);
> - TCP_SKB_CB(skb)->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(skb)->when = tcp_time_stamp;
> return tcp_transmit_skb(sk, skb, 0, GFP_ATOMIC);
> }
>
> @@ -3144,7 +3144,7 @@ int tcp_write_wakeup(struct sock *sk)
> tcp_set_skb_tso_segs(sk, skb, mss);
>
> TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
> - TCP_SKB_CB(skb)->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(skb)->when = tcp_time_stamp;
> err = tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
> if (!err)
> tcp_event_new_data_sent(sk, skb);
> diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
> index 592c37b..1d898ac 100644
> --- a/net/ipv4/tcp_timer.c
> +++ b/net/ipv4/tcp_timer.c
> @@ -59,7 +59,7 @@ static int tcp_out_of_resources(struct sock *sk, bool do_reset)
>
> /* If peer does not open window for long time, or did not transmit
> * anything for long time, penalize it. */
> - if ((s32)(tcp_time_stamp(sk) - tp->lsndtime) > 2*TCP_RTO_MAX || !do_reset)
> + if ((s32)(tcp_time_stamp - tp->lsndtime) > 2*TCP_RTO_MAX || !do_reset)
> shift++;
>
> /* If some dubious ICMP arrived, penalize even more. */
> @@ -69,7 +69,7 @@ static int tcp_out_of_resources(struct sock *sk, bool do_reset)
> if (tcp_check_oom(sk, shift)) {
> /* Catch exceptional cases, when connection requires reset.
> * 1. Last segment was sent recently. */
> - if ((s32)(tcp_time_stamp(sk) - tp->lsndtime) <= TCP_TIMEWAIT_LEN ||
> + if ((s32)(tcp_time_stamp - tp->lsndtime) <= TCP_TIMEWAIT_LEN ||
> /* 2. Window is closed. */
> (!tp->snd_wnd && !tp->packets_out))
> do_reset = true;
> @@ -149,7 +149,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(sk) - start_ts) >= timeout;
> + return (tcp_time_stamp - start_ts) >= timeout;
> }
>
> /* A write timeout has occurred. Process the after effects. */
> @@ -281,9 +281,9 @@ static void tcp_probe_timer(struct sock *sk)
> */
> start_ts = TCP_SKB_CB(tcp_send_head(sk))->when;
> if (!start_ts)
> - TCP_SKB_CB(tcp_send_head(sk))->when = tcp_time_stamp(sk);
> + TCP_SKB_CB(tcp_send_head(sk))->when = tcp_time_stamp;
> else if (icsk->icsk_user_timeout &&
> - (s32)(tcp_time_stamp(sk) - start_ts) > icsk->icsk_user_timeout)
> + (s32)(tcp_time_stamp - start_ts) > icsk->icsk_user_timeout)
> goto abort;
>
> max_probes = sysctl_tcp_retries2;
> @@ -381,7 +381,7 @@ void tcp_retransmit_timer(struct sock *sk)
> tp->snd_una, tp->snd_nxt);
> }
> #endif
> - if (tcp_time_stamp(sk) - tp->rcv_tstamp > TCP_RTO_MAX) {
> + if (tcp_time_stamp - tp->rcv_tstamp > TCP_RTO_MAX) {
> tcp_write_err(sk);
> goto out;
> }
> diff --git a/net/ipv4/tcp_westwood.c b/net/ipv4/tcp_westwood.c
> index b3ef319..76a1e23 100644
> --- a/net/ipv4/tcp_westwood.c
> +++ b/net/ipv4/tcp_westwood.c
> @@ -69,7 +69,7 @@ static void tcp_westwood_init(struct sock *sk)
> w->cumul_ack = 0;
> w->reset_rtt_min = 1;
> w->rtt_min = w->rtt = TCP_WESTWOOD_INIT_RTT;
> - w->rtt_win_sx = tcp_time_stamp(sk);
> + w->rtt_win_sx = tcp_time_stamp;
> w->snd_una = tcp_sk(sk)->snd_una;
> w->first_ack = 1;
> }
> @@ -116,7 +116,7 @@ static void tcp_westwood_pkts_acked(struct sock *sk, u32 cnt, s32 rtt)
> static void westwood_update_window(struct sock *sk)
> {
> struct westwood *w = inet_csk_ca(sk);
> - s32 delta = tcp_time_stamp(sk) - w->rtt_win_sx;
> + s32 delta = tcp_time_stamp - w->rtt_win_sx;
>
> /* Initialize w->snd_una with the first acked sequence number in order
> * to fix mismatch between tp->snd_una and w->snd_una for the first
> @@ -140,7 +140,7 @@ static void westwood_update_window(struct sock *sk)
> westwood_filter(w, delta);
>
> w->bk = 0;
> - w->rtt_win_sx = tcp_time_stamp(sk);
> + w->rtt_win_sx = tcp_time_stamp;
> }
> }
>
> diff --git a/net/ipv6/netfilter/ip6t_SYNPROXY.c b/net/ipv6/netfilter/ip6t_SYNPROXY.c
> index 67f0a33..a0d1727 100644
> --- a/net/ipv6/netfilter/ip6t_SYNPROXY.c
> +++ b/net/ipv6/netfilter/ip6t_SYNPROXY.c
> @@ -295,7 +295,7 @@ synproxy_tg6(struct sk_buff *skb, const struct xt_action_param *par)
>
> opts.options &= info->options;
> if (opts.options & XT_SYNPROXY_OPT_TIMESTAMP)
> - synproxy_init_timestamp_cookie(skb->sk, info, &opts);
> + synproxy_init_timestamp_cookie(info, &opts);
> else
> opts.options &= ~(XT_SYNPROXY_OPT_WSCALE |
> XT_SYNPROXY_OPT_SACK_PERM |
> diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
> index b299e76..7123a8b 100644
> --- a/net/ipv6/tcp_ipv6.c
> +++ b/net/ipv6/tcp_ipv6.c
> @@ -896,7 +896,7 @@ static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
>
> tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
> tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
> - tcp_time_stamp(sk) + tcptw->tw_ts_offset,
> + tcp_time_stamp + tcptw->tw_ts_offset,
> tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw),
> tw->tw_tclass);
>
> @@ -907,7 +907,7 @@ static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
> struct request_sock *req)
> {
> tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1,
> - req->rcv_wnd, tcp_time_stamp(sk), req->ts_recent,
> + req->rcv_wnd, tcp_time_stamp, req->ts_recent,
> tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr), 0);
> }
>
> @@ -1071,7 +1071,7 @@ have_isn:
> want_cookie)
> goto drop_and_free;
>
> - tcp_rsk(req)->snt_synack = tcp_time_stamp(sk);
> + tcp_rsk(req)->snt_synack = tcp_time_stamp;
> tcp_rsk(req)->listener = NULL;
> inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
> return 0;
> diff --git a/net/netfilter/nf_synproxy_core.c b/net/netfilter/nf_synproxy_core.c
> index 32641b8..52e20c9 100644
> --- a/net/netfilter/nf_synproxy_core.c
> +++ b/net/netfilter/nf_synproxy_core.c
> @@ -145,12 +145,11 @@ synproxy_build_options(struct tcphdr *th, const struct synproxy_options *opts)
> }
> EXPORT_SYMBOL_GPL(synproxy_build_options);
>
> -void synproxy_init_timestamp_cookie(struct sock *sk,
> - const struct xt_synproxy_info *info,
> +void synproxy_init_timestamp_cookie(const struct xt_synproxy_info *info,
> struct synproxy_options *opts)
> {
> opts->tsecr = opts->tsval;
> - opts->tsval = tcp_time_stamp(sk) & ~0x3f;
> + opts->tsval = tcp_time_stamp & ~0x3f;
>
> if (opts->options & XT_SYNPROXY_OPT_WSCALE) {
> opts->tsval |= opts->wscale;
>
More information about the Devel
mailing list