tcp: add tcpi_bytes_acked to tcp_info

edumazet · davem330 · commit 0df48c26d841 · 2015-04-29T17:10:37.000-04:00
This patch tracks total number of bytes acked for a TCP socket.
This is the sum of all changes done to tp-&gt;snd_una, and allows
for precise tracking of delivered data.

RFC4898 named this : tcpEStatsAppHCThruOctetsAcked

This is a 64bit field, and can be fetched both from TCP_INFO
getsockopt() if one has a handle on a TCP socket, or from inet_diag
netlink facility (iproute2/ss patch will follow)

Note that tp-&gt;bytes_acked was placed near tp-&gt;snd_una for
best data locality and minimal performance impact.

Signed-off-by: Eric Dumazet &lt;edumazet@google.com&gt;
Acked-by: Yuchung Cheng &lt;ycheng@google.com&gt;
Cc: Matt Mathis &lt;mattmathis@google.com&gt;
Cc: Eric Salo &lt;salo@google.com&gt;
Cc: Martin Lau &lt;kafai@fb.com&gt;
Cc: Chris Rapier &lt;rapier@psc.edu&gt;
Signed-off-by: David S. Miller &lt;davem@davemloft.net&gt;
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
@@ -150,6 +150,10 @@ struct tcp_sock {
 	u32	rcv_wup;	/* rcv_nxt on last window update sent	*/
  	u32	snd_nxt;	/* Next sequence we send		*/
 
+	u64	bytes_acked;	/* RFC4898 tcpEStatsAppHCThruOctetsAcked
+				 * sum(delta(snd_una)), or how many bytes
+				 * were acked.
+				 */
  	u32	snd_una;	/* First byte we want an ack for	*/
  	u32	snd_sml;	/* Last byte of the most recently transmitted small packet */
 	u32	rcv_tstamp;	/* timestamp of last received ACK (for keepalives) */
diff --git a/include/net/tcp.h b/include/net/tcp.h
@@ -576,7 +576,7 @@ static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize)
 }
 
 /* tcp.c */
-void tcp_get_info(const struct sock *, struct tcp_info *);
+void tcp_get_info(struct sock *, struct tcp_info *);
 
 /* Read 'sendfile()'-style from a TCP socket */
 typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *,
diff --git a/include/uapi/linux/tcp.h b/include/uapi/linux/tcp.h
@@ -189,6 +189,7 @@ struct tcp_info {
 
 	__u64	tcpi_pacing_rate;
 	__u64	tcpi_max_pacing_rate;
+	__u64	tcpi_bytes_acked; /* RFC4898 tcpEStatsAppHCThruOctetsAcked */
 };
 
 /* for TCP_MD5SIG socket option */
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
@@ -2592,7 +2592,7 @@ EXPORT_SYMBOL(compat_tcp_setsockopt);
 #endif
 
 /* Return information about state of tcp endpoint in API format. */
-void tcp_get_info(const struct sock *sk, struct tcp_info *info)
+void tcp_get_info(struct sock *sk, struct tcp_info *info)
 {
 	const struct tcp_sock *tp = tcp_sk(sk);
 	const struct inet_connection_sock *icsk = inet_csk(sk);
@@ -2663,6 +2663,10 @@ void tcp_get_info(const struct sock *sk, struct tcp_info *info)
 
 	rate = READ_ONCE(sk->sk_max_pacing_rate);
 	info->tcpi_max_pacing_rate = rate != ~0U ? rate : ~0ULL;
+
+	spin_lock_bh(&sk->sk_lock.slock);
+	info->tcpi_bytes_acked = tp->bytes_acked;
+	spin_unlock_bh(&sk->sk_lock.slock);
 }
 EXPORT_SYMBOL_GPL(tcp_get_info);
 
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
@@ -3280,6 +3280,15 @@ static inline bool tcp_may_update_window(const struct tcp_sock *tp,
 		(ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd);
 }
 
+/* If we update tp->snd_una, also update tp->bytes_acked */
+static void tcp_snd_una_update(struct tcp_sock *tp, u32 ack)
+{
+	u32 delta = ack - tp->snd_una;
+
+	tp->bytes_acked += delta;
+	tp->snd_una = ack;
+}
+
 /* Update our send window.
  *
  * Window update algorithm, described in RFC793/RFC1122 (used in linux-2.2
@@ -3315,7 +3324,7 @@ static int tcp_ack_update_window(struct sock *sk, const struct sk_buff *skb, u32
 		}
 	}
 
-	tp->snd_una = ack;
+	tcp_snd_una_update(tp, ack);
 
 	return flag;
 }
@@ -3497,7 +3506,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
 		 * Note, we use the fact that SND.UNA>=SND.WL2.
 		 */
 		tcp_update_wl(tp, ack_seq);
-		tp->snd_una = ack;
+		tcp_snd_una_update(tp, ack);
 		flag |= FLAG_WIN_UPDATE;
 
 		tcp_in_ack_event(sk, CA_ACK_WIN_UPDATE);

Original file line number	Diff line number	Diff line change
`@@ -576,7 +576,7 @@ static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize)`
`576`	`576`	`}`
`577`	`577`
`578`	`578`	`/* tcp.c */`
`579`		`-void tcp_get_info(const struct sock , struct tcp_info );`
	`579`	`+void tcp_get_info(struct sock , struct tcp_info );`
`580`	`580`
`581`	`581`	`/* Read 'sendfile()'-style from a TCP socket */`
`582`	`582`	`typedef int (sk_read_actor_t)(read_descriptor_t , struct sk_buff *,`
Original file line number	Diff line number	Diff line change
`@@ -3280,6 +3280,15 @@ static inline bool tcp_may_update_window(const struct tcp_sock *tp,`
`3280`	`3280`	`(ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd);`
`3281`	`3281`	`}`
`3282`	`3282`
	`3283`	`+/* If we update tp->snd_una, also update tp->bytes_acked */`
	`3284`	`+static void tcp_snd_una_update(struct tcp_sock *tp, u32 ack)`
	`3285`	`+{`
	`3286`	`+ u32 delta = ack - tp->snd_una;`
	`3287`	`+`
	`3288`	`+ tp->bytes_acked += delta;`
	`3289`	`+ tp->snd_una = ack;`
	`3290`	`+}`
	`3291`	`+`
`3283`	`3292`	`/* Update our send window.`
`3284`	`3293`	`*`
`3285`	`3294`	`* Window update algorithm, described in RFC793/RFC1122 (used in linux-2.2`
`@@ -3315,7 +3324,7 @@ static int tcp_ack_update_window(struct sock sk, const struct sk_buff skb, u32`
`3315`	`3324`	`}`
`3316`	`3325`	`}`
`3317`	`3326`
`3318`		`- tp->snd_una = ack;`
	`3327`	`+ tcp_snd_una_update(tp, ack);`
`3319`	`3328`
`3320`	`3329`	`return flag;`
`3321`	`3330`	`}`
`@@ -3497,7 +3506,7 @@ static int tcp_ack(struct sock sk, const struct sk_buff skb, int flag)`
`3497`	`3506`	`* Note, we use the fact that SND.UNA>=SND.WL2.`
`3498`	`3507`	`*/`
`3499`	`3508`	`tcp_update_wl(tp, ack_seq);`
`3500`		`- tp->snd_una = ack;`
	`3509`	`+ tcp_snd_una_update(tp, ack);`
`3501`	`3510`	`flag \|= FLAG_WIN_UPDATE;`
`3502`	`3511`
`3503`	`3512`	`tcp_in_ack_event(sk, CA_ACK_WIN_UPDATE);`