io_uring cmd for tx timestamps

Add a helper function skb_get_tx_timestamp() that returns a tx timestamp associated with an skb from an queue queue.

Signed-off-by Pavel Begunkov <[email protected]>

Add a helper function skb_get_tx_timestamp() that returns a tx timestamp associated with an skb from an queue queue.

Signed-off-by Pavel Begunkov <[email protected]>

Add a helper function skb_get_tx_timestamp() that returns a tx timestamp associated with an skb from an queue queue.

Signed-off-by Pavel Begunkov <[email protected]>

---
 include/net/sock.h |  4 ++++
 net/socket.c       | 43 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+)

include/net/sock.h +4 -0

index 92e7c1aae3cc..1cd288880ab3 100644
@@ -2677,6 +2677,10 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
 void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
                             struct sk_buff *skb);
 
+bool skb_has_tx_timestamp(struct sk_buff *skb, const struct sock *sk);
+bool skb_get_tx_timestamp(struct sk_buff *skb, struct sock *sk,
+                         struct timespec64 *ts);
+
 static inline void
 sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
 {

net/socket.c +43 -1

index 9a0e720f0859..e9c8f3074fe1 100644
@@ -843,6 +843,49 @@ static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb,
                 sizeof(ts_pktinfo), &ts_pktinfo);
 }
 
+bool skb_has_tx_timestamp(struct sk_buff *skb, const struct sock *sk)
+{
+       const struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
+       u32 tsflags = READ_ONCE(sk->sk_tsflags);
+
+       if (serr->ee.ee_errno != ENOMSG ||
+          serr->ee.ee_origin != SO_EE_ORIGIN_TIMESTAMPING)
+               return false;
+
+       /* software time stamp available and wanted */
+       if ((tsflags & SOF_TIMESTAMPING_SOFTWARE) && skb->tstamp)
+               return true;
+       /* hardware time stamps available and wanted */
+       return (tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
+               skb_hwtstamps(skb)->hwtstamp;
+}
+
+bool skb_get_tx_timestamp(struct sk_buff *skb, struct sock *sk,
+                         struct timespec64 *ts)
+{
+       u32 tsflags = READ_ONCE(sk->sk_tsflags);
+       ktime_t hwtstamp;
+       int if_index = 0;
+
+       if ((tsflags & SOF_TIMESTAMPING_SOFTWARE) &&
+           ktime_to_timespec64_cond(skb->tstamp, ts))
+               return true;
+
+       if (!(tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) ||
+           skb_is_swtx_tstamp(skb, false))
+               return false;
+
+       if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP_NETDEV)
+               hwtstamp = get_timestamp(sk, skb, &if_index);
+       else
+               hwtstamp = skb_hwtstamps(skb)->hwtstamp;
+
+       if (tsflags & SOF_TIMESTAMPING_BIND_PHC)
+               hwtstamp = ptp_convert_timestamp(&hwtstamp,
+                                               READ_ONCE(sk->sk_bind_phc));
+       return ktime_to_timespec64_cond(hwtstamp, ts);
+}
+
 /*
  * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
  */
--

2.49.0

Add a new socket command which returns tx time stamps to the user. It provide an alternative to the existing error queue recvmsg interface. The command works in a polled multishot mode, which means io_uring will poll the socket and keep posting timestamps until the request is cancelled or fails in any other way (e.g. with no space in the CQ). It reuses the net infra and grabs timestamps from the socket's error queue.

The command requires IORING_SETUP_CQE32. All non-final CQEs (marked with IORING_CQE_F_MORE) have cqe->res set to the tskey, and the upper 16 bits of cqe->flags keep tstype (i.e. offset by IORING_CQE_BUFFER_SHIFT). The timevalue is store in the upper part of the extended CQE. The final completion won't have IORING_CQR_F_MORE and will have cqe->res storing

io_uring/cmd_net.c +10 -0

