tcp: Extend SOF_TIMESTAMPING_RX_SOFTWARE to TCP recvmsg

When SOF_TIMESTAMPING_RX_SOFTWARE is enabled for tcp sockets, return the
timestamp corresponding to the highest sequence number data returned.

Previously the skb->tstamp is overwritten when a TCP packet is placed
in the out of order queue.  While the packet is in the ooo queue, save the
timestamp in the TCB_SKB_CB.  This space is shared with the gso_*
options which are only used on the tx path, and a previously unused 4
byte hole.

When skbs are coalesced either in the sk_receive_queue or the
out_of_order_queue always choose the timestamp of the appended skb to
maintain the invariant of returning the timestamp of the last byte in
the recvmsg buffer.

Signed-off-by: Mike Maloney <maloney@google.com>
Acked-by: Willem de Bruijn <willemb@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 31 insertions, 4 deletions

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index d3421ee9a10a..568ccfd6dd37 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -4246,9 +4246,15 @@ static void tcp_sack_remove(struct tcp_sock *tp)
         tp->rx_opt.num_sacks = num_sacks;
 }
 
+enum tcp_queue {
+        OOO_QUEUE,
+        RCV_QUEUE,
+};
+
 /**
  * tcp_try_coalesce - try to merge skb to prior one
  * @sk: socket
+ * @dest: destination queue
  * @to: prior buffer
  * @from: buffer to add in queue
  * @fragstolen: pointer to boolean
@@ -4260,6 +4266,7 @@ static void tcp_sack_remove(struct tcp_sock *tp)
  * Returns true if caller should free @from instead of queueing it
  */
 static bool tcp_try_coalesce(struct sock *sk,
+                             enum tcp_queue dest,
                              struct sk_buff *to,
                              struct sk_buff *from,
                              bool *fragstolen)
@@ -4281,6 +4288,15 @@ static bool tcp_try_coalesce(struct sock *sk,
         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;
+
+        if (TCP_SKB_CB(from)->has_rxtstamp) {
+                TCP_SKB_CB(to)->has_rxtstamp = true;
+                if (dest == OOO_QUEUE)
+                        TCP_SKB_CB(to)->swtstamp = TCP_SKB_CB(from)->swtstamp;
+                else
+                        to->tstamp = from->tstamp;
+        }
+
         return true;
 }
 
@@ -4315,6 +4331,9 @@ static void tcp_ofo_queue(struct sock *sk)
                 }
                 p = rb_next(p);
                 rb_erase(&skb->rbnode, &tp->out_of_order_queue);
+                /* Replace tstamp which was stomped by rbnode */
+                if (TCP_SKB_CB(skb)->has_rxtstamp)
+                        skb->tstamp = TCP_SKB_CB(skb)->swtstamp;
 
                 if (unlikely(!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt))) {
                         SOCK_DEBUG(sk, "ofo packet was already received\n");
@@ -4326,7 +4345,8 @@ static void tcp_ofo_queue(struct sock *sk)
                            TCP_SKB_CB(skb)->end_seq);
 
                 tail = skb_peek_tail(&sk->sk_receive_queue);
-                eaten = tail && tcp_try_coalesce(sk, tail, skb, &fragstolen);
+                eaten = tail && tcp_try_coalesce(sk, RCV_QUEUE,
+                                                 tail, skb, &fragstolen);
                 tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
                 fin = TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN;
                 if (!eaten)
@@ -4380,6 +4400,10 @@ static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
                 return;
         }
 
+        /* Stash tstamp to avoid being stomped on by rbnode */
+        if (TCP_SKB_CB(skb)->has_rxtstamp)
+                TCP_SKB_CB(skb)->swtstamp = skb->tstamp;
+
         inet_csk_schedule_ack(sk);
 
         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOQUEUE);
@@ -4405,7 +4429,8 @@ static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
         /* In the typical case, we are adding an skb to the end of the list.
          * Use of ooo_last_skb avoids the O(Log(N)) rbtree lookup.
          */
-        if (tcp_try_coalesce(sk, tp->ooo_last_skb, skb, &fragstolen)) {
+        if (tcp_try_coalesce(sk, OOO_QUEUE, tp->ooo_last_skb,
+                             skb, &fragstolen)) {
 coalesce_done:
                 tcp_grow_window(sk, skb);
                 kfree_skb_partial(skb, fragstolen);
@@ -4455,7 +4480,8 @@ coalesce_done:
                                 __kfree_skb(skb1);
                                 goto merge_right;
                         }
-                } else if (tcp_try_coalesce(sk, skb1, skb, &fragstolen)) {
+                } else if (tcp_try_coalesce(sk, OOO_QUEUE, skb1,
+                                            skb, &fragstolen)) {
                         goto coalesce_done;
                 }
                 p = &parent->rb_right;
@@ -4506,7 +4532,8 @@ static int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb, int
 
         __skb_pull(skb, hdrlen);
         eaten = (tail &&
-                 tcp_try_coalesce(sk, tail, skb, fragstolen)) ? 1 : 0;
+                 tcp_try_coalesce(sk, RCV_QUEUE, tail,
+                                  skb, fragstolen)) ? 1 : 0;
         tcp_rcv_nxt_update(tcp_sk(sk), TCP_SKB_CB(skb)->end_seq);
         if (!eaten) {
                 __skb_queue_tail(&sk->sk_receive_queue, skb);