net: tcp: use tcp_drop_reason() for tcp_data_queue()

Replace tcp_drop() used in tcp_data_queue() with tcp_drop_reason().
Following drop reasons are introduced:

SKB_DROP_REASON_TCP_ZEROWINDOW
SKB_DROP_REASON_TCP_OLD_DATA
SKB_DROP_REASON_TCP_OVERWINDOW

SKB_DROP_REASON_TCP_OLD_DATA is used for the case that end_seq of skb
less than the left edges of receive window. (Maybe there is a better
name?)

Reviewed-by: Mengen Sun <mengensun@tencent.com>
Reviewed-by: Hao Peng <flyingpeng@tencent.com>
Signed-off-by: Menglong Dong <imagedong@tencent.com>
Reviewed-by: Eric Dumazet <edumazet@google.com>
Reviewed-by: David Ahern <dsahern@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 671db9f49efed32b9a41d0fa9a1e90e020f78310..554ef2c848ee36fba7ea676eb52b10605d323077 100644 (file)
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -363,6 +363,19 @@ enum skb_drop_reason {
                                         * LINUX_MIB_TCPBACKLOGDROP)
                                         */
        SKB_DROP_REASON_TCP_FLAGS,      /* TCP flags invalid */
+       SKB_DROP_REASON_TCP_ZEROWINDOW, /* TCP receive window size is zero,
+                                        * see LINUX_MIB_TCPZEROWINDOWDROP
+                                        */
+       SKB_DROP_REASON_TCP_OLD_DATA,   /* the TCP data reveived is already
+                                        * received before (spurious retrans
+                                        * may happened), see
+                                        * LINUX_MIB_DELAYEDACKLOST
+                                        */
+       SKB_DROP_REASON_TCP_OVERWINDOW, /* the TCP data is out of window,
+                                        * the seq of the first byte exceed
+                                        * the right edges of receive
+                                        * window
+                                        */
        SKB_DROP_REASON_MAX,
 };
 

diff --git a/include/trace/events/skb.h b/include/trace/events/skb.h
index d332e7313a61884bc15ee818f067f86520ebc77e..cc1c8f7eaf728cfae43405ab3c12f13f43834d47 100644 (file)
--- a/include/trace/events/skb.h
+++ b/include/trace/events/skb.h
@@ -33,6 +33,9 @@
        EM(SKB_DROP_REASON_TCP_MD5FAILURE, TCP_MD5FAILURE)      \
        EM(SKB_DROP_REASON_SOCKET_BACKLOG, SOCKET_BACKLOG)      \
        EM(SKB_DROP_REASON_TCP_FLAGS, TCP_FLAGS)                \
+       EM(SKB_DROP_REASON_TCP_ZEROWINDOW, TCP_ZEROWINDOW)      \
+       EM(SKB_DROP_REASON_TCP_OLD_DATA, TCP_OLD_DATA)          \
+       EM(SKB_DROP_REASON_TCP_OVERWINDOW, TCP_OVERWINDOW)      \
        EMe(SKB_DROP_REASON_MAX, MAX)
 
 #undef EM

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 2d8495a62bc446012b3be1925797027d84c600d5..041c778fd0b517bda2bbd81e43bf23a226313192 100644 (file)
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -4988,6 +4988,7 @@ void tcp_data_ready(struct sock *sk)
 static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
 {
        struct tcp_sock *tp = tcp_sk(sk);
+       enum skb_drop_reason reason;
        bool fragstolen;
        int eaten;
 
@@ -5006,6 +5007,7 @@ static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
        skb_dst_drop(skb);
        __skb_pull(skb, tcp_hdr(skb)->doff * 4);
 
+       reason = SKB_DROP_REASON_NOT_SPECIFIED;
        tp->rx_opt.dsack = 0;
 
        /*  Queue data for delivery to the user.
@@ -5014,6 +5016,7 @@ static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
         */
        if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
                if (tcp_receive_window(tp) == 0) {
+                       reason = SKB_DROP_REASON_TCP_ZEROWINDOW;
                        NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPZEROWINDOWDROP);
                        goto out_of_window;
                }
@@ -5023,6 +5026,7 @@ queue_and_out:
                if (skb_queue_len(&sk->sk_receive_queue) == 0)
                        sk_forced_mem_schedule(sk, skb->truesize);
                else if (tcp_try_rmem_schedule(sk, skb, skb->truesize)) {
+                       reason = SKB_DROP_REASON_PROTO_MEM;
                        NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVQDROP);
                        sk->sk_data_ready(sk);
                        goto drop;
@@ -5059,6 +5063,7 @@ queue_and_out:
        if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
                tcp_rcv_spurious_retrans(sk, skb);
                /* A retransmit, 2nd most common case.  Force an immediate ack. */
+               reason = SKB_DROP_REASON_TCP_OLD_DATA;
                NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
                tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);
 
@@ -5066,13 +5071,16 @@ out_of_window:
                tcp_enter_quickack_mode(sk, TCP_MAX_QUICKACKS);
                inet_csk_schedule_ack(sk);
 drop:
-               tcp_drop(sk, skb);
+               tcp_drop_reason(sk, skb, reason);
                return;
        }
 
        /* Out of window. F.e. zero window probe. */
-       if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt + tcp_receive_window(tp)))
+       if (!before(TCP_SKB_CB(skb)->seq,
+                   tp->rcv_nxt + tcp_receive_window(tp))) {
+               reason = SKB_DROP_REASON_TCP_OVERWINDOW;
                goto out_of_window;
+       }
 
        if (before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
                /* Partial packet, seq < rcv_next < end_seq */
@@ -5082,6 +5090,7 @@ drop:
                 * remembering D-SACK for its head made in previous line.
                 */
                if (!tcp_receive_window(tp)) {
+                       reason = SKB_DROP_REASON_TCP_ZEROWINDOW;
                        NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPZEROWINDOWDROP);
                        goto out_of_window;
                }