+static bool io_process_timestamp_skb(struct io_uring_cmd *cmd, struct sock *sk,
+				     struct sk_buff *skb, unsigned issue_flags)
+{
+	struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
+	struct io_uring_cqe cqe[2];
+	struct io_timespec *iots;
+	struct timespec64 ts;
+	u32 tskey;
+
+	BUILD_BUG_ON(sizeof(struct io_uring_cqe) != sizeof(struct io_timespec));

Quoted 7 lines · Pavel Begunkov

Add a new socket command which returns tx time stamps to the user. It provide an alternative to the existing error queue recvmsg interface. The command works in a polled multishot mode, which means io_uring will poll the socket and keep posting timestamps until the request is cancelled or fails in any other way (e.g. with no space in the CQ). It reuses the net infra and grabs timestamps from the socket's error queue.

Quoted 5 lines

The command requires IORING_SETUP_CQE32. All non-final CQEs (marked with IORING_CQE_F_MORE) have cqe->res set to the tskey, and the upper 16 bits of cqe->flags keep tstype (i.e. offset by IORING_CQE_BUFFER_SHIFT). The timevalue is store in the upper part of the extended CQE. The final completion won't have IORING_CQR_F_MORE and will have cqe->res storing

                          ^^

CQE_F_MORE

Minor nit below.

Quoted 14 lines

io_uring/cmd_net.c +14 -0

+static bool io_process_timestamp_skb(struct io_uring_cmd *cmd, struct sock *sk,
+				     struct sk_buff *skb, unsigned issue_flags)
+{
+	struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
+	struct io_uring_cqe cqe[2];
+	struct io_timespec *iots;
+	struct timespec64 ts;
+	u32 tskey;
+
+	BUILD_BUG_ON(sizeof(struct io_uring_cqe) != sizeof(struct io_timespec));
+
+	if (!skb_get_tx_timestamp(skb, sk, &ts))
+		return false;
+

io_uring/cmd_net.c static inline int io_uring_cmd_setsockopt(struct socket *sock, · line 74

Quoted 6 lines

io_uring/cmd_net.c +6 -0

+	tskey = serr->ee.ee_data;
+
+	cqe->user_data = 0;
+	cqe->res = tskey;
+	cqe->flags = IORING_CQE_F_MORE;
+	cqe->flags |= (u32)serr->ee.ee_info << IORING_CQE_BUFFER_SHIFT;

Get rid of the tskey variable?

readable if it used:

	cqe[0].user_data = 0;

etc.

io_uring/cmd_net.c static inline int io_uring_cmd_setsockopt(struct socket *sock, · line 80

Quoted 5 lines

io_uring/cmd_net.c +5 -0

+	iots = (struct io_timespec *)&cqe[1];
+	iots->tv_sec = ts.tv_sec;
+	iots->tv_nsec = ts.tv_nsec;
+	return io_uring_cmd_post_mshot_cqe32(cmd, issue_flags, cqe);
+}

A bit of a shame we can't just get the double CQE and fill it in, rather than fill it on stack and copy it. But probably doesn't matter much.

Add a new socket command which returns tx time stamps to the user. It provide an alternative to the existing error queue recvmsg interface. The command works in a polled multishot mode, which means io_uring will poll the socket and keep posting timestamps until the request is cancelled or fails in any other way (e.g. with no space in the CQ). It reuses the net infra and grabs timestamps from the socket's error queue.

The command requires IORING_SETUP_CQE32. All non-final CQEs (marked with IORING_CQE_F_MORE) have cqe->res set to the tskey, and the upper 16 bits of cqe->flags keep tstype (i.e. offset by IORING_CQE_BUFFER_SHIFT). The timevalue is store in the upper part of the extended CQE. The final completion won't have IORING_CQR_F_MORE and will have cqe->res storing 0/error.

Suggested-by Vadim Fedorenko <[email protected]>

Signed-off-by Pavel Begunkov <[email protected]>

---
 include/uapi/linux/io_uring.h |  6 +++
 io_uring/cmd_net.c            | 77 +++++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+)

include/uapi/linux/io_uring.h +6 -0

index cfd17e382082..0bc156eb96d4 100644
@@ -960,6 +960,11 @@ struct io_uring_recvmsg_out {
 	__u32 flags;
 };
 
+struct io_timespec {
+	__u64		tv_sec;
+	__u64		tv_nsec;
+};
+
 /*
  * Argument for IORING_OP_URING_CMD when file is a socket
  */

@@ -968,6 +973,7 @@ enum io_uring_socket_op {
 	SOCKET_URING_OP_SIOCOUTQ,
 	SOCKET_URING_OP_GETSOCKOPT,
 	SOCKET_URING_OP_SETSOCKOPT,
+	SOCKET_URING_OP_TX_TIMESTAMP,
 };
 
 /* Zero copy receive refill queue entry */

io_uring/cmd_net.c +15 -0

index e99170c7d41a..dae59aea5847 100644
@@ -1,5 +1,6 @@
 #include <asm/ioctls.h>
 #include <linux/io_uring/net.h>
+#include <linux/errqueue.h>
 #include <net/sock.h>
 
 #include "uring_cmd.h"

@@ -51,6 +52,80 @@ static inline int io_uring_cmd_setsockopt(struct socket *sock,
 				  optlen);
 }
 
+static bool io_process_timestamp_skb(struct io_uring_cmd *cmd, struct sock *sk,
+				     struct sk_buff *skb, unsigned issue_flags)
+{
+	struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
+	struct io_uring_cqe cqe[2];
+	struct io_timespec *iots;
+	struct timespec64 ts;
+	u32 tskey;
+
+	BUILD_BUG_ON(sizeof(struct io_uring_cqe) != sizeof(struct io_timespec));
+
+	if (!skb_get_tx_timestamp(skb, sk, &ts))
+		return false;
+

io_uring/cmd_net.c +52 -0

+	return io_uring_cmd_post_mshot_cqe32(cmd, issue_flags, cqe);
+}
+
+static int io_uring_cmd_timestamp(struct socket *sock,
+				  struct io_uring_cmd *cmd,
+				  unsigned int issue_flags)
+{
+	struct sock *sk = sock->sk;
+	struct sk_buff_head *q = &sk->sk_error_queue;
+	struct sk_buff *skb, *tmp;
+	struct sk_buff_head list;
+	int ret;
+
+	if (!(issue_flags & IO_URING_F_CQE32))
+		return -EINVAL;
+	ret = io_cmd_poll_multishot(cmd, issue_flags, EPOLLERR);
+	if (unlikely(ret))
+		return ret;
+
+	if (skb_queue_empty_lockless(q))
+		return -EAGAIN;
+	__skb_queue_head_init(&list);
+
+	scoped_guard(spinlock_irq, &q->lock) {
+		skb_queue_walk_safe(q, skb, tmp) {
+			/* don't support skbs with payload */
+			if (!skb_has_tx_timestamp(skb, sk) || skb->len)
+				continue;
+			__skb_unlink(skb, q);
+			__skb_queue_tail(&list, skb);
+		}
+	}
+
+	while (1) {
+		skb = skb_peek(&list);
+		if (!skb)
+			break;
+		if (!io_process_timestamp_skb(cmd, sk, skb, issue_flags))
+			break;
+		__skb_dequeue(&list);
+		consume_skb(skb);
+	}
+
+	if (!unlikely(skb_queue_empty(&list))) {
+		scoped_guard(spinlock_irqsave, &q->lock)
+			skb_queue_splice(q, &list);
+	}
+	return -EAGAIN;
+}
+
 int io_uring_cmd_sock(struct io_uring_cmd *cmd, unsigned int issue_flags)
 {
 	struct socket *sock = cmd->file->private_data;

@@ -76,6 +151,8 @@ int io_uring_cmd_sock(struct io_uring_cmd *cmd, unsigned int issue_flags)
 		return io_uring_cmd_getsockopt(sock, cmd, issue_flags);
 	case SOCKET_URING_OP_SETSOCKOPT:
 		return io_uring_cmd_setsockopt(sock, cmd, issue_flags);
+	case SOCKET_URING_OP_TX_TIMESTAMP:
+		return io_uring_cmd_timestamp(sock, cmd, issue_flags);
 	default:
 		return -EOPNOTSUPP;
 	}

Signature · 1 line

2.49.0

Quoted 74 lines · Pavel Begunkov

Add a new socket command which returns tx time stamps to the user. It provide an alternative to the existing error queue recvmsg interface. The command works in a polled multishot mode, which means io_uring will poll the socket and keep posting timestamps until the request is cancelled or fails in any other way (e.g. with no space in the CQ). It reuses the net infra and grabs timestamps from the socket's error queue.

The command requires IORING_SETUP_CQE32. All non-final CQEs (marked with IORING_CQE_F_MORE) have cqe->res set to the tskey, and the upper 16 bits of cqe->flags keep tstype (i.e. offset by IORING_CQE_BUFFER_SHIFT). The timevalue is store in the upper part of the extended CQE. The final completion won't have IORING_CQR_F_MORE and will have cqe->res storing 0/error.

Suggested-by Vadim Fedorenko <[email protected]>

Signed-off-by Pavel Begunkov <[email protected]>

---
  include/uapi/linux/io_uring.h |  6 +++
  io_uring/cmd_net.c            | 77 +++++++++++++++++++++++++++++++++++
  2 files changed, 83 insertions(+)

include/uapi/linux/io_uring.h +6 -0

index cfd17e382082..0bc156eb96d4 100644
@@ -960,6 +960,11 @@ struct io_uring_recvmsg_out {
  	__u32 flags;
  };
 
+struct io_timespec {
+	__u64		tv_sec;
+	__u64		tv_nsec;
+};
+
  /*
   * Argument for IORING_OP_URING_CMD when file is a socket
   */

@@ -968,6 +973,7 @@ enum io_uring_socket_op {
  	SOCKET_URING_OP_SIOCOUTQ,
  	SOCKET_URING_OP_GETSOCKOPT,
  	SOCKET_URING_OP_SETSOCKOPT,
+	SOCKET_URING_OP_TX_TIMESTAMP,
  };
 
  /* Zero copy receive refill queue entry */

io_uring/cmd_net.c +15 -0

index e99170c7d41a..dae59aea5847 100644
@@ -1,5 +1,6 @@
  #include <asm/ioctls.h>
  #include <linux/io_uring/net.h>
+#include <linux/errqueue.h>
  #include <net/sock.h>
 
  #include "uring_cmd.h"

@@ -51,6 +52,80 @@ static inline int io_uring_cmd_setsockopt(struct socket *sock,
  				  optlen);
  }
 
