Merge branch 'tcp-add-4-new-stats'

Wei Wang says:

====================
tcp: add 4 new stats

This patch series adds 3 RFC4898 stats:
1. tcpEStatsPerfHCDataOctetsOut
2. tcpEStatsPerfOctetsRetrans
3. tcpEStatsStackDSACKDups
and an addtional stat to record the number of data packet reordering
events seen:
4. tcp_reord_seen

Together with the existing stats, application can use them to measure
the retransmission rate in bytes, exclude spurious retransmissions
reflected by DSACK, and keep track of the reordering events on live
connections.
In particular the networks with different MTUs make bytes-based loss stats
more useful. Google servers have been using these stats for many years to
instrument transport and network performance.

Note: The first patch is a refactor to add a helper to calculate
opt_stats size in order to make later changes cleaner.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

4 files changed, 49 insertions, 5 deletions

diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index f3bfb9f29520..31fa1c080f28 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -2594,6 +2594,10 @@ int tcp_disconnect(struct sock *sk, int flags)
         sk->sk_rx_dst = NULL;
         tcp_saved_syn_free(tp);
         tp->compressed_ack = 0;
+        tp->bytes_sent = 0;
+        tp->bytes_retrans = 0;
+        tp->dsack_dups = 0;
+        tp->reord_seen = 0;
 
         /* Clean up fastopen related fields */
         tcp_free_fastopen_req(tp);
@@ -3201,10 +3205,41 @@ void tcp_get_info(struct sock *sk, struct tcp_info *info)
                 info->tcpi_delivery_rate = rate64;
         info->tcpi_delivered = tp->delivered;
         info->tcpi_delivered_ce = tp->delivered_ce;
+        info->tcpi_bytes_sent = tp->bytes_sent;
+        info->tcpi_bytes_retrans = tp->bytes_retrans;
+        info->tcpi_dsack_dups = tp->dsack_dups;
+        info->tcpi_reord_seen = tp->reord_seen;
         unlock_sock_fast(sk, slow);
 }
 EXPORT_SYMBOL_GPL(tcp_get_info);
 
