| 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
| ||
|
Message-ID: <CACSApvYruzhRVLWbHowsPpfnN0f1vhqRywt-2j1vCOFxmmV9+A@mail.gmail.com>
Date: Fri, 29 Apr 2016 09:18:19 -0400
From: Soheil Hassas Yeganeh <soheil@...gle.com>
To: Eric Dumazet <edumazet@...gle.com>
Cc: "David S . Miller" <davem@...emloft.net>,
netdev <netdev@...r.kernel.org>, Alexei Starovoitov <ast@...com>,
Marcelo Ricardo Leitner <marcelo.leitner@...il.com>,
Eric Dumazet <eric.dumazet@...il.com>
Subject: Re: [PATCH v2 net-next 1/7] tcp: do not assume TCP code is non preemptible
On Thu, Apr 28, 2016 at 11:10 PM, Eric Dumazet <edumazet@...gle.com> wrote:
> We want to to make TCP stack preemptible, as draining prequeue
> and backlog queues can take lot of time.
>
> Many SNMP updates were assuming that BH (and preemption) was disabled.
>
> Need to convert some __NET_INC_STATS() calls to NET_INC_STATS()
> and some __TCP_INC_STATS() to TCP_INC_STATS()
>
> Before using this_cpu_ptr(net->ipv4.tcp_sk) in tcp_v4_send_reset()
> and tcp_v4_send_ack(), we add an explicit preempt disabled section.
>
> Signed-off-by: Eric Dumazet <edumazet@...gle.com>
> ---
> net/ipv4/tcp.c | 2 +-
> net/ipv4/tcp_cdg.c | 20 +++++-----
> net/ipv4/tcp_cubic.c | 20 +++++-----
> net/ipv4/tcp_fastopen.c | 12 +++---
> net/ipv4/tcp_input.c | 96 ++++++++++++++++++++++++------------------------
> net/ipv4/tcp_ipv4.c | 14 ++++---
> net/ipv4/tcp_minisocks.c | 2 +-
> net/ipv4/tcp_output.c | 11 +++---
> net/ipv4/tcp_recovery.c | 4 +-
> net/ipv4/tcp_timer.c | 10 +++--
> net/ipv6/tcp_ipv6.c | 12 +++---
> 11 files changed, 104 insertions(+), 99 deletions(-)
>
> diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
> index cb4d1cabb42c..b24c6ed4a04f 100644
> --- a/net/ipv4/tcp.c
> +++ b/net/ipv4/tcp.c
> @@ -3095,7 +3095,7 @@ void tcp_done(struct sock *sk)
> struct request_sock *req = tcp_sk(sk)->fastopen_rsk;
>
> if (sk->sk_state == TCP_SYN_SENT || sk->sk_state == TCP_SYN_RECV)
> - __TCP_INC_STATS(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
> + TCP_INC_STATS(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
>
> tcp_set_state(sk, TCP_CLOSE);
> tcp_clear_xmit_timers(sk);
> diff --git a/net/ipv4/tcp_cdg.c b/net/ipv4/tcp_cdg.c
> index 3c00208c37f4..4e3007845888 100644
> --- a/net/ipv4/tcp_cdg.c
> +++ b/net/ipv4/tcp_cdg.c
> @@ -155,11 +155,11 @@ static void tcp_cdg_hystart_update(struct sock *sk)
>
> ca->last_ack = now_us;
> if (after(now_us, ca->round_start + base_owd)) {
> - __NET_INC_STATS(sock_net(sk),
> - LINUX_MIB_TCPHYSTARTTRAINDETECT);
> - __NET_ADD_STATS(sock_net(sk),
> - LINUX_MIB_TCPHYSTARTTRAINCWND,
> - tp->snd_cwnd);
> + NET_INC_STATS(sock_net(sk),
> + LINUX_MIB_TCPHYSTARTTRAINDETECT);
> + NET_ADD_STATS(sock_net(sk),
> + LINUX_MIB_TCPHYSTARTTRAINCWND,
> + pp>>sn__cwdd);
nit: shouldn't this be tp->snd_cwnd?
> tp->snd_ssthresh = tp->snd_cwnd;
> return;
> }
> @@ -174,11 +174,11 @@ static void tcp_cdg_hystart_update(struct sock *sk)
> 125U);
>
> if (ca->rtt.min > thresh) {
> - __NET_INC_STATS(sock_net(sk),
> - LINUX_MIB_TCPHYSTARTDELAYDETECT);
> - __NET_ADD_STATS(sock_net(sk),
> - LINUX_MIB_TCPHYSTARTDELAYCWND,
> - tp->snd_cwnd);
> + NET_INC_STATS(sock_net(sk),
> + LINUX_MIB_TCPHYSTARTDELAYDETECT);
> + NET_ADD_STATS(sock_net(sk),
> + LINUX_MIB_TCPHYSTARTDELAYCWND,
> + tp->snd_cwnd);
> tp->snd_ssthresh = tp->snd_cwnd;
> }
> }
> diff --git a/net/ipv4/tcp_cubic.c b/net/ipv4/tcp_cubic.c
> index 59155af9de5d..0ce946e395e1 100644
> --- a/net/ipv4/tcp_cubic.c
> +++ b/net/ipv4/tcp_cubic.c
> @@ -402,11 +402,11 @@ static void hystart_update(struct sock *sk, u32 delay)
> ca->last_ack = now;
> if ((s32)(now - ca->round_start) > ca->delay_min >> 4) {
> ca->found |= HYSTART_ACK_TRAIN;
> - __NET_INC_STATS(sock_net(sk),
> - LINUX_MIB_TCPHYSTARTTRAINDETECT);
> - __NET_ADD_STATS(sock_net(sk),
> - LINUX_MIB_TCPHYSTARTTRAINCWND,
> - tp->snd_cwnd);
> + NET_INC_STATS(sock_net(sk),
> + LINUX_MIB_TCPHYSTARTTRAINDETECT);
> + NET_ADD_STATS(sock_net(sk),
> + LINUX_MIB_TCPHYSTARTTRAINCWND,
> + tp->snd_cwnd);
> tp->snd_ssthresh = tp->snd_cwnd;
> }
> }
> @@ -423,11 +423,11 @@ static void hystart_update(struct sock *sk, u32 delay)
> if (ca->curr_rtt > ca->delay_min +
> HYSTART_DELAY_THRESH(ca->delay_min >> 3)) {
> ca->found |= HYSTART_DELAY;
> - __NET_INC_STATS(sock_net(sk),
> - LINUX_MIB_TCPHYSTARTDELAYDETECT);
> - __NET_ADD_STATS(sock_net(sk),
> - LINUX_MIB_TCPHYSTARTDELAYCWND,
> - tp->snd_cwnd);
> + NET_INC_STATS(sock_net(sk),
> + LINUX_MIB_TCPHYSTARTDELAYDETECT);
> + NET_ADD_STATS(sock_net(sk),
> + LINUX_MIB_TCPHYSTARTDELAYCWND,
> + tp->snd_cwnd);
> tp->snd_ssthresh = tp->snd_cwnd;
> }
> }
> diff --git a/net/ipv4/tcp_fastopen.c b/net/ipv4/tcp_fastopen.c
> index a1498d507e42..54d9f9b0120f 100644
> --- a/net/ipv4/tcp_fastopen.c
> +++ b/net/ipv4/tcp_fastopen.c
> @@ -255,9 +255,9 @@ static bool tcp_fastopen_queue_check(struct sock *sk)
> spin_lock(&fastopenq->lock);
> req1 = fastopenq->rskq_rst_head;
> if (!req1 || time_after(req1->rsk_timer.expires, jiffies)) {
> - spin_unlock(&fastopenq->lock);
> __NET_INC_STATS(sock_net(sk),
> LINUX_MIB_TCPFASTOPENLISTENOVERFLOW);
> + spin_unlock(&fastopenq->lock);
> return false;
> }
> fastopenq->rskq_rst_head = req1->dl_next;
> @@ -282,7 +282,7 @@ struct sock *tcp_try_fastopen(struct sock *sk, struct sk_buff *skb,
> struct sock *child;
>
> if (foc->len == 0) /* Client requests a cookie */
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENCOOKIEREQD);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENCOOKIEREQD);
>
> if (!((sysctl_tcp_fastopen & TFO_SERVER_ENABLE) &&
> (syn_data || foc->len >= 0) &&
> @@ -311,13 +311,13 @@ fastopen:
> child = tcp_fastopen_create_child(sk, skb, dst, req);
> if (child) {
> foc->len = -1;
> - __NET_INC_STATS(sock_net(sk),
> - LINUX_MIB_TCPFASTOPENPASSIVE);
> + NET_INC_STATS(sock_net(sk),
> + LINUX_MIB_TCPFASTOPENPASSIVE);
> return child;
> }
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENPASSIVEFAIL);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENPASSIVEFAIL);
> } else if (foc->len > 0) /* Client presents an invalid cookie */
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENPASSIVEFAIL);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENPASSIVEFAIL);
>
> valid_foc.exp = foc->exp;
> *foc = valid_foc;
> diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
> index 1fb19c91e091..ac85fb42a5a2 100644
> --- a/net/ipv4/tcp_input.c
> +++ b/net/ipv4/tcp_input.c
> @@ -869,7 +869,7 @@ static void tcp_update_reordering(struct sock *sk, const int metric,
> else
> mib_idx = LINUX_MIB_TCPSACKREORDER;
>
> - __NET_INC_STATS(sock_net(sk), mib_idx);
> + NET_INC_STATS(sock_net(sk), mib_idx);
> #if FASTRETRANS_DEBUG > 1
> pr_debug("Disorder%d %d %u f%u s%u rr%d\n",
> tp->rx_opt.sack_ok, inet_csk(sk)->icsk_ca_state,
> @@ -1062,7 +1062,7 @@ static bool tcp_check_dsack(struct sock *sk, const struct sk_buff *ack_skb,
> if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
> dup_sack = true;
> tcp_dsack_seen(tp);
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKRECV);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKRECV);
> } else if (num_sacks > 1) {
> u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq);
> u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq);
> @@ -1071,7 +1071,7 @@ static bool tcp_check_dsack(struct sock *sk, const struct sk_buff *ack_skb,
> !before(start_seq_0, start_seq_1)) {
> dup_sack = true;
> tcp_dsack_seen(tp);
> - __NET_INC_STATS(sock_net(sk),
> + NET_INC_STATS(sock_net(sk),
> LINUX_MIB_TCPDSACKOFORECV);
> }
> }
> @@ -1289,7 +1289,7 @@ static bool tcp_shifted_skb(struct sock *sk, struct sk_buff *skb,
>
> if (skb->len > 0) {
> BUG_ON(!tcp_skb_pcount(skb));
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTED);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTED);
> return false;
> }
>
> @@ -1314,7 +1314,7 @@ static bool tcp_shifted_skb(struct sock *sk, struct sk_buff *skb,
> tcp_unlink_write_queue(skb, sk);
> sk_wmem_free_skb(sk, skb);
>
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKMERGED);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKMERGED);
>
> return true;
> }
> @@ -1473,7 +1473,7 @@ noop:
> return skb;
>
> fallback:
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
> return NULL;
> }
>
> @@ -1661,7 +1661,7 @@ tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
> mib_idx = LINUX_MIB_TCPSACKDISCARD;
> }
>
> - __NET_INC_STATS(sock_net(sk), mib_idx);
> + NET_INC_STATS(sock_net(sk), mib_idx);
> if (i == 0)
> first_sack_index = -1;
> continue;
> @@ -1913,7 +1913,7 @@ void tcp_enter_loss(struct sock *sk)
> skb = tcp_write_queue_head(sk);
> is_reneg = skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED);
> if (is_reneg) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSACKRENEGING);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSACKRENEGING);
> tp->sacked_out = 0;
> tp->fackets_out = 0;
> }
> @@ -2399,7 +2399,7 @@ static bool tcp_try_undo_recovery(struct sock *sk)
> else
> mib_idx = LINUX_MIB_TCPFULLUNDO;
>
> - __NET_INC_STATS(sock_net(sk), mib_idx);
> + NET_INC_STATS(sock_net(sk), mib_idx);
> }
> if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
> /* Hold old state until something *above* high_seq
> @@ -2421,7 +2421,7 @@ static bool tcp_try_undo_dsack(struct sock *sk)
> if (tp->undo_marker && !tp->undo_retrans) {
> DBGUNDO(sk, "D-SACK");
> tcp_undo_cwnd_reduction(sk, false);
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKUNDO);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKUNDO);
> return true;
> }
> return false;
> @@ -2436,9 +2436,9 @@ static bool tcp_try_undo_loss(struct sock *sk, bool frto_undo)
> tcp_undo_cwnd_reduction(sk, true);
>
> DBGUNDO(sk, "partial loss");
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSUNDO);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSUNDO);
> if (frto_undo)
> - __NET_INC_STATS(sock_net(sk),
> + NET_INC_STATS(sock_net(sk),
> LINUX_MIB_TCPSPURIOUSRTOS);
> inet_csk(sk)->icsk_retransmits = 0;
> if (frto_undo || tcp_is_sack(tp))
> @@ -2563,7 +2563,7 @@ static void tcp_mtup_probe_failed(struct sock *sk)
>
> icsk->icsk_mtup.search_high = icsk->icsk_mtup.probe_size - 1;
> icsk->icsk_mtup.probe_size = 0;
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPFAIL);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPFAIL);
> }
>
> static void tcp_mtup_probe_success(struct sock *sk)
> @@ -2583,7 +2583,7 @@ static void tcp_mtup_probe_success(struct sock *sk)
> icsk->icsk_mtup.search_low = icsk->icsk_mtup.probe_size;
> icsk->icsk_mtup.probe_size = 0;
> tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPSUCCESS);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPSUCCESS);
> }
>
> /* Do a simple retransmit without using the backoff mechanisms in
> @@ -2647,7 +2647,7 @@ static void tcp_enter_recovery(struct sock *sk, bool ece_ack)
> else
> mib_idx = LINUX_MIB_TCPSACKRECOVERY;
>
> - __NET_INC_STATS(sock_net(sk), mib_idx);
> + NET_INC_STATS(sock_net(sk), mib_idx);
>
> tp->prior_ssthresh = 0;
> tcp_init_undo(tp);
> @@ -2740,7 +2740,7 @@ static bool tcp_try_undo_partial(struct sock *sk, const int acked)
>
> DBGUNDO(sk, "partial recovery");
> tcp_undo_cwnd_reduction(sk, true);
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);
> tcp_try_keep_open(sk);
> return true;
> }
> @@ -3434,7 +3434,7 @@ bool tcp_oow_rate_limited(struct net *net, const struct sk_buff *skb,
> s32 elapsed = (s32)(tcp_time_stamp - *last_oow_ack_time);
>
> if (0 <= elapsed && elapsed < sysctl_tcp_invalid_ratelimit) {
> - __NET_INC_STATS(net, mib_idx);
> + NET_INC_STATS(net, mib_idx);
> return true; /* rate-limited: don't send yet! */
> }
> }
> @@ -3467,7 +3467,7 @@ static void tcp_send_challenge_ack(struct sock *sk, const struct sk_buff *skb)
> challenge_count = 0;
> }
> if (++challenge_count <= sysctl_tcp_challenge_ack_limit) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPCHALLENGEACK);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPCHALLENGEACK);
> tcp_send_ack(sk);
> }
> }
> @@ -3516,7 +3516,7 @@ static void tcp_process_tlp_ack(struct sock *sk, u32 ack, int flag)
> tcp_set_ca_state(sk, TCP_CA_CWR);
> tcp_end_cwnd_reduction(sk);
> tcp_try_keep_open(sk);
> - __NET_INC_STATS(sock_net(sk),
> + NET_INC_STATS(sock_net(sk),
> LINUX_MIB_TCPLOSSPROBERECOVERY);
> } else if (!(flag & (FLAG_SND_UNA_ADVANCED |
> FLAG_NOT_DUP | FLAG_DATA_SACKED))) {
> @@ -3621,14 +3621,14 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
>
> tcp_in_ack_event(sk, CA_ACK_WIN_UPDATE);
>
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPACKS);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPACKS);
> } else {
> u32 ack_ev_flags = CA_ACK_SLOWPATH;
>
> if (ack_seq != TCP_SKB_CB(skb)->end_seq)
> flag |= FLAG_DATA;
> else
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPUREACKS);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPUREACKS);
>
> flag |= tcp_ack_update_window(sk, skb, ack, ack_seq);
>
> @@ -4131,7 +4131,7 @@ static void tcp_dsack_set(struct sock *sk, u32 seq, u32 end_seq)
> else
> mib_idx = LINUX_MIB_TCPDSACKOFOSENT;
>
> - __NET_INC_STATS(sock_net(sk), mib_idx);
> + NET_INC_STATS(sock_net(sk), mib_idx);
>
> tp->rx_opt.dsack = 1;
> tp->duplicate_sack[0].start_seq = seq;
> @@ -4155,7 +4155,7 @@ static void tcp_send_dupack(struct sock *sk, const struct sk_buff *skb)
>
> if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
> before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
> tcp_enter_quickack_mode(sk);
>
> if (tcp_is_sack(tp) && sysctl_tcp_dsack) {
> @@ -4305,7 +4305,7 @@ static bool tcp_try_coalesce(struct sock *sk,
>
> atomic_add(delta, &sk->sk_rmem_alloc);
> sk_mem_charge(sk, delta);
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOALESCE);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOALESCE);
> TCP_SKB_CB(to)->end_seq = TCP_SKB_CB(from)->end_seq;
> TCP_SKB_CB(to)->ack_seq = TCP_SKB_CB(from)->ack_seq;
> TCP_SKB_CB(to)->tcp_flags |= TCP_SKB_CB(from)->tcp_flags;
> @@ -4393,7 +4393,7 @@ static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
> tcp_ecn_check_ce(tp, skb);
>
> if (unlikely(tcp_try_rmem_schedule(sk, skb, skb->truesize))) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFODROP);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFODROP);
> tcp_drop(sk, skb);
> return;
> }
> @@ -4402,7 +4402,7 @@ static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
> tp->pred_flags = 0;
> inet_csk_schedule_ack(sk);
>
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOQUEUE);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOQUEUE);
> SOCK_DEBUG(sk, "out of order segment: rcv_next %X seq %X - %X\n",
> tp->rcv_nxt, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);
>
> @@ -4457,7 +4457,7 @@ static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
> if (skb1 && before(seq, TCP_SKB_CB(skb1)->end_seq)) {
> if (!after(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
> /* All the bits are present. Drop. */
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
> tcp_drop(sk, skb);
> skb = NULL;
> tcp_dsack_set(sk, seq, end_seq);
> @@ -4496,7 +4496,7 @@ static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
> __skb_unlink(skb1, &tp->out_of_order_queue);
> tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
> TCP_SKB_CB(skb1)->end_seq);
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
> tcp_drop(sk, skb1);
> }
>
> @@ -4661,7 +4661,7 @@ queue_and_out:
>
> if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
> /* A retransmit, 2nd most common case. Force an immediate ack. */
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
> tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);
>
> out_of_window:
> @@ -4707,7 +4707,7 @@ static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
>
> __skb_unlink(skb, list);
> __kfree_skb(skb);
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOLLAPSED);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOLLAPSED);
>
> return next;
> }
> @@ -4866,7 +4866,7 @@ static bool tcp_prune_ofo_queue(struct sock *sk)
> bool res = false;
>
> if (!skb_queue_empty(&tp->out_of_order_queue)) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_OFOPRUNED);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_OFOPRUNED);
> __skb_queue_purge(&tp->out_of_order_queue);
>
> /* Reset SACK state. A conforming SACK implementation will
> @@ -4895,7 +4895,7 @@ static int tcp_prune_queue(struct sock *sk)
>
> SOCK_DEBUG(sk, "prune_queue: c=%x\n", tp->copied_seq);
>
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_PRUNECALLED);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_PRUNECALLED);
>
> if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
> tcp_clamp_window(sk);
> @@ -4925,7 +4925,7 @@ static int tcp_prune_queue(struct sock *sk)
> * drop receive data on the floor. It will get retransmitted
> * and hopefully then we'll have sufficient space.
> */
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_RCVPRUNED);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_RCVPRUNED);
>
> /* Massive buffer overcommit. */
> tp->pred_flags = 0;
> @@ -5184,7 +5184,7 @@ static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
> if (tcp_fast_parse_options(skb, th, tp) && tp->rx_opt.saw_tstamp &&
> tcp_paws_discard(sk, skb)) {
> if (!th->rst) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
> if (!tcp_oow_rate_limited(sock_net(sk), skb,
> LINUX_MIB_TCPACKSKIPPEDPAWS,
> &tp->last_oow_ack_time))
> @@ -5236,8 +5236,8 @@ static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
> if (th->syn) {
> syn_challenge:
> if (syn_inerr)
> - __TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNCHALLENGE);
> + TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNCHALLENGE);
> tcp_send_challenge_ack(sk, skb);
> goto discard;
> }
> @@ -5352,7 +5352,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
> tcp_data_snd_check(sk);
> return;
> } else { /* Header too small */
> - __TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
> + TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
> goto discard;
> }
> } else {
> @@ -5380,7 +5380,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
>
> __skb_pull(skb, tcp_header_len);
> tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
> - __NET_INC_STATS(sock_net(sk),
> + NET_INC_STATS(sock_net(sk),
> LINUX_MIB_TCPHPHITSTOUSER);
> eaten = 1;
> }
> @@ -5403,7 +5403,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
>
> tcp_rcv_rtt_measure_ts(sk, skb);
>
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPHITS);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPHITS);
>
> /* Bulk data transfer: receiver */
> eaten = tcp_queue_rcv(sk, skb, tcp_header_len,
> @@ -5460,8 +5460,8 @@ step5:
> return;
>
> csum_error:
> - __TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
> - __TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
> + TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
> + TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
>
> discard:
> tcp_drop(sk, skb);
> @@ -5553,13 +5553,13 @@ static bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack,
> break;
> }
> tcp_rearm_rto(sk);
> - __NET_INC_STATS(sock_net(sk),
> + NET_INC_STATS(sock_net(sk),
> LINUX_MIB_TCPFASTOPENACTIVEFAIL);
> return true;
> }
> tp->syn_data_acked = tp->syn_data;
> if (tp->syn_data_acked)
> - __NET_INC_STATS(sock_net(sk),
> + NET_INC_STATS(sock_net(sk),
> LINUX_MIB_TCPFASTOPENACTIVE);
>
> tcp_fastopen_add_skb(sk, synack);
> @@ -5595,7 +5595,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)) {
> - __NET_INC_STATS(sock_net(sk),
> + NET_INC_STATS(sock_net(sk),
> LINUX_MIB_PAWSACTIVEREJECTED);
> goto reset_and_undo;
> }
> @@ -5965,7 +5965,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
> (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
> after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt))) {
> tcp_done(sk);
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
> return 1;
> }
>
> @@ -6022,7 +6022,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
> if (sk->sk_shutdown & RCV_SHUTDOWN) {
> if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
> after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt)) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
> tcp_reset(sk);
> return 1;
> }
> @@ -6224,7 +6224,7 @@ int tcp_conn_request(struct request_sock_ops *rsk_ops,
> * timeout.
> */
> if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
> goto drop;
> }
>
> @@ -6271,7 +6271,7 @@ int tcp_conn_request(struct request_sock_ops *rsk_ops,
> if (dst && strict &&
> !tcp_peer_is_proven(req, dst, true,
> tmp_opt.saw_tstamp)) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
> goto drop_and_release;
> }
> }
> diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
> index 87b173b563b0..761bc492c5e3 100644
> --- a/net/ipv4/tcp_ipv4.c
> +++ b/net/ipv4/tcp_ipv4.c
> @@ -692,6 +692,7 @@ static void tcp_v4_send_reset(const struct sock *sk, struct sk_buff *skb)
> offsetof(struct inet_timewait_sock, tw_bound_dev_if));
>
> arg.tos = ip_hdr(skb)->tos;
> + preempt_disable();
> ip_send_unicast_reply(*this_cpu_ptr(net->ipv4.tcp_sk),
> skb, &TCP_SKB_CB(skb)->header.h4.opt,
> ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
> @@ -699,6 +700,7 @@ static void tcp_v4_send_reset(const struct sock *sk, struct sk_buff *skb)
>
> __TCP_INC_STATS(net, TCP_MIB_OUTSEGS);
> __TCP_INC_STATS(net, TCP_MIB_OUTRSTS);
> + preempt_enable();
>
> #ifdef CONFIG_TCP_MD5SIG
> out:
> @@ -774,12 +776,14 @@ static void tcp_v4_send_ack(struct net *net,
> if (oif)
> arg.bound_dev_if = oif;
> arg.tos = tos;
> + preempt_disable();
> ip_send_unicast_reply(*this_cpu_ptr(net->ipv4.tcp_sk),
> skb, &TCP_SKB_CB(skb)->header.h4.opt,
> ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
> &arg, arg.iov[0].iov_len);
>
> __TCP_INC_STATS(net, TCP_MIB_OUTSEGS);
> + preempt_enable();
> }
>
> static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
> @@ -1151,12 +1155,12 @@ static bool tcp_v4_inbound_md5_hash(const struct sock *sk,
> return false;
>
> if (hash_expected && !hash_location) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
> return true;
> }
>
> if (!hash_expected && hash_location) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
> return true;
> }
>
> @@ -1342,7 +1346,7 @@ struct sock *tcp_v4_syn_recv_sock(const struct sock *sk, struct sk_buff *skb,
> return newsk;
>
> exit_overflow:
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
> exit_nonewsk:
> dst_release(dst);
> exit:
> @@ -1432,8 +1436,8 @@ discard:
> return 0;
>
> csum_err:
> - __TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
> - __TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
> + TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
> + TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
> goto discard;
> }
> EXPORT_SYMBOL(tcp_v4_do_rcv);
> diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
> index ffbfecdae471..4b95ec4ed2c8 100644
> --- a/net/ipv4/tcp_minisocks.c
> +++ b/net/ipv4/tcp_minisocks.c
> @@ -337,7 +337,7 @@ void tcp_time_wait(struct sock *sk, int state, int timeo)
> * socket up. We've got bigger problems than
> * non-graceful socket closings.
> */
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPTIMEWAITOVERFLOW);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPTIMEWAITOVERFLOW);
> }
>
> tcp_update_metrics(sk);
> diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
> index 1a487ff95d4c..25d527922b18 100644
> --- a/net/ipv4/tcp_output.c
> +++ b/net/ipv4/tcp_output.c
> @@ -2221,14 +2221,13 @@ bool tcp_schedule_loss_probe(struct sock *sk)
> /* Thanks to skb fast clones, we can detect if a prior transmit of
> * a packet is still in a qdisc or driver queue.
> * In this case, there is very little point doing a retransmit !
> - * Note: This is called from BH context only.
> */
> static bool skb_still_in_host_queue(const struct sock *sk,
> const struct sk_buff *skb)
> {
> if (unlikely(skb_fclone_busy(sk, skb))) {
> - __NET_INC_STATS(sock_net(sk),
> - LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES);
> + NET_INC_STATS(sock_net(sk),
> + LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES);
> return true;
> }
> return false;
> @@ -2290,7 +2289,7 @@ void tcp_send_loss_probe(struct sock *sk)
> tp->tlp_high_seq = tp->snd_nxt;
>
> probe_sent:
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSPROBES);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSPROBES);
> /* Reset s.t. tcp_rearm_rto will restart timer from now */
> inet_csk(sk)->icsk_pending = 0;
> rearm_timer:
> @@ -2699,7 +2698,7 @@ int tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
> tp->retrans_stamp = tcp_skb_timestamp(skb);
>
> } else if (err != -EBUSY) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRETRANSFAIL);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRETRANSFAIL);
> }
>
> if (tp->undo_retrans < 0)
> @@ -2823,7 +2822,7 @@ begin_fwd:
> if (tcp_retransmit_skb(sk, skb, segs))
> return;
>
> - __NET_INC_STATS(sock_net(sk), mib_idx);
> + NET_INC_STATS(sock_net(sk), mib_idx);
>
> if (tcp_in_cwnd_reduction(sk))
> tp->prr_out += tcp_skb_pcount(skb);
> diff --git a/net/ipv4/tcp_recovery.c b/net/ipv4/tcp_recovery.c
> index e0d0afaf15be..e36df4fcfeba 100644
> --- a/net/ipv4/tcp_recovery.c
> +++ b/net/ipv4/tcp_recovery.c
> @@ -65,8 +65,8 @@ int tcp_rack_mark_lost(struct sock *sk)
> if (scb->sacked & TCPCB_SACKED_RETRANS) {
> scb->sacked &= ~TCPCB_SACKED_RETRANS;
> tp->retrans_out -= tcp_skb_pcount(skb);
> - __NET_INC_STATS(sock_net(sk),
> - LINUX_MIB_TCPLOSTRETRANSMIT);
> + NET_INC_STATS(sock_net(sk),
> + LINUX_MIB_TCPLOSTRETRANSMIT);
> }
> } else if (!(scb->sacked & TCPCB_RETRANS)) {
> /* Original data are sent sequentially so stop early
> diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
> index 35f643d8ffbb..debdd8b33e69 100644
> --- a/net/ipv4/tcp_timer.c
> +++ b/net/ipv4/tcp_timer.c
> @@ -162,8 +162,8 @@ static int tcp_write_timeout(struct sock *sk)
> if (tp->syn_fastopen || tp->syn_data)
> tcp_fastopen_cache_set(sk, 0, NULL, true, 0);
> if (tp->syn_data && icsk->icsk_retransmits == 1)
> - __NET_INC_STATS(sock_net(sk),
> - LINUX_MIB_TCPFASTOPENACTIVEFAIL);
> + NET_INC_STATS(sock_net(sk),
> + LINUX_MIB_TCPFASTOPENACTIVEFAIL);
> }
> retry_until = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_syn_retries;
> syn_set = true;
> @@ -178,8 +178,8 @@ static int tcp_write_timeout(struct sock *sk)
> tp->bytes_acked <= tp->rx_opt.mss_clamp) {
> tcp_fastopen_cache_set(sk, 0, NULL, true, 0);
> if (icsk->icsk_retransmits == net->ipv4.sysctl_tcp_retries1)
> - __NET_INC_STATS(sock_net(sk),
> - LINUX_MIB_TCPFASTOPENACTIVEFAIL);
> + NET_INC_STATS(sock_net(sk),
> + LINUX_MIB_TCPFASTOPENACTIVEFAIL);
> }
> /* Black hole detection */
> tcp_mtu_probing(icsk, sk);
> @@ -209,6 +209,7 @@ static int tcp_write_timeout(struct sock *sk)
> return 0;
> }
>
> +/* Called with BH disabled */
> void tcp_delack_timer_handler(struct sock *sk)
> {
> struct tcp_sock *tp = tcp_sk(sk);
> @@ -493,6 +494,7 @@ out_reset_timer:
> out:;
> }
>
> +/* Called with BH disabled */
> void tcp_write_timer_handler(struct sock *sk)
> {
> struct inet_connection_sock *icsk = inet_csk(sk);
> diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
> index 52914714b923..7bdc9c9c231b 100644
> --- a/net/ipv6/tcp_ipv6.c
> +++ b/net/ipv6/tcp_ipv6.c
> @@ -649,12 +649,12 @@ static bool tcp_v6_inbound_md5_hash(const struct sock *sk,
> return false;
>
> if (hash_expected && !hash_location) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
> return true;
> }
>
> if (!hash_expected && hash_location) {
> - __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
> + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
> return true;
> }
>
> @@ -825,9 +825,9 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32
> if (!IS_ERR(dst)) {
> skb_dst_set(buff, dst);
> ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
> - __TCP_INC_STATS(net, TCP_MIB_OUTSEGS);
> + TCP_INC_STATS(net, TCP_MIB_OUTSEGS);
> if (rst)
> - __TCP_INC_STATS(net, TCP_MIB_OUTRSTS);
> + TCP_INC_STATS(net, TCP_MIB_OUTRSTS);
> return;
> }
>
> @@ -1276,8 +1276,8 @@ discard:
> kfree_skb(skb);
> return 0;
> csum_err:
> - __TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
> - __TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
> + TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
> + TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
> goto discard;
>
>
> --
> 2.8.0.rc3.226.g39d4020
>
Powered by blists - more mailing lists