+static bool io_process_timestamp_skb(struct io_uring_cmd *cmd, struct sock *sk,
+				     struct sk_buff *skb, unsigned issue_flags)
+{
+	struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
+	struct io_uring_cqe cqe[2];
+	struct io_timespec *iots;
+	struct timespec64 ts;
+	u32 tskey;
+
+	BUILD_BUG_ON(sizeof(struct io_uring_cqe) != sizeof(struct io_timespec));
+
+	if (!skb_get_tx_timestamp(skb, sk, &ts))
+		return false;
+

io_uring/cmd_net.c static inline int io_uring_cmd_setsockopt(struct socket *sock, · line 78

Quoted 10 lines

io_uring/cmd_net.c +10 -0

+	tskey = serr->ee.ee_data;
+
+	cqe->user_data = 0;
+	cqe->res = tskey;
+	cqe->flags = IORING_CQE_F_MORE;
+	cqe->flags |= (u32)serr->ee.ee_info << IORING_CQE_BUFFER_SHIFT;
+
+	iots = (struct io_timespec *)&cqe[1];
+	iots->tv_sec = ts.tv_sec;
+	iots->tv_nsec = ts.tv_nsec;

skb_get_tx_timestamp loses the information whether this is a software or a hardware timestamp. Is that loss problematic?

If a process only requests one type of timestamp, it will not be.

But when requesting both (SOF_TIMESTAMPING_OPT_TX_SWHW) this per cqe annotation may be necessary.

Quoted 66 lines

io_uring/cmd_net.c +52 -0

+	return io_uring_cmd_post_mshot_cqe32(cmd, issue_flags, cqe);
+}
+
+static int io_uring_cmd_timestamp(struct socket *sock,
+				  struct io_uring_cmd *cmd,
+				  unsigned int issue_flags)
+{
+	struct sock *sk = sock->sk;
+	struct sk_buff_head *q = &sk->sk_error_queue;
+	struct sk_buff *skb, *tmp;
+	struct sk_buff_head list;
+	int ret;
+
+	if (!(issue_flags & IO_URING_F_CQE32))
+		return -EINVAL;
+	ret = io_cmd_poll_multishot(cmd, issue_flags, EPOLLERR);
+	if (unlikely(ret))
+		return ret;
+
+	if (skb_queue_empty_lockless(q))
+		return -EAGAIN;
+	__skb_queue_head_init(&list);
+
+	scoped_guard(spinlock_irq, &q->lock) {
+		skb_queue_walk_safe(q, skb, tmp) {
+			/* don't support skbs with payload */
+			if (!skb_has_tx_timestamp(skb, sk) || skb->len)
+				continue;
+			__skb_unlink(skb, q);
+			__skb_queue_tail(&list, skb);
+		}
+	}
+
+	while (1) {
+		skb = skb_peek(&list);
+		if (!skb)
+			break;
+		if (!io_process_timestamp_skb(cmd, sk, skb, issue_flags))
+			break;
+		__skb_dequeue(&list);
+		consume_skb(skb);
+	}
+
+	if (!unlikely(skb_queue_empty(&list))) {
+		scoped_guard(spinlock_irqsave, &q->lock)
+			skb_queue_splice(q, &list);
+	}
+	return -EAGAIN;
+}
+
  int io_uring_cmd_sock(struct io_uring_cmd *cmd, unsigned int issue_flags)
  {
  	struct socket *sock = cmd->file->private_data;

@@ -76,6 +151,8 @@ int io_uring_cmd_sock(struct io_uring_cmd *cmd, unsigned int issue_flags)
  		return io_uring_cmd_getsockopt(sock, cmd, issue_flags);
  	case SOCKET_URING_OP_SETSOCKOPT:
  		return io_uring_cmd_setsockopt(sock, cmd, issue_flags);
+	case SOCKET_URING_OP_TX_TIMESTAMP:
+		return io_uring_cmd_timestamp(sock, cmd, issue_flags);
  	default:
  		return -EOPNOTSUPP;
  	}

Signature · 1 line

2.49.0

Quoted 1 line · Willem de Bruijn

Pavel Begunkov wrote:

Quoted 16 lines

io_uring/cmd_net.c static inline int io_uring_cmd_setsockopt(struct socket *sock, · line 78

Quoted 10 lines

+    tskey = serr->ee.ee_data;

io_uring/cmd_net.c +9 -0

+
+    cqe->user_data = 0;
+    cqe->res = tskey;
+    cqe->flags = IORING_CQE_F_MORE;
+    cqe->flags |= (u32)serr->ee.ee_info << IORING_CQE_BUFFER_SHIFT;
+
+    iots = (struct io_timespec *)&cqe[1];
+    iots->tv_sec = ts.tv_sec;
+    iots->tv_nsec = ts.tv_nsec;

skb_get_tx_timestamp loses the information whether this is a software or a hardware timestamp. Is that loss problematic?

If a process only requests one type of timestamp, it will not be.

Quoted 2 lines

But when requesting both (SOF_TIMESTAMPING_OPT_TX_SWHW) this per cqe annotation may be necessary.

skb_has_tx_timestamp() helper has clear priority of software timestamp, if enabled for the socket. Looks like SOF_TIMESTAMPING_OPT_TX_SWHW case won't produce both timestamps with the current implementation. Am I missing something?

Quoted 91 lines · Willem de Bruijn

Quoted 74 lines · Pavel Begunkov

Add a new socket command which returns tx time stamps to the user. It provide an alternative to the existing error queue recvmsg interface. The command works in a polled multishot mode, which means io_uring will poll the socket and keep posting timestamps until the request is cancelled or fails in any other way (e.g. with no space in the CQ). It reuses the net infra and grabs timestamps from the socket's error queue.

The command requires IORING_SETUP_CQE32. All non-final CQEs (marked with IORING_CQE_F_MORE) have cqe->res set to the tskey, and the upper 16 bits of cqe->flags keep tstype (i.e. offset by IORING_CQE_BUFFER_SHIFT). The timevalue is store in the upper part of the extended CQE. The final completion won't have IORING_CQR_F_MORE and will have cqe->res storing 0/error.

Suggested-by Vadim Fedorenko <[email protected]>

Signed-off-by Pavel Begunkov <[email protected]>

---
  include/uapi/linux/io_uring.h |  6 +++
  io_uring/cmd_net.c            | 77 +++++++++++++++++++++++++++++++++++
  2 files changed, 83 insertions(+)

include/uapi/linux/io_uring.h +6 -0

index cfd17e382082..0bc156eb96d4 100644
@@ -960,6 +960,11 @@ struct io_uring_recvmsg_out {
  	__u32 flags;
  };
 
+struct io_timespec {
+	__u64		tv_sec;
+	__u64		tv_nsec;
+};
+
  /*
   * Argument for IORING_OP_URING_CMD when file is a socket
   */

@@ -968,6 +973,7 @@ enum io_uring_socket_op {
  	SOCKET_URING_OP_SIOCOUTQ,
  	SOCKET_URING_OP_GETSOCKOPT,
  	SOCKET_URING_OP_SETSOCKOPT,
+	SOCKET_URING_OP_TX_TIMESTAMP,
  };
 
  /* Zero copy receive refill queue entry */

io_uring/cmd_net.c +15 -0

index e99170c7d41a..dae59aea5847 100644
@@ -1,5 +1,6 @@
  #include <asm/ioctls.h>
  #include <linux/io_uring/net.h>
+#include <linux/errqueue.h>
  #include <net/sock.h>
 
  #include "uring_cmd.h"

@@ -51,6 +52,80 @@ static inline int io_uring_cmd_setsockopt(struct socket *sock,
  				  optlen);
  }
 
+static bool io_process_timestamp_skb(struct io_uring_cmd *cmd, struct sock *sk,
+				     struct sk_buff *skb, unsigned issue_flags)
+{
+	struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
+	struct io_uring_cqe cqe[2];
+	struct io_timespec *iots;
+	struct timespec64 ts;
+	u32 tskey;
+
+	BUILD_BUG_ON(sizeof(struct io_uring_cqe) != sizeof(struct io_timespec));
+
+	if (!skb_get_tx_timestamp(skb, sk, &ts))
+		return false;
+

io_uring/cmd_net.c static inline int io_uring_cmd_setsockopt(struct socket *sock, · line 78

Quoted 10 lines

io_uring/cmd_net.c +10 -0

+	tskey = serr->ee.ee_data;
+
+	cqe->user_data = 0;
+	cqe->res = tskey;
+	cqe->flags = IORING_CQE_F_MORE;
+	cqe->flags |= (u32)serr->ee.ee_info << IORING_CQE_BUFFER_SHIFT;
+
+	iots = (struct io_timespec *)&cqe[1];
+	iots->tv_sec = ts.tv_sec;
+	iots->tv_nsec = ts.tv_nsec;

skb_get_tx_timestamp loses the information whether this is a software or a hardware timestamp. Is that loss problematic?

If a process only requests one type of timestamp, it will not be.

Quoted 2 lines

But when requesting both (SOF_TIMESTAMPING_OPT_TX_SWHW) this per cqe annotation may be necessary.

skb_has_tx_timestamp() helper has clear priority of software timestamp, if enabled for the socket. Looks like SOF_TIMESTAMPING_OPT_TX_SWHW case won't produce both timestamps with the current implementation. Am I missing something?

Quoted 95 lines · Vadim Fedorenko

Quoted 93 lines · Willem de Bruijn

Quoted 74 lines · Pavel Begunkov

Add a new socket command which returns tx time stamps to the user. It provide an alternative to the existing error queue recvmsg interface. The command works in a polled multishot mode, which means io_uring will poll the socket and keep posting timestamps until the request is cancelled or fails in any other way (e.g. with no space in the CQ). It reuses the net infra and grabs timestamps from the socket's error queue.

The command requires IORING_SETUP_CQE32. All non-final CQEs (marked with IORING_CQE_F_MORE) have cqe->res set to the tskey, and the upper 16 bits of cqe->flags keep tstype (i.e. offset by IORING_CQE_BUFFER_SHIFT). The timevalue is store in the upper part of the extended CQE. The final completion won't have IORING_CQR_F_MORE and will have cqe->res storing 0/error.

Suggested-by Vadim Fedorenko <[email protected]>

Signed-off-by Pavel Begunkov <[email protected]>

---
  include/uapi/linux/io_uring.h |  6 +++
  io_uring/cmd_net.c            | 77 +++++++++++++++++++++++++++++++++++
  2 files changed, 83 insertions(+)

include/uapi/linux/io_uring.h +6 -0

index cfd17e382082..0bc156eb96d4 100644
@@ -960,6 +960,11 @@ struct io_uring_recvmsg_out {
   __u32 flags;
  };
 
+struct io_timespec {
+  __u64           tv_sec;
+  __u64           tv_nsec;
+};
+
  /*
   * Argument for IORING_OP_URING_CMD when file is a socket
   */

@@ -968,6 +973,7 @@ enum io_uring_socket_op {
   SOCKET_URING_OP_SIOCOUTQ,
   SOCKET_URING_OP_GETSOCKOPT,
   SOCKET_URING_OP_SETSOCKOPT,
+  SOCKET_URING_OP_TX_TIMESTAMP,
  };
 
  /* Zero copy receive refill queue entry */

io_uring/cmd_net.c +15 -0

index e99170c7d41a..dae59aea5847 100644
@@ -1,5 +1,6 @@
  #include <asm/ioctls.h>
  #include <linux/io_uring/net.h>
+#include <linux/errqueue.h>
  #include <net/sock.h>
 
  #include "uring_cmd.h"

@@ -51,6 +52,80 @@ static inline int io_uring_cmd_setsockopt(struct socket *sock,
                             optlen);
  }
 
+static bool io_process_timestamp_skb(struct io_uring_cmd *cmd, struct sock *sk,
+                               struct sk_buff *skb, unsigned issue_flags)
+{
+  struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
+  struct io_uring_cqe cqe[2];
+  struct io_timespec *iots;
+  struct timespec64 ts;
+  u32 tskey;
+
+  BUILD_BUG_ON(sizeof(struct io_uring_cqe) != sizeof(struct io_timespec));
+
+  if (!skb_get_tx_timestamp(skb, sk, &ts))
+          return false;
+

io_uring/cmd_net.c static inline int io_uring_cmd_setsockopt(struct socket *sock, · line 78

Quoted 10 lines

io_uring/cmd_net.c +10 -0

+  tskey = serr->ee.ee_data;
+
+  cqe->user_data = 0;
+  cqe->res = tskey;
+  cqe->flags = IORING_CQE_F_MORE;
+  cqe->flags |= (u32)serr->ee.ee_info << IORING_CQE_BUFFER_SHIFT;
+
+  iots = (struct io_timespec *)&cqe[1];
+  iots->tv_sec = ts.tv_sec;
+  iots->tv_nsec = ts.tv_nsec;

skb_get_tx_timestamp loses the information whether this is a software or a hardware timestamp. Is that loss problematic?

If a process only requests one type of timestamp, it will not be.

But when requesting both (SOF_TIMESTAMPING_OPT_TX_SWHW) this per cqe annotation may be necessary.

Quoted 4 lines

skb_has_tx_timestamp() helper has clear priority of software timestamp, if enabled for the socket. Looks like SOF_TIMESTAMPING_OPT_TX_SWHW case won't produce both timestamps with the current implementation. Am I missing something?

The point of that option is to request both SW and HW tx timestamps. Before that option, the SW timestamp was suppressed if a HW timestamp was pending.

Quoted 91 lines · Willem de Bruijn

Quoted 74 lines · Pavel Begunkov

Add a new socket command which returns tx time stamps to the user. It provide an alternative to the existing error queue recvmsg interface. The command works in a polled multishot mode, which means io_uring will poll the socket and keep posting timestamps until the request is cancelled or fails in any other way (e.g. with no space in the CQ). It reuses the net infra and grabs timestamps from the socket's error queue.

The command requires IORING_SETUP_CQE32. All non-final CQEs (marked with IORING_CQE_F_MORE) have cqe->res set to the tskey, and the upper 16 bits of cqe->flags keep tstype (i.e. offset by IORING_CQE_BUFFER_SHIFT). The timevalue is store in the upper part of the extended CQE. The final completion won't have IORING_CQR_F_MORE and will have cqe->res storing 0/error.

Suggested-by Vadim Fedorenko <[email protected]>

Signed-off-by Pavel Begunkov <[email protected]>

---
  include/uapi/linux/io_uring.h |  6 +++
  io_uring/cmd_net.c            | 77 +++++++++++++++++++++++++++++++++++
  2 files changed, 83 insertions(+)

include/uapi/linux/io_uring.h +6 -0

index cfd17e382082..0bc156eb96d4 100644
@@ -960,6 +960,11 @@ struct io_uring_recvmsg_out {
     __u32 flags;
  };
 
+struct io_timespec {
+    __u64           tv_sec;
+    __u64           tv_nsec;
+};
+
  /*
   * Argument for IORING_OP_URING_CMD when file is a socket
   */

@@ -968,6 +973,7 @@ enum io_uring_socket_op {
     SOCKET_URING_OP_SIOCOUTQ,
     SOCKET_URING_OP_GETSOCKOPT,
     SOCKET_URING_OP_SETSOCKOPT,
+    SOCKET_URING_OP_TX_TIMESTAMP,
  };
 
  /* Zero copy receive refill queue entry */

io_uring/cmd_net.c +15 -0

index e99170c7d41a..dae59aea5847 100644
@@ -1,5 +1,6 @@
  #include <asm/ioctls.h>
  #include <linux/io_uring/net.h>
+#include <linux/errqueue.h>
  #include <net/sock.h>
 
  #include "uring_cmd.h"

@@ -51,6 +52,80 @@ static inline int io_uring_cmd_setsockopt(struct socket *sock,
                               optlen);
  }
 
+static bool io_process_timestamp_skb(struct io_uring_cmd *cmd, struct sock *sk,
+                                 struct sk_buff *skb, unsigned issue_flags)
+{
+    struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
+    struct io_uring_cqe cqe[2];
+    struct io_timespec *iots;
+    struct timespec64 ts;
+    u32 tskey;
+
+    BUILD_BUG_ON(sizeof(struct io_uring_cqe) != sizeof(struct io_timespec));
+
+    if (!skb_get_tx_timestamp(skb, sk, &ts))
+            return false;
+

io_uring/cmd_net.c static inline int io_uring_cmd_setsockopt(struct socket *sock, · line 78

Quoted 10 lines

io_uring/cmd_net.c +10 -0

+    tskey = serr->ee.ee_data;
+
+    cqe->user_data = 0;
+    cqe->res = tskey;
+    cqe->flags = IORING_CQE_F_MORE;
+    cqe->flags |= (u32)serr->ee.ee_info << IORING_CQE_BUFFER_SHIFT;
+
+    iots = (struct io_timespec *)&cqe[1];
+    iots->tv_sec = ts.tv_sec;
+    iots->tv_nsec = ts.tv_nsec;

skb_get_tx_timestamp loses the information whether this is a software or a hardware timestamp. Is that loss problematic?

If a process only requests one type of timestamp, it will not be.

Quoted 2 lines

But when requesting both (SOF_TIMESTAMPING_OPT_TX_SWHW) this per cqe annotation may be necessary.

skb_has_tx_timestamp() helper has clear priority of software timestamp, if enabled for the socket. Looks like SOF_TIMESTAMPING_OPT_TX_SWHW case won't produce both timestamps with the current implementation. Am I missing something?

Quoted 32 lines

Quoted 32 lines

Quoted 16 lines

   }

io_uring/cmd_net.c +14 -0

+static bool io_process_timestamp_skb(struct io_uring_cmd *cmd, struct sock *sk,
+                                 struct sk_buff *skb, unsigned issue_flags)
+{
+    struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
+    struct io_uring_cqe cqe[2];
+    struct io_timespec *iots;
+    struct timespec64 ts;
+    u32 tskey;
+
+    BUILD_BUG_ON(sizeof(struct io_uring_cqe) != sizeof(struct io_timespec));
+
+    if (!skb_get_tx_timestamp(skb, sk, &ts))
+            return false;
+

io_uring/cmd_net.c static inline int io_uring_cmd_setsockopt(struct socket *sock, · line 78

Quoted 10 lines

io_uring/cmd_net.c +10 -0

+    tskey = serr->ee.ee_data;
+
+    cqe->user_data = 0;
+    cqe->res = tskey;
+    cqe->flags = IORING_CQE_F_MORE;
+    cqe->flags |= (u32)serr->ee.ee_info << IORING_CQE_BUFFER_SHIFT;
+
+    iots = (struct io_timespec *)&cqe[1];
+    iots->tv_sec = ts.tv_sec;
+    iots->tv_nsec = ts.tv_nsec;

skb_get_tx_timestamp loses the information whether this is a software or a hardware timestamp. Is that loss problematic?

If a process only requests one type of timestamp, it will not be.

Quoted 7 lines

Quoted 2 lines

But when requesting both (SOF_TIMESTAMPING_OPT_TX_SWHW) this per cqe annotation may be necessary.

skb_has_tx_timestamp() helper has clear priority of software timestamp, if enabled for the socket. Looks like SOF_TIMESTAMPING_OPT_TX_SWHW case won't produce both timestamps with the current implementation. Am I missing something?

Sorry that I don't know how iouring works at a high level, so my question could be naive and unrelated to what Willem said.

Is it possible that applications set various tx sw timestamp flags (like SOF_TIMESTAMPING_TX_SCHED, SOF_TIMESTAMPING_TX_SOFTWARE)? If it

might happen, then applications can get lost on which type of tx timestamp it acquires without explicitly specifying in cqe.

On 6/6/25 01:02, Jason Xing wrote:
...>>>> optlen);

Quoted 43 lines

Quoted 32 lines

Quoted 32 lines

Quoted 16 lines

   }

io_uring/cmd_net.c +14 -0

+static bool io_process_timestamp_skb(struct io_uring_cmd *cmd, struct sock *sk,
+                                 struct sk_buff *skb, unsigned issue_flags)
+{
+    struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
+    struct io_uring_cqe cqe[2];
+    struct io_timespec *iots;
+    struct timespec64 ts;
+    u32 tskey;
+
+    BUILD_BUG_ON(sizeof(struct io_uring_cqe) != sizeof(struct io_timespec));
+
+    if (!skb_get_tx_timestamp(skb, sk, &ts))
+            return false;
+

io_uring/cmd_net.c static inline int io_uring_cmd_setsockopt(struct socket *sock, · line 78

Quoted 10 lines

io_uring/cmd_net.c +10 -0

+    tskey = serr->ee.ee_data;
+
+    cqe->user_data = 0;
+    cqe->res = tskey;
+    cqe->flags = IORING_CQE_F_MORE;
+    cqe->flags |= (u32)serr->ee.ee_info << IORING_CQE_BUFFER_SHIFT;
+
+    iots = (struct io_timespec *)&cqe[1];
+    iots->tv_sec = ts.tv_sec;
+    iots->tv_nsec = ts.tv_nsec;

skb_get_tx_timestamp loses the information whether this is a software or a hardware timestamp. Is that loss problematic?

If a process only requests one type of timestamp, it will not be.

Quoted 7 lines

Quoted 2 lines

But when requesting both (SOF_TIMESTAMPING_OPT_TX_SWHW) this per cqe annotation may be necessary.

skb_has_tx_timestamp() helper has clear priority of software timestamp, if enabled for the socket. Looks like SOF_TIMESTAMPING_OPT_TX_SWHW case won't produce both timestamps with the current implementation. Am I missing something?

Sorry that I don't know how iouring works at a high level, so my question could be naive and unrelated to what Willem said.

Quoted 2 lines

Is it possible that applications set various tx sw timestamp flags (like SOF_TIMESTAMPING_TX_SCHED, SOF_TIMESTAMPING_TX_SOFTWARE)? If it

io_uring takes timestamps from the error queue, just like the socket api does it. There should be different skbs in the queue for different SCM_TSTAMP_{SND,SCHED,ACK,*} timestamps, io_uring only passes the type it got in an skb's serr->ee.ee_info to user without changes. Hope it answers it

Quoted 10 lines

Quoted 4 lines

question could be naive and unrelated to what Willem said.

Is it possible that applications set various tx sw timestamp flags (like SOF_TIMESTAMPING_TX_SCHED, SOF_TIMESTAMPING_TX_SOFTWARE)? If it

io_uring takes timestamps from the error queue, just like the socket api does it. There should be different skbs in the queue for different SCM_TSTAMP_{SND,SCHED,ACK,*} timestamps, io_uring only passes the type it got in an skb's serr->ee.ee_info to user without changes. Hope it answers it

Sure, thanks, io_uring has no difference from other regular applications in this case. Then the question that Willem proposed remains because in other applications struct scm_timestamping_internal can be used to distinguish sw and hw timestamps (please see __sock_recv_timestamp() as an example).

Vadim Fedorenko suggested to add an alternative API for receiving tx timestamps through io_uring. The series introduces io_uring socket cmd for fetching tx timestamps, which is a polled multishot request, i.e. internally polling the socket for POLLERR and posts timestamps when they're arrives. For the API description see Patch 5.

It reuses existing timestamp infra and takes them from the socket's error queue. For networking people the important parts are Patch 1, and io_uring_cmd_timestamp() from Patch 5 walking the error queue.

It should be reasonable to take it through the io_uring tree once we have consensus, but let me know if there are any concerns.

Vadim Fedorenko suggested to add an alternative API for receiving tx timestamps through io_uring. The series introduces io_uring socket cmd for fetching tx timestamps, which is a polled multishot request, i.e. internally polling the socket for POLLERR and posts timestamps when they're arrives. For the API description see Patch 5.

It reuses existing timestamp infra and takes them from the socket's error queue. For networking people the important parts are Patch 1, and io_uring_cmd_timestamp() from Patch 5 walking the error queue.

It should be reasonable to take it through the io_uring tree once we have consensus, but let me know if there are any concerns.

Quoted 6 lines · Pavel Begunkov

Vadim Fedorenko suggested to add an alternative API for receiving tx timestamps through io_uring. The series introduces io_uring socket cmd for fetching tx timestamps, which is a polled multishot request, i.e. internally polling the socket for POLLERR and posts timestamps when they're arrives. For the API description see Patch 5.

Quoted 6 lines

It reuses existing timestamp infra and takes them from the socket's error queue. For networking people the important parts are Patch 1, and io_uring_cmd_timestamp() from Patch 5 walking the error queue.

It should be reasonable to take it through the io_uring tree once we have consensus, but let me know if there are any concerns.

Still looks fine to me - is there a liburing test case as well?