+static size_t tcp_opt_stats_get_size(void)
+{
+        return
+                nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_BUSY */
+                nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_RWND_LIMITED */
+                nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_SNDBUF_LIMITED */
+                nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_DATA_SEGS_OUT */
+                nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_TOTAL_RETRANS */
+                nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_PACING_RATE */
+                nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_DELIVERY_RATE */
+                nla_total_size(sizeof(u32)) + /* TCP_NLA_SND_CWND */
+                nla_total_size(sizeof(u32)) + /* TCP_NLA_REORDERING */
+                nla_total_size(sizeof(u32)) + /* TCP_NLA_MIN_RTT */
+                nla_total_size(sizeof(u8)) + /* TCP_NLA_RECUR_RETRANS */
+                nla_total_size(sizeof(u8)) + /* TCP_NLA_DELIVERY_RATE_APP_LMT */
+                nla_total_size(sizeof(u32)) + /* TCP_NLA_SNDQ_SIZE */
+                nla_total_size(sizeof(u8)) + /* TCP_NLA_CA_STATE */
+                nla_total_size(sizeof(u32)) + /* TCP_NLA_SND_SSTHRESH */
+                nla_total_size(sizeof(u32)) + /* TCP_NLA_DELIVERED */
+                nla_total_size(sizeof(u32)) + /* TCP_NLA_DELIVERED_CE */
+                nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_BYTES_SENT */
+                nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_BYTES_RETRANS */
+                nla_total_size(sizeof(u32)) + /* TCP_NLA_DSACK_DUPS */
+                nla_total_size(sizeof(u32)) + /* TCP_NLA_REORD_SEEN */
+                0;
+}
+
 struct sk_buff *tcp_get_timestamping_opt_stats(const struct sock *sk)
 {
         const struct tcp_sock *tp = tcp_sk(sk);
@@ -3213,9 +3248,7 @@ struct sk_buff *tcp_get_timestamping_opt_stats(const struct sock *sk)
         u64 rate64;
         u32 rate;
 
-        stats = alloc_skb(7 * nla_total_size_64bit(sizeof(u64)) +
-                          7 * nla_total_size(sizeof(u32)) +
-                          3 * nla_total_size(sizeof(u8)), GFP_ATOMIC);
+        stats = alloc_skb(tcp_opt_stats_get_size(), GFP_ATOMIC);
         if (!stats)
                 return NULL;
 
@@ -3251,6 +3284,13 @@ struct sk_buff *tcp_get_timestamping_opt_stats(const struct sock *sk)
         nla_put_u32(stats, TCP_NLA_SNDQ_SIZE, tp->write_seq - tp->snd_una);
         nla_put_u8(stats, TCP_NLA_CA_STATE, inet_csk(sk)->icsk_ca_state);
 
+        nla_put_u64_64bit(stats, TCP_NLA_BYTES_SENT, tp->bytes_sent,
+                          TCP_NLA_PAD);
+        nla_put_u64_64bit(stats, TCP_NLA_BYTES_RETRANS, tp->bytes_retrans,
+                          TCP_NLA_PAD);
+        nla_put_u32(stats, TCP_NLA_DSACK_DUPS, tp->dsack_dups);
+        nla_put_u32(stats, TCP_NLA_REORD_SEEN, tp->reord_seen);
+
         return stats;
 }
 
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index d51fa358b2b1..3d6156f07a8d 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -874,6 +874,7 @@ static void tcp_dsack_seen(struct tcp_sock *tp)
 {
         tp->rx_opt.sack_ok |= TCP_DSACK_SEEN;
         tp->rack.dsack_seen = 1;
+        tp->dsack_dups++;
 }
 
 /* It's reordering when higher sequence was delivered (i.e. sacked) before
@@ -905,8 +906,8 @@ static void tcp_check_sack_reordering(struct sock *sk, const u32 low_seq,
                                        sock_net(sk)->ipv4.sysctl_tcp_max_reordering);
         }
 
-        tp->rack.reord = 1;
         /* This exciting event is worth to be remembered. 8) */
+        tp->reord_seen++;
         NET_INC_STATS(sock_net(sk),
                       ts ? LINUX_MIB_TCPTSREORDER : LINUX_MIB_TCPSACKREORDER);
 }
@@ -1870,6 +1871,7 @@ static void tcp_check_reno_reordering(struct sock *sk, const int addend)
 
         tp->reordering = min_t(u32, tp->packets_out + addend,
                                sock_net(sk)->ipv4.sysctl_tcp_max_reordering);
+        tp->reord_seen++;
         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRENOREORDER);
 }
 
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 490df62f26d4..50cabf7656f3 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -1136,6 +1136,7 @@ static int __tcp_transmit_skb(struct sock *sk, struct sk_buff *skb,
         if (skb->len != tcp_header_size) {
                 tcp_event_data_sent(tp, sk);
                 tp->data_segs_out += tcp_skb_pcount(skb);
+                tp->bytes_sent += skb->len - tcp_header_size;
                 tcp_internal_pacing(sk, skb);
         }
 
@@ -2870,6 +2871,7 @@ int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
         if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)
                 __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNRETRANS);
         tp->total_retrans += segs;
+        tp->bytes_retrans += skb->len;
 
         /* make sure skb->data is aligned on arches that require it
          * and check if ack-trimming & collapsing extended the headroom
diff --git a/net/ipv4/tcp_recovery.c b/net/ipv4/tcp_recovery.c
index 71593e4400ab..c81aadff769b 100644
--- a/net/ipv4/tcp_recovery.c
+++ b/net/ipv4/tcp_recovery.c
@@ -25,7 +25,7 @@ static u32 tcp_rack_reo_wnd(const struct sock *sk)
 {
         struct tcp_sock *tp = tcp_sk(sk);
 
-        if (!tp->rack.reord) {
+        if (!tp->reord_seen) {
                 /* If reordering has not been observed, be aggressive during
                  * the recovery or starting the recovery by DUPACK threshold.
                  */