Skip to contentSkip to conversation

net: y2038-safe socket timestamps

PATCH Superseded Deepa Dinamani 4 participants 35 messages Nov 24, 2018 – Nov 30, 2018

Subsystems (20)
Networking Network drivers x86 MIPS +16 more subsystems

v1 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

cover net: y2038-safe socket timestamps

The series introduces new socket timestamps that are y2038 safe.

The time data types used for the existing socket timestamp
options: SO_TIMESTAMP, SO_TIMESTAMPNS and SO_TIMESTAMPING are not y2038 safe. The series introduces SO_TIMESTAMP_NEW, SO_TIMESTAMPNS_NEW and SO_TIMESTAMPING_NEW to replace these. These new timestamps can be used on all architectures.

The alternative considered was to extend the sys_setsockopt() by using the flags. We did not receive any strong opinions about either of the approaches. Hence, this was chosen, as glibc folks preferred this.

The series does not deal with updating the internal kernel socket calls like rxrpc to make them y2038 safe. This will be dealt with separately.

Note that the timestamps behavior already does not match the man page specific behavior:
SIOCGSTAMP
This ioctl should only be used if the socket option SO_TIMESTAMP
is not set on the socket. Otherwise, it returns the timestamp of the last packet that was received while SO_TIMESTAMP was not set, or it fails if no such packet has been received, (i.e., ioctl(2) returns -1 with errno set to ENOENT).

The recommendation is to update the man page to remove the above statement.

The overview of the series is as below:
1. Delete asm specific socket.h when possible.
2. Support SO/SCM_TIMESTAMP* options only in userspace.
3. Rename current SO/SCM_TIMESTAMP* to SO/SCM_TIMESTAMP*_OLD.
3. Alter socket options so that SOCK_RCVTSTAMPNS does not rely on SOCK_RCVTSTAMP.
4. Introduce y2038 safe types for socket timestamp.
5. Introduce new y2038 safe socket options SO/SCM_TIMESTAMP*_NEW.

Deepa Dinamani (8):
arch: Use asm-generic/socket.h when possible
sockopt: Rename SO_TIMESTAMP* to SO_TIMESTAMP*_OLD
socket: Disentangle SOCK_RCVTSTAMPNS from SOCK_RCVTSTAMP
arch: sparc: Override struct __kernel_old_timeval
socket: Use old_timeval types for socket timestamps
socket: Add struct sock_timeval
socket: Add SO_TIMESTAMP[NS]_NEW
socket: Add SO_TIMESTAMPING_NEW

 arch/alpha/include/uapi/asm/socket.h      |  35 ++++--
 arch/ia64/include/uapi/asm/Kbuild         |   1 +
 arch/ia64/include/uapi/asm/socket.h       | 120 ------------------
 arch/mips/include/uapi/asm/socket.h       |  34 ++++--
 arch/parisc/include/uapi/asm/socket.h     |  34 ++++--
 arch/s390/include/uapi/asm/Kbuild         |   1 +
 arch/s390/include/uapi/asm/socket.h       | 117 ------------------
 arch/sparc/include/uapi/asm/posix_types.h |  10 ++
 arch/sparc/include/uapi/asm/socket.h      |  36 ++++--
 arch/x86/include/uapi/asm/Kbuild          |   1 +
 arch/x86/include/uapi/asm/socket.h        |   1 -
 arch/xtensa/include/asm/Kbuild            |   1 +
 arch/xtensa/include/uapi/asm/Kbuild       |   1 +
 arch/xtensa/include/uapi/asm/socket.h     | 122 -------------------
 drivers/isdn/mISDN/socket.c               |   2 +-
 include/linux/skbuff.h                    |  24 +++-
 include/linux/socket.h                    |   7 ++
 include/net/sock.h                        |   5 +-
 include/uapi/asm-generic/socket.h         |  35 ++++--
 include/uapi/linux/errqueue.h             |   4 +
 include/uapi/linux/time.h                 |   7 ++
 net/bluetooth/hci_sock.c                  |   4 +-
 net/compat.c                              |  12 +-
 net/core/scm.c                            |  27 ++++
 net/core/sock.c                           | 142 ++++++++++++++--------
 net/ipv4/tcp.c                            |  82 ++++++++-----
 net/rds/af_rds.c                          |  10 +-
 net/rds/recv.c                            |  18 ++-
 net/rxrpc/local_object.c                  |   2 +-
 net/smc/af_smc.c                          |   3 +-
 net/socket.c                              |  68 +++++++----
 net/unix/af_unix.c                        |   4 +-
 32 files changed, 449 insertions(+), 521 deletions(-)
 delete mode 100644 arch/ia64/include/uapi/asm/socket.h
 delete mode 100644 arch/s390/include/uapi/asm/socket.h
 delete mode 100644 arch/x86/include/uapi/asm/socket.h
 delete mode 100644 arch/xtensa/include/uapi/asm/socket.h

base-commit: b124b524bc97868cc2b5656e6ffa21a9b752b7e0

Signature · 44 lines
2.17.1

Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
#1 lore raw

PATCH 1/8 arch: Use asm-generic/socket.h when possible

Many architectures maintain an arch specific copy of the file even though there are no differences with the asm-generic one. Allow these architectures to use the generic one instead.

---
 arch/ia64/include/uapi/asm/Kbuild     |   1 +
 arch/ia64/include/uapi/asm/socket.h   | 120 -------------------------
 arch/s390/include/uapi/asm/Kbuild     |   1 +
 arch/s390/include/uapi/asm/socket.h   | 117 ------------------------
 arch/x86/include/uapi/asm/Kbuild      |   1 +
 arch/x86/include/uapi/asm/socket.h    |   1 -
 arch/xtensa/include/asm/Kbuild        |   1 +
 arch/xtensa/include/uapi/asm/Kbuild   |   1 +
 arch/xtensa/include/uapi/asm/socket.h | 122 --------------------------
 9 files changed, 5 insertions(+), 360 deletions(-)
 delete mode 100644 arch/ia64/include/uapi/asm/socket.h
 delete mode 100644 arch/s390/include/uapi/asm/socket.h
 delete mode 100644 arch/x86/include/uapi/asm/socket.h
 delete mode 100644 arch/xtensa/include/uapi/asm/socket.h
arch/ia64/include/uapi/asm/Kbuild +1 -0
index ccce0ea65e05..37ea5ec1b94d 100644
@@ -9,3 +9,4 @@ generic-y += msgbuf.h
 generic-y += poll.h
 generic-y += sembuf.h
 generic-y += shmbuf.h
+generic-y += socket.h
arch/ia64/include/uapi/asm/socket.h deleted +0 -120

120 lines not on this page · raw message

arch/s390/include/uapi/asm/Kbuild +1 -0
index dc38a90cf091..15bb61228b74 100644
@@ -15,6 +15,7 @@ generic-y += poll.h
 generic-y += resource.h
 generic-y += sembuf.h
 generic-y += shmbuf.h
+generic-y += socket.h
 generic-y += sockios.h
 generic-y += swab.h
 generic-y += termbits.h
arch/s390/include/uapi/asm/socket.h deleted +0 -117

117 lines not on this page · raw message

arch/x86/include/uapi/asm/Kbuild +1 -0
index 322681622d1e..a400e71a13ce 100644
@@ -6,3 +6,4 @@ generated-y += unistd_32.h
 generated-y += unistd_64.h
 generated-y += unistd_x32.h
 generic-y += poll.h
+generic-y += socket.h
arch/x86/include/uapi/asm/socket.h deleted +0 -1
deleted file mode 100644
index 6b71384b9d8b..000000000000
@@ -1 +0,0 @@
-#include <asm-generic/socket.h>
arch/xtensa/include/asm/Kbuild +1 -0
index e255683cd520..809f39ce08c0 100644
@@ -25,6 +25,7 @@ generic-y += percpu.h
 generic-y += preempt.h
 generic-y += rwsem.h
 generic-y += sections.h
+generic-y += socket.h
 generic-y += topology.h
 generic-y += trace_clock.h
 generic-y += vga.h
arch/xtensa/include/uapi/asm/Kbuild +1 -0
index f95cad300369..fc2680dace55 100644
@@ -10,5 +10,6 @@ generic-y += ioctl.h
 generic-y += kvm_para.h
 generic-y += resource.h
 generic-y += siginfo.h
+generic-y += socket.h
 generic-y += statfs.h
 generic-y += termios.h
arch/xtensa/include/uapi/asm/socket.h deleted +0 -122

122 lines not on this page · raw message

Signature · 1 line
2.17.1
#2 lore raw

PATCH 2/8 sockopt: Rename SO_TIMESTAMP* to SO_TIMESTAMP*_OLD

In reply to Deepa Dinamani

SO_TIMESTAMP, SO_TIMESTAMPNS and SO_TIMESTAMPING options, the way they are currently defined, are not y2038 safe. Subsequent patches in the series add new y2038 safe versions of these options which provide 64 bit timestamps on all architectures uniformly.
Hence, rename existing options with OLD tag suffixes.

Also note that kernel will not use the untagged SO_TIMESTAMP* and SCM_TIMESTAMP* options internally anymore.

---
 arch/alpha/include/uapi/asm/socket.h  | 23 ++++++++++++++++-------
 arch/mips/include/uapi/asm/socket.h   | 23 ++++++++++++++++-------
 arch/parisc/include/uapi/asm/socket.h | 23 ++++++++++++++++-------
 arch/sparc/include/uapi/asm/socket.h  | 24 ++++++++++++++++--------
 include/uapi/asm-generic/socket.h     | 23 ++++++++++++++++-------
 net/compat.c                          |  6 +++---
 net/core/sock.c                       | 16 ++++++++--------
 net/ipv4/tcp.c                        |  6 +++---
 net/rds/af_rds.c                      |  2 +-
 net/rds/recv.c                        |  2 +-
 net/rxrpc/local_object.c              |  2 +-
 net/socket.c                          |  8 ++++----
 12 files changed, 101 insertions(+), 57 deletions(-)
arch/alpha/include/uapi/asm/socket.h +16 -7
index 065fb372e355..00e45c80e574 100644
@@ -51,13 +51,9 @@
 #define SO_GET_FILTER		SO_ATTACH_FILTER
 
 #define SO_PEERNAME		28
-#define SO_TIMESTAMP		29
-#define SCM_TIMESTAMP		SO_TIMESTAMP
 
 #define SO_PEERSEC		30
 #define SO_PASSSEC		34
-#define SO_TIMESTAMPNS		35
-#define SCM_TIMESTAMPNS		SO_TIMESTAMPNS
 
 /* Security levels - as per NRL IPv6 - don't actually do anything */
 #define SO_SECURITY_AUTHENTICATION		19
@@ -66,9 +62,6 @@
 
 #define SO_MARK			36
 
-#define SO_TIMESTAMPING		37
-#define SCM_TIMESTAMPING	SO_TIMESTAMPING
-
 #define SO_RXQ_OVFL             40
 
 #define SO_WIFI_STATUS		41
@@ -115,4 +108,20 @@
 #define SO_TXTIME		61
 #define SCM_TXTIME		SO_TXTIME
 
+#define SO_TIMESTAMP_OLD         29
+#define SO_TIMESTAMPNS_OLD       35
+#define SO_TIMESTAMPING_OLD      37
+
+#if !defined(__KERNEL__)
+
+#define SO_TIMESTAMP           SO_TIMESTAMP_OLD
+#define SO_TIMESTAMPNS         SO_TIMESTAMPNS_OLD
+#define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
+
+#define SCM_TIMESTAMP          SO_TIMESTAMP
+#define SCM_TIMESTAMPNS        SO_TIMESTAMPNS
+#define SCM_TIMESTAMPING       SO_TIMESTAMPING
+
+#endif
+
 #endif /* _UAPI_ASM_SOCKET_H */
arch/mips/include/uapi/asm/socket.h +16 -7
index 71370fb3ceef..b9553f770346 100644
@@ -65,21 +65,14 @@
 #define SO_GET_FILTER		SO_ATTACH_FILTER
 
 #define SO_PEERNAME		28
-#define SO_TIMESTAMP		29
-#define SCM_TIMESTAMP		SO_TIMESTAMP
 
 #define SO_PEERSEC		30
 #define SO_SNDBUFFORCE		31
 #define SO_RCVBUFFORCE		33
 #define SO_PASSSEC		34
-#define SO_TIMESTAMPNS		35
-#define SCM_TIMESTAMPNS		SO_TIMESTAMPNS
 
 #define SO_MARK			36
 
-#define SO_TIMESTAMPING		37
-#define SCM_TIMESTAMPING	SO_TIMESTAMPING
-
 #define SO_RXQ_OVFL		40
 
 #define SO_WIFI_STATUS		41
@@ -126,4 +119,20 @@
 #define SO_TXTIME		61
 #define SCM_TXTIME		SO_TXTIME
 
+#define SO_TIMESTAMP_OLD         29
+#define SO_TIMESTAMPNS_OLD       35
+#define SO_TIMESTAMPING_OLD      37
+
+#if !defined(__KERNEL__)
+
+#define SO_TIMESTAMP           SO_TIMESTAMP_OLD
+#define SO_TIMESTAMPNS         SO_TIMESTAMPNS_OLD
+#define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
+
+#define SCM_TIMESTAMP          SO_TIMESTAMP
+#define SCM_TIMESTAMPNS        SO_TIMESTAMPNS
+#define SCM_TIMESTAMPING       SO_TIMESTAMPING
+
+#endif
+
 #endif /* _UAPI_ASM_SOCKET_H */
arch/parisc/include/uapi/asm/socket.h +16 -7
index 061b9cf2a779..37cdfe64bb27 100644
@@ -34,10 +34,6 @@
 #define SO_BSDCOMPAT	0x400e
 #define SO_PASSCRED	0x4010
 #define SO_PEERCRED	0x4011
-#define SO_TIMESTAMP	0x4012
-#define SCM_TIMESTAMP	SO_TIMESTAMP
-#define SO_TIMESTAMPNS	0x4013
-#define SCM_TIMESTAMPNS	SO_TIMESTAMPNS
 
 /* Security levels - as per NRL IPv6 - don't actually do anything */
 #define SO_SECURITY_AUTHENTICATION		0x4016
@@ -58,9 +54,6 @@
 
 #define SO_MARK			0x401f
 
-#define SO_TIMESTAMPING		0x4020
-#define SCM_TIMESTAMPING	SO_TIMESTAMPING
-
 #define SO_RXQ_OVFL             0x4021
 
 #define SO_WIFI_STATUS		0x4022
@@ -107,4 +100,20 @@
 #define SO_TXTIME		0x4036
 #define SCM_TXTIME		SO_TXTIME
 
+#define SO_TIMESTAMP_OLD         0x4012
+#define SO_TIMESTAMPNS_OLD       0x4013
+#define SO_TIMESTAMPING_OLD      0x4020
+
+#if !defined(__KERNEL__)
+
+#define SO_TIMESTAMP           SO_TIMESTAMP_OLD
+#define SO_TIMESTAMPNS         SO_TIMESTAMPNS_OLD
+#define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
+
+#define SCM_TIMESTAMP          SO_TIMESTAMP
+#define SCM_TIMESTAMPNS        SO_TIMESTAMPNS
+#define SCM_TIMESTAMPING       SO_TIMESTAMPING
+
+#endif
+
 #endif /* _UAPI_ASM_SOCKET_H */
arch/sparc/include/uapi/asm/socket.h +16 -8
index 7ea35e5601b6..ca573641fc6c 100644
@@ -33,7 +33,6 @@
 #define SO_PROTOCOL	0x1028
 #define SO_DOMAIN	0x1029
 
-
 /* Linux specific, keep the same. */
 #define SO_NO_CHECK	0x000b
 #define SO_PRIORITY	0x000c
@@ -45,19 +44,12 @@
 #define SO_GET_FILTER		SO_ATTACH_FILTER
 
 #define SO_PEERNAME		0x001c
-#define SO_TIMESTAMP		0x001d
-#define SCM_TIMESTAMP		SO_TIMESTAMP
 
 #define SO_PEERSEC		0x001e
 #define SO_PASSSEC		0x001f
-#define SO_TIMESTAMPNS		0x0021
-#define SCM_TIMESTAMPNS		SO_TIMESTAMPNS
 
 #define SO_MARK			0x0022
 
-#define SO_TIMESTAMPING		0x0023
-#define SCM_TIMESTAMPING	SO_TIMESTAMPING
-
 #define SO_RXQ_OVFL             0x0024
 
 #define SO_WIFI_STATUS		0x0025
@@ -109,4 +101,20 @@
 #define SO_SECURITY_ENCRYPTION_TRANSPORT	0x5002
 #define SO_SECURITY_ENCRYPTION_NETWORK		0x5004
 
+#define SO_TIMESTAMP_OLD         0x001d
+#define SO_TIMESTAMPNS_OLD       0x0021
+#define SO_TIMESTAMPING_OLD      0x0023
+
+#if !defined(__KERNEL__)
+
+#define SO_TIMESTAMP           SO_TIMESTAMP_OLD
+#define SO_TIMESTAMPNS         SO_TIMESTAMPNS_OLD
+#define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
+
+#define SCM_TIMESTAMP          SO_TIMESTAMP
+#define SCM_TIMESTAMPNS        SO_TIMESTAMPNS
+#define SCM_TIMESTAMPING       SO_TIMESTAMPING
+
+#endif
+
 #endif /* _ASM_SOCKET_H */
include/uapi/asm-generic/socket.h +16 -7
index a12692e5f7a8..dc704e41203d 100644
@@ -46,21 +46,14 @@
 #define SO_GET_FILTER		SO_ATTACH_FILTER
 
 #define SO_PEERNAME		28
-#define SO_TIMESTAMP		29
-#define SCM_TIMESTAMP		SO_TIMESTAMP
 
 #define SO_ACCEPTCONN		30
 
 #define SO_PEERSEC		31
 #define SO_PASSSEC		34
-#define SO_TIMESTAMPNS		35
-#define SCM_TIMESTAMPNS		SO_TIMESTAMPNS
 
 #define SO_MARK			36
 
-#define SO_TIMESTAMPING		37
-#define SCM_TIMESTAMPING	SO_TIMESTAMPING
-
 #define SO_PROTOCOL		38
 #define SO_DOMAIN		39
 
@@ -110,4 +103,20 @@
 #define SO_TXTIME		61
 #define SCM_TXTIME		SO_TXTIME
 
+#define SO_TIMESTAMP_OLD         29
+#define SO_TIMESTAMPNS_OLD       35
+#define SO_TIMESTAMPING_OLD      37
+
+#if !defined(__KERNEL__)
+
+#define SO_TIMESTAMP           SO_TIMESTAMP_OLD
+#define SO_TIMESTAMPNS         SO_TIMESTAMPNS_OLD
+#define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
+
+#define SCM_TIMESTAMP          SO_TIMESTAMP
+#define SCM_TIMESTAMPNS        SO_TIMESTAMPNS
+#define SCM_TIMESTAMPING       SO_TIMESTAMPING
+
+#endif
+
 #endif /* __ASM_GENERIC_SOCKET_H */
net/compat.c +3 -3
index 47a614b370cd..720ab07276b0 100644
@@ -219,7 +219,7 @@ int put_cmsg_compat(struct msghdr *kmsg, int level, int type, int len, void *dat
 	}
 
 	if (!COMPAT_USE_64BIT_TIME) {
-		if (level == SOL_SOCKET && type == SCM_TIMESTAMP) {
+		if (level == SOL_SOCKET && type == SO_TIMESTAMP_OLD) {
 			struct timeval *tv = (struct timeval *)data;
 			ctv.tv_sec = tv->tv_sec;
 			ctv.tv_usec = tv->tv_usec;
@@ -227,8 +227,8 @@ int put_cmsg_compat(struct msghdr *kmsg, int level, int type, int len, void *dat
 			len = sizeof(ctv);
 		}
 		if (level == SOL_SOCKET &&
-		    (type == SCM_TIMESTAMPNS || type == SCM_TIMESTAMPING)) {
-			int count = type == SCM_TIMESTAMPNS ? 1 : 3;
+		    (type == SO_TIMESTAMPNS_OLD || type == SO_TIMESTAMPING_OLD)) {
+			int count = type == SO_TIMESTAMPNS_OLD ? 1 : 3;
 			int i;
 			struct timespec *ts = (struct timespec *)data;
 			for (i = 0; i < count; i++) {
net/core/sock.c +8 -8
index 6d7e189e3cd9..cf990db9b2a0 100644
@@ -814,10 +814,10 @@ int sock_setsockopt(struct socket *sock, int level, int optname,
 			clear_bit(SOCK_PASSCRED, &sock->flags);
 		break;
 
-	case SO_TIMESTAMP:
-	case SO_TIMESTAMPNS:
+	case SO_TIMESTAMP_OLD:
+	case SO_TIMESTAMPNS_OLD:
 		if (valbool)  {
-			if (optname == SO_TIMESTAMP)
+			if (optname == SO_TIMESTAMP_OLD)
 				sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
 			else
 				sock_set_flag(sk, SOCK_RCVTSTAMPNS);
@@ -829,7 +829,7 @@ int sock_setsockopt(struct socket *sock, int level, int optname,
 		}
 		break;
 
-	case SO_TIMESTAMPING:
+	case SO_TIMESTAMPING_OLD:
 		if (val & ~SOF_TIMESTAMPING_MASK) {
 			ret = -EINVAL;
 			break;
@@ -1182,16 +1182,16 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
 		sock_warn_obsolete_bsdism("getsockopt");
 		break;
 
-	case SO_TIMESTAMP:
+	case SO_TIMESTAMP_OLD:
 		v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
 				!sock_flag(sk, SOCK_RCVTSTAMPNS);
 		break;
 
-	case SO_TIMESTAMPNS:
+	case SO_TIMESTAMPNS_OLD:
 		v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
 		break;
 
-	case SO_TIMESTAMPING:
+	case SO_TIMESTAMPING_OLD:
 		v.val = sk->sk_tsflags;
 		break;
 
@@ -2118,7 +2118,7 @@ int __sock_cmsg_send(struct sock *sk, struct msghdr *msg, struct cmsghdr *cmsg,
 			return -EINVAL;
 		sockc->mark = *(u32 *)CMSG_DATA(cmsg);
 		break;
-	case SO_TIMESTAMPING:
+	case SO_TIMESTAMPING_OLD:
 		if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
 			return -EINVAL;
 
net/ipv4/tcp.c +3 -3
index 252048776dbb..496848ab0269 100644
@@ -1870,13 +1870,13 @@ static void tcp_recv_timestamp(struct msghdr *msg, const struct sock *sk,
 	if (tss->ts[0].tv_sec || tss->ts[0].tv_nsec) {
 		if (sock_flag(sk, SOCK_RCVTSTAMP)) {
 			if (sock_flag(sk, SOCK_RCVTSTAMPNS)) {
-				put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS,
+				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
 					 sizeof(tss->ts[0]), &tss->ts[0]);
 			} else {
 				tv.tv_sec = tss->ts[0].tv_sec;
 				tv.tv_usec = tss->ts[0].tv_nsec / 1000;
 
-				put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,
+				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
 					 sizeof(tv), &tv);
 			}
 		}
@@ -1896,7 +1896,7 @@ static void tcp_recv_timestamp(struct msghdr *msg, const struct sock *sk,
 
 	if (has_timestamping) {
 		tss->ts[1] = (struct timespec) {0};
-		put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING,
+		put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPING_OLD,
 			 sizeof(*tss), tss);
 	}
 }
net/rds/af_rds.c +1 -1
index 65387e1e6964..eeb4639adbe5 100644
@@ -430,7 +430,7 @@ static int rds_setsockopt(struct socket *sock, int level, int optname,
 		ret = rds_set_transport(rs, optval, optlen);
 		release_sock(sock->sk);
 		break;
-	case SO_TIMESTAMP:
+	case SO_TIMESTAMP_OLD:
 		lock_sock(sock->sk);
 		ret = rds_enable_recvtstamp(sock->sk, optval, optlen);
 		release_sock(sock->sk);
net/rds/recv.c +1 -1
index 727639dac8a7..04e30d63a159 100644
@@ -550,7 +550,7 @@ static int rds_cmsg_recv(struct rds_incoming *inc, struct msghdr *msg,
 	if ((inc->i_rx_tstamp != 0) &&
 	    sock_flag(rds_rs_to_sk(rs), SOCK_RCVTSTAMP)) {
 		struct timeval tv = ktime_to_timeval(inc->i_rx_tstamp);
-		ret = put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,
+		ret = put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
 			       sizeof(tv), &tv);
 		if (ret)
 			goto out;
net/rxrpc/local_object.c +1 -1
index 0906e51d3cfb..15cf42d5b53a 100644
@@ -202,7 +202,7 @@ static int rxrpc_open_socket(struct rxrpc_local *local, struct net *net)
 
 		/* We want receive timestamps. */
 		opt = 1;
-		ret = kernel_setsockopt(local->socket, SOL_SOCKET, SO_TIMESTAMPNS,
+		ret = kernel_setsockopt(local->socket, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
 					(char *)&opt, sizeof(opt));
 		if (ret < 0) {
 			_debug("setsockopt failed");
net/socket.c +4 -4
index f1ede2a64985..dfc5742ccfbb 100644
@@ -670,7 +670,7 @@ static bool skb_is_err_queue(const struct sk_buff *skb)
  * before the software timestamp is received, a hardware TX timestamp may be
  * returned only if there is no software TX timestamp. Ignore false software
  * timestamps, which may be made in the __sock_recv_timestamp() call when the
- * option SO_TIMESTAMP(NS) is enabled on the socket, even when the skb has a
+ * option SO_TIMESTAMP_OLD(NS) is enabled on the socket, even when the skb has a
  * hardware timestamp.
  */
 static bool skb_is_swtx_tstamp(const struct sk_buff *skb, int false_tstamp)
@@ -722,12 +722,12 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
 		if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
 			struct timeval tv;
 			skb_get_timestamp(skb, &tv);
-			put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,
+			put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
 				 sizeof(tv), &tv);
 		} else {
 			struct timespec ts;
 			skb_get_timestampns(skb, &ts);
-			put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS,
+			put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
 				 sizeof(ts), &ts);
 		}
 	}
@@ -747,7 +747,7 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
 	}
 	if (!empty) {
 		put_cmsg(msg, SOL_SOCKET,
-			 SCM_TIMESTAMPING, sizeof(tss), &tss);
+			 SO_TIMESTAMPING_OLD, sizeof(tss), &tss);
 
 		if (skb_is_err_queue(skb) && skb->len &&
 		    SKB_EXT_ERR(skb)->opt_stats)
Signature · 1 line
2.17.1
#3 lore raw

Re: [PATCH 2/8] sockopt: Rename SO_TIMESTAMP* to SO_TIMESTAMP*_OLD

Quoted 7 lines · Deepa Dinamani

SO_TIMESTAMP, SO_TIMESTAMPNS and SO_TIMESTAMPING options, the way they are currently defined, are not y2038 safe. Subsequent patches in the series add new y2038 safe versions of these options which provide 64 bit timestamps on all architectures uniformly.
Hence, rename existing options with OLD tag suffixes.

Why do the existing interfaces have to be renamed when new interfaces are added?

#4 lore raw

Re: [PATCH 2/8] sockopt: Rename SO_TIMESTAMP* to SO_TIMESTAMP*_OLD

Quoted 11 lines · Willem de Bruijn
Quoted 7 lines · Deepa Dinamani

SO_TIMESTAMP, SO_TIMESTAMPNS and SO_TIMESTAMPING options, the way they are currently defined, are not y2038 safe. Subsequent patches in the series add new y2038 safe versions of these options which provide 64 bit timestamps on all architectures uniformly.
Hence, rename existing options with OLD tag suffixes.

Why do the existing interfaces have to be renamed when new interfaces are added?

Existing options need to be renamed because of the macro below:

#define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? \
SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)

SO_TIMESTAMP is now dependent on size of time_t because of the libc flag.

-Deepa

#5 lore raw

Re: [PATCH 2/8] sockopt: Rename SO_TIMESTAMP* to SO_TIMESTAMP*_OLD

Quoted 13 lines · Deepa Dinamani
Quoted 10 lines · Willem de Bruijn
Quoted 7 lines · Deepa Dinamani

SO_TIMESTAMP, SO_TIMESTAMPNS and SO_TIMESTAMPING options, the way they are currently defined, are not y2038 safe. Subsequent patches in the series add new y2038 safe versions of these options which provide 64 bit timestamps on all architectures uniformly.
Hence, rename existing options with OLD tag suffixes.

Quoted 8 lines
Quoted 1 line

Why do the existing interfaces have to be renamed when new interfaces are added?

Existing options need to be renamed because of the macro below:

#define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? \
SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)

SO_TIMESTAMP is now dependent on size of time_t because of the libc flag.

Yes, I understand the mechanism based on libc's definition of time_t after Arnd's explanation. Please do capture that in the commit message, for possible future readers who stumble upon the code with git blame.

#6 lore raw

PATCH 3/8 socket: Disentangle SOCK_RCVTSTAMPNS from SOCK_RCVTSTAMP

In reply to Deepa Dinamani

SOCK_RCVTSTAMPNS is never set alone. SOCK_RCVTSTAMP is always set along with SOCK_RCVTSTAMPNS. This leads to checking for two flag states whenever we need to check for SOCK_RCVTSTAMPS.

Also SOCK_RCVTSTAMPS was the only flag that needed to be checked in order to verify if either of the two flags are set. But, the two features are not actually dependent on each other. This artificial dependency creates more confusion.
The change does away with this logic as well.

Note that RDS seems to be supporting only SO_TIMESTAMP at SOL_RDS level. And, it uses the same SOCK_RCVTSTAMP to track this. Hence, the updates to rds_incoming->i_rx_tstamp only track SOCK_RCVTSTAMP and not SOCK_RCVTSTAMPNS.

---
 include/net/sock.h |  4 +++-
 net/core/sock.c    | 37 ++++++++++++++++++++++++-------------
 net/ipv4/tcp.c     | 20 +++++++++-----------
 net/socket.c       |  3 ++-
 net/unix/af_unix.c |  4 ++--
 5 files changed, 40 insertions(+), 28 deletions(-)
include/net/sock.h +3 -1
index f665d74ae509..8143c4c1a49d 100644
@@ -2305,6 +2305,7 @@ sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
 	 * - hardware time stamps available and wanted
 	 */
 	if (sock_flag(sk, SOCK_RCVTSTAMP) ||
+		sock_flag(sk, SOCK_RCVTSTAMPNS) ||
 	    (sk->sk_tsflags & SOF_TIMESTAMPING_RX_SOFTWARE) ||
 	    (kt && sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) ||
 	    (hwtstamps->hwtstamp &&
@@ -2325,7 +2326,8 @@ static inline void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
 					  struct sk_buff *skb)
 {
 #define FLAGS_TS_OR_DROPS ((1UL << SOCK_RXQ_OVFL)			| \
-			   (1UL << SOCK_RCVTSTAMP))
+			   (1UL << SOCK_RCVTSTAMP)			| \
+			   (1UL << SOCK_RCVTSTAMPNS))
 #define TSFLAGS_ANY	  (SOF_TIMESTAMPING_SOFTWARE			| \
 			   SOF_TIMESTAMPING_RAW_HARDWARE)
 
net/core/sock.c +24 -13
index cf990db9b2a0..e60036618205 100644
@@ -647,6 +647,28 @@ bool sk_mc_loop(struct sock *sk)
 }
 EXPORT_SYMBOL(sk_mc_loop);
 
+static void setsockopt_timestamp(struct sock *sk, int type, int val)
+{
+	if (!val) {
+		sock_reset_flag(sk, SOCK_RCVTSTAMP);
+		sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
+		return;
+	}
+
+	switch (type) {
+	case SO_TIMESTAMP_OLD:
+		sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
+		sock_set_flag(sk, SOCK_RCVTSTAMP);
+		break;
+	case SO_TIMESTAMPNS_OLD:
+		sock_reset_flag(sk, SOCK_RCVTSTAMP);
+		sock_set_flag(sk, SOCK_RCVTSTAMPNS);
+		break;
+	}
+
+	sock_enable_timestamp(sk, SOCK_TIMESTAMP);
+}
+
 /*
  *	This is meant for all protocols to use and covers goings on
  *	at the socket level. Everything here is generic.
@@ -816,17 +838,7 @@ int sock_setsockopt(struct socket *sock, int level, int optname,
 
 	case SO_TIMESTAMP_OLD:
 	case SO_TIMESTAMPNS_OLD:
-		if (valbool)  {
-			if (optname == SO_TIMESTAMP_OLD)
-				sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
-			else
-				sock_set_flag(sk, SOCK_RCVTSTAMPNS);
-			sock_set_flag(sk, SOCK_RCVTSTAMP);
-			sock_enable_timestamp(sk, SOCK_TIMESTAMP);
-		} else {
-			sock_reset_flag(sk, SOCK_RCVTSTAMP);
-			sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
-		}
+		setsockopt_timestamp(sk, optname, valbool);
 		break;
 
 	case SO_TIMESTAMPING_OLD:
@@ -1183,8 +1195,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
 		break;
 
 	case SO_TIMESTAMP_OLD:
-		v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
-				!sock_flag(sk, SOCK_RCVTSTAMPNS);
+		v.val = sock_flag(sk, SOCK_RCVTSTAMP);
 		break;
 
 	case SO_TIMESTAMPNS_OLD:
net/ipv4/tcp.c +9 -11
index 496848ab0269..d6eb5f542fcf 100644
@@ -1868,17 +1868,15 @@ static void tcp_recv_timestamp(struct msghdr *msg, const struct sock *sk,
 	bool has_timestamping = false;
 
 	if (tss->ts[0].tv_sec || tss->ts[0].tv_nsec) {
-		if (sock_flag(sk, SOCK_RCVTSTAMP)) {
-			if (sock_flag(sk, SOCK_RCVTSTAMPNS)) {
-				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
-					 sizeof(tss->ts[0]), &tss->ts[0]);
-			} else {
-				tv.tv_sec = tss->ts[0].tv_sec;
-				tv.tv_usec = tss->ts[0].tv_nsec / 1000;
-
-				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
-					 sizeof(tv), &tv);
-			}
+		if (sock_flag(sk, SOCK_RCVTSTAMPNS)) {
+			put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
+				 sizeof(tss->ts[0]), &tss->ts[0]);
+		} else if (sock_flag(sk, SOCK_RCVTSTAMP)) {
+			tv.tv_sec = tss->ts[0].tv_sec;
+			tv.tv_usec = tss->ts[0].tv_nsec / 1000;
+
+			put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
+				 sizeof(tv), &tv);
 		}
 
 		if (sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE)
net/socket.c +2 -1
index dfc5742ccfbb..c7455349a3c1 100644
@@ -701,11 +701,12 @@ static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb)
 
 /*
  * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
+ * or sock_flag(sk, SOCK_RCVTSTAMPNS)
  */
 void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
 	struct sk_buff *skb)
 {
-	int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);
+	int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP) || sock_flag(sk, SOCK_RCVTSTAMPNS);
 	struct scm_timestamping tss;
 	int empty = 1, false_tstamp = 0;
 	struct skb_shared_hwtstamps *shhwtstamps =
net/unix/af_unix.c +2 -2
index 74d1eed7cbd4..531efd0ddeb1 100644
@@ -1798,7 +1798,7 @@ static int unix_dgram_sendmsg(struct socket *sock, struct msghdr *msg,
 	if (unlikely(sk_locked))
 		unix_state_unlock(sk);
 
-	if (sock_flag(other, SOCK_RCVTSTAMP))
+	if (sock_flag(other, SOCK_RCVTSTAMP) || sock_flag(other, SOCK_RCVTSTAMPNS))
 		__net_timestamp(skb);
 	maybe_add_creds(skb, sock, other);
 	skb_queue_tail(&other->sk_receive_queue, skb);
@@ -2141,7 +2141,7 @@ static int unix_dgram_recvmsg(struct socket *sock, struct msghdr *msg,
 	if (err)
 		goto out_free;
 
-	if (sock_flag(sk, SOCK_RCVTSTAMP))
+	if (sock_flag(sk, SOCK_RCVTSTAMP) || sock_flag(sk, SOCK_RCVTSTAMPNS))
 		__sock_recv_timestamp(msg, sk, skb);
 
 	memset(&scm, 0, sizeof(scm));
Signature · 1 line
2.17.1
#7 lore raw

Re: [PATCH 3/8] socket: Disentangle SOCK_RCVTSTAMPNS from SOCK_RCVTSTAMP

Quoted 11 lines · Deepa Dinamani

SOCK_RCVTSTAMPNS is never set alone. SOCK_RCVTSTAMP is always set along with SOCK_RCVTSTAMPNS. This leads to checking for two flag states whenever we need to check for SOCK_RCVTSTAMPS.

Also SOCK_RCVTSTAMPS was the only flag that needed to be checked in order to verify if either of the two flags are set. But, the two features are not actually dependent on each other. This artificial dependency creates more confusion.

This is done so that the hot path only has to check one flag in the common case where no timestamp is requested.

#8 lore raw

Re: [PATCH 3/8] socket: Disentangle SOCK_RCVTSTAMPNS from SOCK_RCVTSTAMP

Quoted 8 lines · Willem de Bruijn
Quoted 6 lines · Deepa Dinamani

SOCK_RCVTSTAMPNS is never set alone. SOCK_RCVTSTAMP is always set along with SOCK_RCVTSTAMPNS. This leads to checking for two flag states whenever we need to check for SOCK_RCVTSTAMPS.

Quoted 8 lines
Quoted 5 lines

Also SOCK_RCVTSTAMPS was the only flag that needed to be checked in order to verify if either of the two flags are set. But, the two features are not actually dependent on each other. This artificial dependency creates more confusion.

This is done so that the hot path only has to check one flag in the common case where no timestamp is requested.

In that case we could just check it this way:

if (newsk->sk_flags & SK_FLAGS_TIMESTAMP)

We are already doing this in many places.

I do not see any other reason for the two timestamps to be intertwined.

Do you have any objections to using this patch and replacing the checks as above?

-Deepa

#9 lore raw

Re: [PATCH 3/8] socket: Disentangle SOCK_RCVTSTAMPNS from SOCK_RCVTSTAMP

Quoted 22 lines · Deepa Dinamani
Quoted 8 lines · Willem de Bruijn
Quoted 6 lines · Deepa Dinamani

SOCK_RCVTSTAMPNS is never set alone. SOCK_RCVTSTAMP is always set along with SOCK_RCVTSTAMPNS. This leads to checking for two flag states whenever we need to check for SOCK_RCVTSTAMPS.

Quoted 8 lines
Quoted 5 lines

Also SOCK_RCVTSTAMPS was the only flag that needed to be checked in order to verify if either of the two flags are set. But, the two features are not actually dependent on each other. This artificial dependency creates more confusion.

This is done so that the hot path only has to check one flag in the common case where no timestamp is requested.

In that case we could just check it this way:

Quoted 8 lines

if (newsk->sk_flags & SK_FLAGS_TIMESTAMP)

We are already doing this in many places.

I do not see any other reason for the two timestamps to be intertwined.

Do you have any objections to using this patch and replacing the checks as above?

The existing logic is as is for a reason. There is no need to change it to satisfy the main purpose of your patchset?

It is structured as one bit to test whether a timestamp is requested and another to select among two variants usec/nsec. Just add another layer of branching between new/old in cases where this distinction is needed.

Please avoid code churn unless needed.

maintainer
#10 lore raw

Re: [PATCH 3/8] socket: Disentangle SOCK_RCVTSTAMPNS from SOCK_RCVTSTAMP

From: Willem de Bruijn <[email protected]>
Date: Sun, 25 Nov 2018 09:18:55 -0500

Quoted 9 lines

The existing logic is as is for a reason. There is no need to change it to satisfy the main purpose of your patchset?

It is structured as one bit to test whether a timestamp is requested and another to select among two variants usec/nsec. Just add another layer of branching between new/old in cases where this distinction is needed.

Please avoid code churn unless needed.

+1

#11 lore raw

Re: [PATCH 3/8] socket: Disentangle SOCK_RCVTSTAMPNS from SOCK_RCVTSTAMP

Quoted 7 lines · David Miller

From: Willem de Bruijn <[email protected]>
Date: Sun, 25 Nov 2018 09:18:55 -0500

Quoted 3 lines

The existing logic is as is for a reason. There is no need to change it to satisfy the main purpose of your patchset?

Quoted 8 lines
Quoted 6 lines

It is structured as one bit to test whether a timestamp is requested and another to select among two variants usec/nsec. Just add another layer of branching between new/old in cases where this distinction is needed.

Please avoid code churn unless needed.

+1

This patch makes it easier to add logic for 2 new socket time options. But, if you prefer for all of the options to depend on SOCK_RCVTSTAMP then I will drop it.

-Deepa

#12 lore raw

Re: [PATCH 3/8] socket: Disentangle SOCK_RCVTSTAMPNS from SOCK_RCVTSTAMP

Quoted 14 lines · Deepa Dinamani
Quoted 12 lines · David Miller

From: Willem de Bruijn <[email protected]>
Date: Sun, 25 Nov 2018 09:18:55 -0500

Quoted 8 lines

The existing logic is as is for a reason. There is no need to change it to satisfy the main purpose of your patchset?

It is structured as one bit to test whether a timestamp is requested and another to select among two variants usec/nsec. Just add another layer of branching between new/old in cases where this distinction is needed.

Quoted 7 lines
Quoted 3 lines
Quoted 1 line

Please avoid code churn unless needed.

+1

This patch makes it easier to add logic for 2 new socket time options. But, if you prefer for all of the options to depend on SOCK_RCVTSTAMP then I will drop it.

Yes, please keep as is.

I don't see how this change is needed to significantly simplify the main patchset, and an unnecessary change can cause an unforeseen regression (as was the case with doubling the tests in the hot path).

The current approach has one branch in the hot path where timestamps are disabled and then selects from two variants where it is enabled:

    if (rcvtstamp) {
      if (rcvtstamp_ns)
        ..
      else
        ..
    }

Both of these need to be split into new and old variants. The way to achieve that with minimal code perturbation is

    if (rcvtstamp) {
  +    if (sk_timestamping_new)
  +     return __sock_recv_timestamp_new(..)
  +
      if (rcvtstamp_ns)
        ..
      else
        ..

}

Or alternatively add a check for new in each of the inner branches. In any case, please be consistent between sock_recv_sw_timestamp and tcp_recv_sw_timestamp. The current patchset alternates them.

#13 lore raw

PATCH 4/8 arch: sparc: Override struct __kernel_old_timeval

In reply to Deepa Dinamani

struct __kernel_old_timeval is supposed to have the same layout as struct timeval. But, it was inadvarently missed that __kernel_suseconds has a different definition for sparc64.
Provide an asm-specific override that fixes it.

---
 arch/sparc/include/uapi/asm/posix_types.h | 10 ++++++++++
 include/uapi/linux/time.h                 |  2 ++
 2 files changed, 12 insertions(+)
arch/sparc/include/uapi/asm/posix_types.h +10 -0
index fec499d6efb7..f139e0048628 100644
@@ -19,6 +19,16 @@ typedef unsigned short         __kernel_old_gid_t;
 typedef int		       __kernel_suseconds_t;
 #define __kernel_suseconds_t __kernel_suseconds_t
 
+typedef long		__kernel_long_t;
+typedef unsigned long	__kernel_ulong_t;
+#define __kernel_long_t __kernel_long_t
+
+struct __kernel_old_timeval {
+	__kernel_long_t tv_sec;
+	__kernel_suseconds_t tv_usec;
+};
+#define __kernel_old_timeval __kernel_old_timeval
+
 #else
 /* sparc 32 bit */
 
include/uapi/linux/time.h +2 -0
index 6b56a2208be7..04d5587f30d3 100644
@@ -63,10 +63,12 @@ struct __kernel_itimerspec {
  * here, this is probably because it is not y2038 safe and needs to
  * be changed to use another interface.
  */
+#ifndef __kernel_old_timeval
 struct __kernel_old_timeval {
 	__kernel_long_t tv_sec;
 	__kernel_long_t tv_usec;
 };
+#endif
 
 /*
  * The IDs of the various system clocks (for POSIX.1b interval timers):
Signature · 1 line
2.17.1
#14 lore raw

PATCH 5/8 socket: Use old_timeval types for socket timestamps

In reply to Deepa Dinamani

As part of y2038 solution, all internal uses of struct timeval are replaced by struct __kernel_old_timeval and struct compat_timeval by struct old_timeval32. Make socket timestamps use these new types.

This is mainly to be able to verify that the kernel build is y2038 safe when such non y2038 safe types are not supported anymore.

---
 drivers/isdn/mISDN/socket.c | 2 +-
 include/linux/skbuff.h      | 6 +++---
 net/bluetooth/hci_sock.c    | 4 ++--
 net/compat.c                | 6 +++---
 net/ipv4/tcp.c              | 2 +-
 net/rds/recv.c              | 2 +-
 net/socket.c                | 2 +-
 7 files changed, 12 insertions(+), 12 deletions(-)
drivers/isdn/mISDN/socket.c +1 -1
index 15d3ca37669a..4ab8b1b6608f 100644
@@ -103,7 +103,7 @@ mISDN_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
 static inline void
 mISDN_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
 {
-	struct timeval	tv;
+	struct __kernel_old_timeval	tv;
 
 	if (_pms(sk)->cmask & MISDN_TIME_STAMP) {
 		skb_get_timestamp(skb, &tv);
include/linux/skbuff.h +3 -3
index a2e8297a5b00..e2dc01330cb1 100644
@@ -3453,16 +3453,16 @@ static inline ktime_t skb_get_ktime(const struct sk_buff *skb)
 /**
  *	skb_get_timestamp - get timestamp from a skb
  *	@skb: skb to get stamp from
- *	@stamp: pointer to struct timeval to store stamp in
+ *	@stamp: pointer to struct __kernel_old_timeval to store stamp in
  *
  *	Timestamps are stored in the skb as offsets to a base timestamp.
  *	This function converts the offset back to a struct timeval and stores
  *	it in stamp.
  */
 static inline void skb_get_timestamp(const struct sk_buff *skb,
-				     struct timeval *stamp)
+				     struct __kernel_old_timeval *stamp)
 {
-	*stamp = ktime_to_timeval(skb->tstamp);
+	*stamp = ns_to_kernel_old_timeval(skb->tstamp);
 }
 
 static inline void skb_get_timestampns(const struct sk_buff *skb,
net/bluetooth/hci_sock.c +2 -2
index 10dfd20c748e..32aff3755480 100644
@@ -1400,9 +1400,9 @@ static void hci_sock_cmsg(struct sock *sk, struct msghdr *msg,
 
 	if (mask & HCI_CMSG_TSTAMP) {
 #ifdef CONFIG_COMPAT
-		struct compat_timeval ctv;
+		struct old_timeval32 ctv;
 #endif
-		struct timeval tv;
+		struct __kernel_old_timeval tv;
 		void *data;
 		int len;
 
net/compat.c +3 -3
index 720ab07276b0..8dea66c96926 100644
@@ -209,8 +209,8 @@ int put_cmsg_compat(struct msghdr *kmsg, int level, int type, int len, void *dat
 {
 	struct compat_cmsghdr __user *cm = (struct compat_cmsghdr __user *) kmsg->msg_control;
 	struct compat_cmsghdr cmhdr;
-	struct compat_timeval ctv;
-	struct compat_timespec cts[3];
+	struct old_timeval32 ctv;
+	struct old_timespec32 cts[3];
 	int cmlen;
 
 	if (cm == NULL || kmsg->msg_controllen < sizeof(*cm)) {
@@ -220,7 +220,7 @@ int put_cmsg_compat(struct msghdr *kmsg, int level, int type, int len, void *dat
 
 	if (!COMPAT_USE_64BIT_TIME) {
 		if (level == SOL_SOCKET && type == SO_TIMESTAMP_OLD) {
-			struct timeval *tv = (struct timeval *)data;
+			struct __kernel_old_timeval *tv = (struct __kernel_old_timeval *)data;
 			ctv.tv_sec = tv->tv_sec;
 			ctv.tv_usec = tv->tv_usec;
 			data = &ctv;
net/ipv4/tcp.c +1 -1
index d6eb5f542fcf..805d9965a210 100644
@@ -1864,7 +1864,7 @@ static void tcp_update_recv_tstamps(struct sk_buff *skb,
 static void tcp_recv_timestamp(struct msghdr *msg, const struct sock *sk,
 			       struct scm_timestamping *tss)
 {
-	struct timeval tv;
+	struct __kernel_old_timeval tv;
 	bool has_timestamping = false;
 
 	if (tss->ts[0].tv_sec || tss->ts[0].tv_nsec) {
net/rds/recv.c +1 -1
index 04e30d63a159..435bf2320cd3 100644
@@ -549,7 +549,7 @@ static int rds_cmsg_recv(struct rds_incoming *inc, struct msghdr *msg,
 
 	if ((inc->i_rx_tstamp != 0) &&
 	    sock_flag(rds_rs_to_sk(rs), SOCK_RCVTSTAMP)) {
-		struct timeval tv = ktime_to_timeval(inc->i_rx_tstamp);
+		struct __kernel_old_timeval tv = ns_to_kernel_old_timeval(inc->i_rx_tstamp);
 		ret = put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
 			       sizeof(tv), &tv);
 		if (ret)
net/socket.c +1 -1
index c7455349a3c1..d3defba55547 100644
@@ -721,7 +721,7 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
 
 	if (need_software_tstamp) {
 		if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
-			struct timeval tv;
+			struct __kernel_old_timeval tv;
 			skb_get_timestamp(skb, &tv);
 			put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
 				 sizeof(tv), &tv);
Signature · 1 line
2.17.1
#15 lore raw

PATCH 6/8 socket: Add struct sock_timeval

In reply to Deepa Dinamani

The new type is meant to be used as a y2038 safe structure to be used as part of cmsg data.
Presently the SO_TIMESTAMP socket option uses struct timeval for timestamps. This is not y2038 safe.
Subsequent patches in the series add new y2038 safe socket option to be used in the place of SO_TIMESTAMP_OLD. struct sock_timeval will be used as the timestamp format at that time.

struct sock_timeval also maintains the same layout across 32 bit and 64 bit ABIs.

---
 include/uapi/linux/time.h | 5 +++++
 1 file changed, 5 insertions(+)
include/uapi/linux/time.h +5 -0
index 04d5587f30d3..106f9398c285 100644
@@ -70,6 +70,11 @@ struct __kernel_old_timeval {
 };
 #endif
 
+struct sock_timeval {
+	long long tv_sec;
+	long long tv_usec;
+};
+
 /*
  * The IDs of the various system clocks (for POSIX.1b interval timers):
  */
Signature · 1 line
2.17.1
#16 lore raw

Re: [PATCH 6/8] socket: Add struct sock_timeval

Quoted 23 lines · Deepa Dinamani

The new type is meant to be used as a y2038 safe structure to be used as part of cmsg data.
Presently the SO_TIMESTAMP socket option uses struct timeval for timestamps. This is not y2038 safe.
Subsequent patches in the series add new y2038 safe socket option to be used in the place of SO_TIMESTAMP_OLD. struct sock_timeval will be used as the timestamp format at that time.

struct sock_timeval also maintains the same layout across 32 bit and 64 bit ABIs.

---
 include/uapi/linux/time.h | 5 +++++
 1 file changed, 5 insertions(+)
include/uapi/linux/time.h +0 -0
index 04d5587f30d3..106f9398c285 100644

include/uapi/linux/time.h struct __kernel_old_timeval { · line 75

Quoted 6 lines
include/uapi/linux/time.h +3 -0
@@ -70,6 +70,11 @@ struct __kernel_old_timeval {
 };
 #endif
 
+struct sock_timeval {
+       long long tv_sec;
+       long long tv_usec;

should these use fixed-width type __u64?

even if all data models define long long as 64-bit, that might be more descriptive.
_______________________________________________
Y2038 mailing list
[email protected]
https://lists.linaro.org/mailman/listinfo/y2038

maintainer
#17 lore raw

Re: [PATCH 6/8] socket: Add struct sock_timeval

From: Willem de Bruijn <[email protected]>
Date: Sat, 24 Nov 2018 14:37:42 -0500

Quoted 9 lines · Deepa Dinamani
Quoted 8 lines
include/uapi/linux/time.h +0 -0
index 04d5587f30d3..106f9398c285 100644
@@ -70,6 +70,11 @@ struct __kernel_old_timeval {
 };
 #endif
 
Quoted 8 lines

include/uapi/linux/time.h struct __kernel_old_timeval { · line 75

Quoted 3 lines
include/uapi/linux/time.h +3 -0
+struct sock_timeval {
+       long long tv_sec;
+       long long tv_usec;

should these use fixed-width type __u64?

even if all data models define long long as 64-bit, that might be more descriptive.

Agreed.

#18 lore raw

Re: [PATCH 6/8] socket: Add struct sock_timeval

In reply to Willem de Bruijn
Quoted 28 lines · Willem de Bruijn
Quoted 26 lines · Deepa Dinamani

The new type is meant to be used as a y2038 safe structure to be used as part of cmsg data.
Presently the SO_TIMESTAMP socket option uses struct timeval for timestamps. This is not y2038 safe.
Subsequent patches in the series add new y2038 safe socket option to be used in the place of SO_TIMESTAMP_OLD. struct sock_timeval will be used as the timestamp format at that time.

struct sock_timeval also maintains the same layout across 32 bit and 64 bit ABIs.

---
 include/uapi/linux/time.h | 5 +++++
 1 file changed, 5 insertions(+)
include/uapi/linux/time.h +0 -0
index 04d5587f30d3..106f9398c285 100644
@@ -70,6 +70,11 @@ struct __kernel_old_timeval {
 };
 #endif
 
Quoted 5 lines

include/uapi/linux/time.h struct __kernel_old_timeval { · line 75

Quoted 3 lines
include/uapi/linux/time.h +3 -0
+struct sock_timeval {
+       long long tv_sec;
+       long long tv_usec;

should these use fixed-width type __u64?

We have avoided using __u64/__s64 types for time types in uapi. I think we did this for portability reasons.
Although this new type might not be required to be interpreted in libc, I would prefer for this to be long long.
If there is a strong preference then I can change it.

-Deepa
_______________________________________________
Y2038 mailing list
[email protected]
https://lists.linaro.org/mailman/listinfo/y2038

maintainer
#19 lore raw

Re: [PATCH 6/8] socket: Add struct sock_timeval

Quoted 34 lines · Deepa Dinamani
Quoted 27 lines · Willem de Bruijn
Quoted 26 lines · Deepa Dinamani

The new type is meant to be used as a y2038 safe structure to be used as part of cmsg data.
Presently the SO_TIMESTAMP socket option uses struct timeval for timestamps. This is not y2038 safe.
Subsequent patches in the series add new y2038 safe socket option to be used in the place of SO_TIMESTAMP_OLD. struct sock_timeval will be used as the timestamp format at that time.

struct sock_timeval also maintains the same layout across 32 bit and 64 bit ABIs.

---
 include/uapi/linux/time.h | 5 +++++
 1 file changed, 5 insertions(+)
include/uapi/linux/time.h +0 -0
index 04d5587f30d3..106f9398c285 100644
@@ -70,6 +70,11 @@ struct __kernel_old_timeval {
 };
 #endif
 
Quoted 5 lines

include/uapi/linux/time.h struct __kernel_old_timeval { · line 75

Quoted 3 lines
include/uapi/linux/time.h +3 -0
+struct sock_timeval {
+       long long tv_sec;
+       long long tv_usec;

should these use fixed-width type __u64?

Quoted 5 lines

We have avoided using __u64/__s64 types for time types in uapi. I think we did this for portability reasons.
Although this new type might not be required to be interpreted in libc, I would prefer for this to be long long.
If there is a strong preference then I can change it.

I think we want signed types to keep it closer to what we have today with 'timeval'. as long as linux/types.h is included first (it is).

Between __s64 or long long, I don't think it makes a difference, so let's just go with Willem's suggestion. We already rely on 'long long' being exactly 64 bit wide in 'struct __kernel_timespec' as well.

We could however debate whether 'sock_timeval' should be visible to user space in linux/tme.h like this, or if it should be put in a namespace like '__kernel_sock_timeval' to ensure it won't conflict with user space headers defining a type of the same name.

Arnd

#20 lore raw

Re: [PATCH 6/8] socket: Add struct sock_timeval

Quoted 8 lines

I think we want signed types to keep it closer to what we have today with 'timeval'. as long as linux/types.h is included first (it is).

Between __s64 or long long, I don't think it makes a difference, so let's just go with Willem's suggestion. We already rely on 'long long' being exactly 64 bit wide in 'struct __kernel_timespec' as well.

Sure, I will change this to __s64.
I was also thinking we want signed types because it should be possible to set system time before 1970.

Quoted 5 lines

We could however debate whether 'sock_timeval' should be visible to user space in linux/tme.h like this, or if it should be put in a namespace like '__kernel_sock_timeval' to ensure it won't conflict with user space headers defining a type of the same name.

Good idea. I can rename it to __kernel_sock_timeval.

Thanks,
Deepa

#21 lore raw

PATCH 7/8 socket: Add SO_TIMESTAMP[NS]_NEW

In reply to Deepa Dinamani

Add SO_TIMESTAMP_NEW and SO_TIMESTAMPNS_NEW variants of socket timestamp options.
These are the y2038 safe versions of the SO_TIMESTAMP_OLD and SO_TIMESTAMPNS_OLD for all architectures.

Note that the format of scm_timestamping.ts[0] is not changed in this patch.

---
 arch/alpha/include/uapi/asm/socket.h  | 15 ++++++-
 arch/mips/include/uapi/asm/socket.h   | 14 +++++-
 arch/parisc/include/uapi/asm/socket.h | 14 +++++-
 arch/sparc/include/uapi/asm/socket.h  | 14 +++++-
 include/linux/skbuff.h                | 18 ++++++++
 include/net/sock.h                    |  1 +
 include/uapi/asm-generic/socket.h     | 15 ++++++-
 net/core/sock.c                       | 18 ++++++++
 net/ipv4/tcp.c                        | 61 +++++++++++++++++++--------
 net/rds/af_rds.c                      |  8 +++-
 net/rds/recv.c                        | 16 ++++++-
 net/socket.c                          | 47 +++++++++++++++------
 12 files changed, 197 insertions(+), 44 deletions(-)
arch/alpha/include/uapi/asm/socket.h +13 -2
index 00e45c80e574..352e3dc0b3d9 100644
@@ -3,6 +3,7 @@
 #define _UAPI_ASM_SOCKET_H
 
 #include <asm/sockios.h>
+#include <asm/bitsperlong.h>
 
 /* For setsockopt(2) */
 /*
@@ -110,12 +111,22 @@
 
 #define SO_TIMESTAMP_OLD         29
 #define SO_TIMESTAMPNS_OLD       35
+
 #define SO_TIMESTAMPING_OLD      37
 
+#define SO_TIMESTAMP_NEW         62
+#define SO_TIMESTAMPNS_NEW       63
+
 #if !defined(__KERNEL__)
 
-#define SO_TIMESTAMP           SO_TIMESTAMP_OLD
-#define SO_TIMESTAMPNS         SO_TIMESTAMPNS_OLD
+#if __BITS_PER_LONG == 64
+#define SO_TIMESTAMP		SO_TIMESTAMP_OLD
+#define SO_TIMESTAMPNS		SO_TIMESTAMPNS_OLD
+#else
+#define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)
+#define SO_TIMESTAMPNS (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPNS_OLD : SO_TIMESTAMPNS_NEW)
+#endif
+
 #define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
 
 #define SCM_TIMESTAMP          SO_TIMESTAMP
arch/mips/include/uapi/asm/socket.h +12 -2
index b9553f770346..d1752e3f1248 100644
@@ -11,6 +11,7 @@
 #define _UAPI_ASM_SOCKET_H
 
 #include <asm/sockios.h>
+#include <asm/bitsperlong.h>
 
 /*
  * For setsockopt(2)
@@ -123,10 +124,19 @@
 #define SO_TIMESTAMPNS_OLD       35
 #define SO_TIMESTAMPING_OLD      37
 
+#define SO_TIMESTAMP_NEW         62
+#define SO_TIMESTAMPNS_NEW       63
+
 #if !defined(__KERNEL__)
 
-#define SO_TIMESTAMP           SO_TIMESTAMP_OLD
-#define SO_TIMESTAMPNS         SO_TIMESTAMPNS_OLD
+#if __BITS_PER_LONG == 64
+#define SO_TIMESTAMP		SO_TIMESTAMP_OLD
+#define SO_TIMESTAMPNS		SO_TIMESTAMPNS_OLD
+#else
+#define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)
+#define SO_TIMESTAMPNS (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPNS_OLD : SO_TIMESTAMPNS_NEW)
+#endif
+
 #define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
 
 #define SCM_TIMESTAMP          SO_TIMESTAMP
arch/parisc/include/uapi/asm/socket.h +12 -2
index 37cdfe64bb27..0a45b668abd1 100644
@@ -3,6 +3,7 @@
 #define _UAPI_ASM_SOCKET_H
 
 #include <asm/sockios.h>
+#include <asm/bitsperlong.h>
 
 /* For setsockopt(2) */
 #define SOL_SOCKET	0xffff
@@ -104,10 +105,19 @@
 #define SO_TIMESTAMPNS_OLD       0x4013
 #define SO_TIMESTAMPING_OLD      0x4020
 
+#define SO_TIMESTAMP_NEW         0x4037
+#define SO_TIMESTAMPNS_NEW       0x4038
+
 #if !defined(__KERNEL__)
 
-#define SO_TIMESTAMP           SO_TIMESTAMP_OLD
-#define SO_TIMESTAMPNS         SO_TIMESTAMPNS_OLD
+#if __BITS_PER_LONG == 64
+#define SO_TIMESTAMP		SO_TIMESTAMP_OLD
+#define SO_TIMESTAMPNS		SO_TIMESTAMPNS_OLD
+#else
+#define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)
+#define SO_TIMESTAMPNS (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPNS_OLD : SO_TIMESTAMPNS_NEW)
+#endif
+
 #define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
 
 #define SCM_TIMESTAMP          SO_TIMESTAMP
arch/sparc/include/uapi/asm/socket.h +12 -2
index ca573641fc6c..dc8527cae5a7 100644
@@ -3,6 +3,7 @@
 #define _ASM_SOCKET_H
 
 #include <asm/sockios.h>
+#include <asm/bitsperlong.h>
 
 /* For setsockopt(2) */
 #define SOL_SOCKET	0xffff
@@ -105,10 +106,19 @@
 #define SO_TIMESTAMPNS_OLD       0x0021
 #define SO_TIMESTAMPING_OLD      0x0023
 
+#define SO_TIMESTAMP_NEW         0x0040
+#define SO_TIMESTAMPNS_NEW       0x0041
+
 #if !defined(__KERNEL__)
 
-#define SO_TIMESTAMP           SO_TIMESTAMP_OLD
-#define SO_TIMESTAMPNS         SO_TIMESTAMPNS_OLD
+#if __BITS_PER_LONG == 64
+#define SO_TIMESTAMP		SO_TIMESTAMP_OLD
+#define SO_TIMESTAMPNS		SO_TIMESTAMPNS_OLD
+#else
+#define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)
+#define SO_TIMESTAMPNS (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPNS_OLD : SO_TIMESTAMPNS_NEW)
+#endif
+
 #define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
 
 #define SCM_TIMESTAMP          SO_TIMESTAMP
include/linux/skbuff.h +18 -0
index e2dc01330cb1..1e42c4a2209d 100644
@@ -3465,12 +3465,30 @@ static inline void skb_get_timestamp(const struct sk_buff *skb,
 	*stamp = ns_to_kernel_old_timeval(skb->tstamp);
 }
 
+static inline void skb_get_new_timestamp(const struct sk_buff *skb,
+				     struct sock_timeval *stamp)
+{
+	struct timespec64 ts = ktime_to_timespec64(skb->tstamp);
+
+	stamp->tv_sec = ts.tv_sec;
+	stamp->tv_usec = ts.tv_nsec / 1000;
+}
+
 static inline void skb_get_timestampns(const struct sk_buff *skb,
 				       struct timespec *stamp)
 {
 	*stamp = ktime_to_timespec(skb->tstamp);
 }
 
+static inline void skb_get_new_timestampns(const struct sk_buff *skb,
+				       struct __kernel_timespec *stamp)
+{
+	struct timespec64 ts = ktime_to_timespec64(skb->tstamp);
+
+	stamp->tv_sec = ts.tv_sec;
+	stamp->tv_nsec = ts.tv_nsec;
+}
+
 static inline void __net_timestamp(struct sk_buff *skb)
 {
 	skb->tstamp = ktime_get_real();
include/net/sock.h +1 -0
index 8143c4c1a49d..9edf909dc176 100644
@@ -801,6 +801,7 @@ enum sock_flags {
 	SOCK_RCU_FREE, /* wait rcu grace period in sk_destruct() */
 	SOCK_TXTIME,
 	SOCK_XDP, /* XDP is attached */
+	SOCK_TSTAMP_NEW, /* Indicates 64 bit timestamps always */
 };
 
 #define SK_FLAGS_TIMESTAMP ((1UL << SOCK_TIMESTAMP) | (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE))
include/uapi/asm-generic/socket.h +13 -2
index dc704e41203d..0b0fae6b57a9 100644
@@ -3,6 +3,7 @@
 #define __ASM_GENERIC_SOCKET_H
 
 #include <asm/sockios.h>
+#include <asm/bitsperlong.h>
 
 /* For setsockopt(2) */
 #define SOL_SOCKET	1
@@ -107,10 +108,20 @@
 #define SO_TIMESTAMPNS_OLD       35
 #define SO_TIMESTAMPING_OLD      37
 
+#define SO_TIMESTAMP_NEW         62
+#define SO_TIMESTAMPNS_NEW       63
+
 #if !defined(__KERNEL__)
 
-#define SO_TIMESTAMP           SO_TIMESTAMP_OLD
-#define SO_TIMESTAMPNS         SO_TIMESTAMPNS_OLD
+#if __BITS_PER_LONG == 64 || (defined(__x86_64__) && defined(__ILP32__))
+/* on 64-bit and x32, avoid the ?: operator */
+#define SO_TIMESTAMP		SO_TIMESTAMP_OLD
+#define SO_TIMESTAMPNS		SO_TIMESTAMPNS_OLD
+#else
+#define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)
+#define SO_TIMESTAMPNS (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPNS_OLD : SO_TIMESTAMPNS_NEW)
+#endif
+
 #define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
 
 #define SCM_TIMESTAMP          SO_TIMESTAMP
net/core/sock.c +18 -0
index e60036618205..7b485dfaa400 100644
@@ -652,15 +652,23 @@ static void setsockopt_timestamp(struct sock *sk, int type, int val)
 	if (!val) {
 		sock_reset_flag(sk, SOCK_RCVTSTAMP);
 		sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
+		sock_reset_flag(sk, SOCK_TSTAMP_NEW);
 		return;
 	}
 
+	if (type == SO_TIMESTAMP_NEW || type == SO_TIMESTAMPNS_NEW)
+		sock_set_flag(sk, SOCK_TSTAMP_NEW);
+	else
+		sock_reset_flag(sk, SOCK_TSTAMP_NEW);
+
 	switch (type) {
 	case SO_TIMESTAMP_OLD:
+	case SO_TIMESTAMP_NEW:
 		sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
 		sock_set_flag(sk, SOCK_RCVTSTAMP);
 		break;
 	case SO_TIMESTAMPNS_OLD:
+	case SO_TIMESTAMPNS_NEW:
 		sock_reset_flag(sk, SOCK_RCVTSTAMP);
 		sock_set_flag(sk, SOCK_RCVTSTAMPNS);
 		break;
@@ -837,7 +845,9 @@ int sock_setsockopt(struct socket *sock, int level, int optname,
 		break;
 
 	case SO_TIMESTAMP_OLD:
+	case SO_TIMESTAMP_NEW:
 	case SO_TIMESTAMPNS_OLD:
+	case SO_TIMESTAMPNS_NEW:
 		setsockopt_timestamp(sk, optname, valbool);
 		break;
 
@@ -1202,6 +1212,14 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
 		v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
 		break;
 
+	case SO_TIMESTAMP_NEW:
+		v.val = sock_flag(sk, SOCK_RCVTSTAMP) && sock_flag(sk, SOCK_TSTAMP_NEW);
+		break;
+
+	case SO_TIMESTAMPNS_NEW:
+		v.val = sock_flag(sk, SOCK_RCVTSTAMPNS) && sock_flag(sk, SOCK_TSTAMP_NEW);
+		break;
+
 	case SO_TIMESTAMPING_OLD:
 		v.val = sk->sk_tsflags;
 		break;
net/ipv4/tcp.c +44 -17

74 lines not on this page · raw message

net/rds/af_rds.c +6 -2
index eeb4639adbe5..65571a6273c3 100644
@@ -348,7 +348,7 @@ static int rds_set_transport(struct rds_sock *rs, char __user *optval,
 }
 
 static int rds_enable_recvtstamp(struct sock *sk, char __user *optval,
-				 int optlen)
+				 int optlen, int optname)
 {
 	int val, valbool;
 
@@ -360,6 +360,9 @@ static int rds_enable_recvtstamp(struct sock *sk, char __user *optval,
 
 	valbool = val ? 1 : 0;
 
+	if (optname == SO_TIMESTAMP_NEW)
+		sock_set_flag(sk, SOCK_TSTAMP_NEW);
+
 	if (valbool)
 		sock_set_flag(sk, SOCK_RCVTSTAMP);
 	else
@@ -431,8 +434,9 @@ static int rds_setsockopt(struct socket *sock, int level, int optname,
 		release_sock(sock->sk);
 		break;
 	case SO_TIMESTAMP_OLD:
+	case SO_TIMESTAMP_NEW:
 		lock_sock(sock->sk);
-		ret = rds_enable_recvtstamp(sock->sk, optval, optlen);
+		ret = rds_enable_recvtstamp(sock->sk, optval, optlen, optname);
 		release_sock(sock->sk);
 		break;
 	case SO_RDS_MSG_RXPATH_LATENCY:
net/rds/recv.c +14 -2
index 435bf2320cd3..4c3fd56dc4ca 100644
@@ -550,8 +550,20 @@ static int rds_cmsg_recv(struct rds_incoming *inc, struct msghdr *msg,
 	if ((inc->i_rx_tstamp != 0) &&
 	    sock_flag(rds_rs_to_sk(rs), SOCK_RCVTSTAMP)) {
 		struct __kernel_old_timeval tv = ns_to_kernel_old_timeval(inc->i_rx_tstamp);
-		ret = put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
-			       sizeof(tv), &tv);
+
+		if (!sock_flag(rds_rs_to_sk(rs), SOCK_TSTAMP_NEW)) {
+			ret = put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
+				       sizeof(tv), &tv);
+		} else {
+			struct sock_timeval sk_tv;
+
+			sk_tv.tv_sec = tv.tv_sec;
+			sk_tv.tv_usec = tv.tv_usec;
+
+			ret = put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_NEW,
+				       sizeof(sk_tv), &sk_tv);
+		}
+
 		if (ret)
 			goto out;
 	}
net/socket.c +34 -13

59 lines not on this page · raw message

Signature · 1 line
2.17.1
#22 lore raw

Re: [PATCH 7/8] socket: Add SO_TIMESTAMP[NS]_NEW

Quoted 26 lines · Deepa Dinamani

Add SO_TIMESTAMP_NEW and SO_TIMESTAMPNS_NEW variants of socket timestamp options.
These are the y2038 safe versions of the SO_TIMESTAMP_OLD and SO_TIMESTAMPNS_OLD for all architectures.

Note that the format of scm_timestamping.ts[0] is not changed in this patch.

---

include/net/sock.h +0 -0
index 8143c4c1a49d..9edf909dc176 100644

include/net/sock.h enum sock_flags { · line 804

Quoted 4 lines
include/net/sock.h +1 -0
@@ -801,6 +801,7 @@ enum sock_flags {
        SOCK_RCU_FREE, /* wait rcu grace period in sk_destruct() */
        SOCK_TXTIME,
        SOCK_XDP, /* XDP is attached */
+       SOCK_TSTAMP_NEW, /* Indicates 64 bit timestamps always */

sk_flags is getting exhausted. Commit b9f40e21ef42 ("net-timestamp:
move timestamp flags out of sk_flags") added a new u16 sk_tsflags specifically for timestamps. That may be a better choice here, too.

Quoted 7 lines
net/core/sock.c +0 -0
index e60036618205..7b485dfaa400 100644
@@ -652,15 +652,23 @@ static void setsockopt_timestamp(struct sock *sk, int type, int val)
        if (!val) {
                sock_reset_flag(sk, SOCK_RCVTSTAMP);

net/core/sock.c static void setsockopt_timestamp(struct sock *sk, int type, int val) · line 663

Quoted 10 lines
net/core/sock.c +6 -0
                sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
+               sock_reset_flag(sk, SOCK_TSTAMP_NEW);
                return;
        }
 
+       if (type == SO_TIMESTAMP_NEW || type == SO_TIMESTAMPNS_NEW)
+               sock_set_flag(sk, SOCK_TSTAMP_NEW);
+       else
+               sock_reset_flag(sk, SOCK_TSTAMP_NEW);
+

if adding a boolean whether the socket uses new or old-style timestamps, perhaps fail hard if a process tries to set a new-style option while an old-style is already set and vice versa. Also include SO_TIMESTAMPING_NEW as it toggles the same option.

Quoted 44 lines
net/socket.c +32 -0
index d3defba55547..9abeb6bc9cfe 100644
@@ -699,6 +699,38 @@ static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb)
                 sizeof(ts_pktinfo), &ts_pktinfo);
 }
 
+static void sock_recv_sw_timestamp(struct msghdr *msg, struct sock *sk,
+                                  struct sk_buff *skb)
+{
+       if (sock_flag(sk, SOCK_TSTAMP_NEW)) {
+               if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
+                       struct sock_timeval tv;
+
+                       skb_get_new_timestamp(skb, &tv);
+                       put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_NEW,
+                                sizeof(tv), &tv);
+               } else {
+                       struct __kernel_timespec ts;
+
+                       skb_get_new_timestampns(skb, &ts);
+                       put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_NEW,
+                                sizeof(ts), &ts);
+               }
+       }
+       if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
+               struct __kernel_old_timeval tv;
+
+               skb_get_timestamp(skb, &tv);
+               put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
+                        sizeof(tv), &tv);
+       } else {
+               struct timespec ts;
+
+               skb_get_timestampns(skb, &ts);
+               put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
+                        sizeof(ts), &ts);
+       }
+}
 /*
  * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
  * or sock_flag(sk, SOCK_RCVTSTAMPNS)

net/socket.c void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, · line 721

Quoted 3 lines
net/socket.c +0 -1
@@ -719,19 +751,8 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
                false_tstamp = 1;
        }
-       if (need_software_tstamp) {

Considerably less code churn if adding __sock_recv_timestamp_2038 and calling that here:

                   if (sock_flag(sk, SOCK_TSTAMP_NEW))
                           __sock_recv_timestamp_2038(msg, sk, skb);
                   else if ...

Same for the tcp case above, really, and in the case of the next patch for SO_TIMESTAMPING_NEW

Quoted 22 lines
net/socket.c +2 -12
-               if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
-                       struct __kernel_old_timeval tv;
-                       skb_get_timestamp(skb, &tv);
-                       put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
-                                sizeof(tv), &tv);
-               } else {
-                       struct timespec ts;
-                       skb_get_timestampns(skb, &ts);
-                       put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
-                                sizeof(ts), &ts);
-               }
-       }
 
 
+       if (need_software_tstamp)
+               sock_recv_sw_timestamp(msg, sk, skb);
 
        memset(&tss, 0, sizeof(tss));
        if ((sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) &&

--
2.17.1

#23 lore raw

Re: [PATCH 7/8] socket: Add SO_TIMESTAMP[NS]_NEW

Quoted 111 lines · Willem de Bruijn
Quoted 26 lines · Deepa Dinamani

Add SO_TIMESTAMP_NEW and SO_TIMESTAMPNS_NEW variants of socket timestamp options.
These are the y2038 safe versions of the SO_TIMESTAMP_OLD and SO_TIMESTAMPNS_OLD for all architectures.

Note that the format of scm_timestamping.ts[0] is not changed in this patch.

---

include/net/sock.h +0 -0
index 8143c4c1a49d..9edf909dc176 100644

include/net/sock.h enum sock_flags { · line 804

Quoted 4 lines
include/net/sock.h +1 -0
@@ -801,6 +801,7 @@ enum sock_flags {
        SOCK_RCU_FREE, /* wait rcu grace period in sk_destruct() */
        SOCK_TXTIME,
        SOCK_XDP, /* XDP is attached */
+       SOCK_TSTAMP_NEW, /* Indicates 64 bit timestamps always */

sk_flags is getting exhausted. Commit b9f40e21ef42 ("net-timestamp:
move timestamp flags out of sk_flags") added a new u16 sk_tsflags specifically for timestamps. That may be a better choice here, too.

Quoted 7 lines
net/core/sock.c +0 -0
index e60036618205..7b485dfaa400 100644
@@ -652,15 +652,23 @@ static void setsockopt_timestamp(struct sock *sk, int type, int val)
        if (!val) {
                sock_reset_flag(sk, SOCK_RCVTSTAMP);

net/core/sock.c static void setsockopt_timestamp(struct sock *sk, int type, int val) · line 663

Quoted 10 lines
net/core/sock.c +6 -0
                sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
+               sock_reset_flag(sk, SOCK_TSTAMP_NEW);
                return;
        }
 
+       if (type == SO_TIMESTAMP_NEW || type == SO_TIMESTAMPNS_NEW)
+               sock_set_flag(sk, SOCK_TSTAMP_NEW);
+       else
+               sock_reset_flag(sk, SOCK_TSTAMP_NEW);
+

if adding a boolean whether the socket uses new or old-style timestamps, perhaps fail hard if a process tries to set a new-style option while an old-style is already set and vice versa. Also include SO_TIMESTAMPING_NEW as it toggles the same option.

Quoted 44 lines
net/socket.c +32 -0
index d3defba55547..9abeb6bc9cfe 100644
@@ -699,6 +699,38 @@ static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb)
                 sizeof(ts_pktinfo), &ts_pktinfo);
 }
 
+static void sock_recv_sw_timestamp(struct msghdr *msg, struct sock *sk,
+                                  struct sk_buff *skb)
+{
+       if (sock_flag(sk, SOCK_TSTAMP_NEW)) {
+               if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
+                       struct sock_timeval tv;
+
+                       skb_get_new_timestamp(skb, &tv);
+                       put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_NEW,
+                                sizeof(tv), &tv);
+               } else {
+                       struct __kernel_timespec ts;
+
+                       skb_get_new_timestampns(skb, &ts);
+                       put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_NEW,
+                                sizeof(ts), &ts);
+               }
+       }
+       if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
+               struct __kernel_old_timeval tv;
+
+               skb_get_timestamp(skb, &tv);
+               put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
+                        sizeof(tv), &tv);
+       } else {
+               struct timespec ts;
+
+               skb_get_timestampns(skb, &ts);
+               put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
+                        sizeof(ts), &ts);
+       }
+}
 /*
  * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
  * or sock_flag(sk, SOCK_RCVTSTAMPNS)

net/socket.c void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, · line 721

Quoted 3 lines
net/socket.c +0 -1
@@ -719,19 +751,8 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
                false_tstamp = 1;
        }
-       if (need_software_tstamp) {

Considerably less code churn if adding __sock_recv_timestamp_2038 and calling that here:

Quoted 6 lines
                   if (sock_flag(sk, SOCK_TSTAMP_NEW))
                           __sock_recv_timestamp_2038(msg, sk, skb);
                   else if ...

Same for the tcp case above, really, and in the case of the next patch for SO_TIMESTAMPING_NEW

That naming convention, ..._2038, is not the nicest, of course. That is not the relevant bit in the above comment.

Come to think of it, and related to my question in patch 2 why the need to rename at all, could all new structs, constants and functions be named consistently with 64 suffix? __sock_recv_timestamp64, SO_TIMESTAMPING64 and timeval64 (instead of sock_timeval, it isn't really a sock specific struct)?

I guess that there is a good reason for the renaming exercise and conditional mapping of SO_TIMESTAMP onto old or new interface. Please elucidate in the commit message.
_______________________________________________
Y2038 mailing list
[email protected]
https://lists.linaro.org/mailman/listinfo/y2038

#24 lore raw

Re: [PATCH 7/8] socket: Add SO_TIMESTAMP[NS]_NEW

Quoted 10 lines
Quoted 10 lines

net/core/sock.c static void setsockopt_timestamp(struct sock *sk, int type, int val) · line 663

Quoted 5 lines
net/core/sock.c +5 -0
+       if (type == SO_TIMESTAMP_NEW || type == SO_TIMESTAMPNS_NEW)
+               sock_set_flag(sk, SOCK_TSTAMP_NEW);
+       else
+               sock_reset_flag(sk, SOCK_TSTAMP_NEW);
+

if adding a boolean whether the socket uses new or old-style timestamps, perhaps fail hard if a process tries to set a new-style option while an old-style is already set and vice versa. Also include SO_TIMESTAMPING_NEW as it toggles the same option.

I do not think this is a problem.
Consider this example, if there is a user application with updated socket timestamps is linking into a library that is yet to be updated.

Besides, the old timestamps should work perfectly fine on 64 bit arches even beyond 2038.
So failing here means adding a bunch of ifdef's to verify it is not executing on 64 bit arch or something like x32.

Quoted 67 lines
Quoted 51 lines
Quoted 44 lines
net/socket.c +32 -0
index d3defba55547..9abeb6bc9cfe 100644
@@ -699,6 +699,38 @@ static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb)
                 sizeof(ts_pktinfo), &ts_pktinfo);
 }
 
+static void sock_recv_sw_timestamp(struct msghdr *msg, struct sock *sk,
+                                  struct sk_buff *skb)
+{
+       if (sock_flag(sk, SOCK_TSTAMP_NEW)) {
+               if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
+                       struct sock_timeval tv;
+
+                       skb_get_new_timestamp(skb, &tv);
+                       put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_NEW,
+                                sizeof(tv), &tv);
+               } else {
+                       struct __kernel_timespec ts;
+
+                       skb_get_new_timestampns(skb, &ts);
+                       put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_NEW,
+                                sizeof(ts), &ts);
+               }
+       }
+       if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
+               struct __kernel_old_timeval tv;
+
+               skb_get_timestamp(skb, &tv);
+               put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
+                        sizeof(tv), &tv);
+       } else {
+               struct timespec ts;
+
+               skb_get_timestampns(skb, &ts);
+               put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
+                        sizeof(ts), &ts);
+       }
+}
 /*
  * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
  * or sock_flag(sk, SOCK_RCVTSTAMPNS)

net/socket.c void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, · line 721

Quoted 3 lines
net/socket.c +0 -1
@@ -719,19 +751,8 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
                false_tstamp = 1;
        }
-       if (need_software_tstamp) {

Considerably less code churn if adding __sock_recv_timestamp_2038 and calling that here:

Quoted 6 lines
                   if (sock_flag(sk, SOCK_TSTAMP_NEW))
                           __sock_recv_timestamp_2038(msg, sk, skb);
                   else if ...

Same for the tcp case above, really, and in the case of the next patch for SO_TIMESTAMPING_NEW

That naming convention, ..._2038, is not the nicest, of course. That is not the relevant bit in the above comment.

Come to think of it, and related to my question in patch 2 why the need to rename at all, could all new structs, constants and functions be named consistently with 64 suffix? __sock_recv_timestamp64, SO_TIMESTAMPING64 and timeval64 (instead of sock_timeval, it isn't really a sock specific struct)?

Quoted 3 lines

I guess that there is a good reason for the renaming exercise and conditional mapping of SO_TIMESTAMP onto old or new interface. Please elucidate in the commit message.

I think there is some confusion here.

The existing timestamp options: SO_TIMESTAMP* fail to provide proper timestamps beyond year 2038 on 32 bit ABIs.
But, these work fine on 64 bit native ABIs.
So now we need a way of updating these timestamps so that we do not break existing userspace: 64 bit ABIs should not have to change userspace, 32 bit ABIs should work as is until 2038 after which they have bad timestamps.
So we introduce new y2038 safe timestamp options for 32 bit ABIs. We assume that 32 bit applications will switch to new ABIs at some point, but leave the older timestamps as is.
I can update the commit text as per above.

-Deepa
_______________________________________________
Y2038 mailing list
[email protected]
https://lists.linaro.org/mailman/listinfo/y2038

#25 lore raw

Re: [PATCH 7/8] socket: Add SO_TIMESTAMP[NS]_NEW

A couple of comments I missed:

Quoted 15 lines
Quoted 15 lines
Quoted 15 lines

net/socket.c void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, · line 721

Quoted 7 lines

/*
* called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
* or sock_flag(sk, SOCK_RCVTSTAMPNS)

net/socket.c +0 -1
@@ -719,19 +751,8 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
                false_tstamp = 1;
        }
-       if (need_software_tstamp) {

Considerably less code churn if adding __sock_recv_timestamp_2038 and calling that here:

                   if (sock_flag(sk, SOCK_TSTAMP_NEW))
                           __sock_recv_timestamp_2038(msg, sk, skb);
                   else if ...
Quoted 5 lines
Quoted 5 lines
Quoted 2 lines

Same for the tcp case above, really, and in the case of the next patch for SO_TIMESTAMPING_NEW

That naming convention, ..._2038, is not the nicest, of course. That is not the relevant bit in the above comment.

it could be __sock_recv_timestamp64().
But, these timestamps should be doing exactly the same thing as the old ones and I thought it would be nicer to keep the same code path. I can change it to as per above.

Quoted 12 lines
Quoted 9 lines

Come to think of it, and related to my question in patch 2 why the need to rename at all, could all new structs, constants and functions be named consistently with 64 suffix? __sock_recv_timestamp64, SO_TIMESTAMPING64 and timeval64 (instead of sock_timeval, it isn't really a sock specific struct)?

I guess that there is a good reason for the renaming exercise and conditional mapping of SO_TIMESTAMP onto old or new interface. Please elucidate in the commit message.

I think there is some confusion here.

Quoted 11 lines

The existing timestamp options: SO_TIMESTAMP* fail to provide proper timestamps beyond year 2038 on 32 bit ABIs.
But, these work fine on 64 bit native ABIs.
So now we need a way of updating these timestamps so that we do not break existing userspace: 64 bit ABIs should not have to change userspace, 32 bit ABIs should work as is until 2038 after which they have bad timestamps.
So we introduce new y2038 safe timestamp options for 32 bit ABIs. We assume that 32 bit applications will switch to new ABIs at some point, but leave the older timestamps as is.
I can update the commit text as per above.

We have been avoiding adding timeval64 timestamps to discourage users from using these types in the interfaces.
We want to keep all the uapi time interfaces to use __kernel_* interfaces. And, we already provide __kernel_timespec interface for such instances.
But, in this case we do not have an option. So we introduce a type specific to sockets.

-Deepa
_______________________________________________
Y2038 mailing list
[email protected]
https://lists.linaro.org/mailman/listinfo/y2038

#26 lore raw

Re: [PATCH 7/8] socket: Add SO_TIMESTAMP[NS]_NEW

Quoted 10 lines
Quoted 5 lines
Quoted 5 lines
Quoted 2 lines

Same for the tcp case above, really, and in the case of the next patch for SO_TIMESTAMPING_NEW

That naming convention, ..._2038, is not the nicest, of course. That is not the relevant bit in the above comment.

it could be __sock_recv_timestamp64().
But, these timestamps should be doing exactly the same thing as the old ones and I thought it would be nicer to keep the same code path. I can change it to as per above.

Please minimize code changes. It breaks git blame and longer patches are harder to review.

In this specific case, from a readability point of view, I find new functions that map one-to-one onto the new interfaces also more readable than deeper nested branches in place.

Quoted 5 lines
Quoted 4 lines

So we introduce new y2038 safe timestamp options for 32 bit ABIs. We assume that 32 bit applications will switch to new ABIs at some point, but leave the older timestamps as is.
I can update the commit text as per above.

Quoted 7 lines

We have been avoiding adding timeval64 timestamps to discourage users from using these types in the interfaces.
We want to keep all the uapi time interfaces to use __kernel_* interfaces. And, we already provide __kernel_timespec interface for such instances.
But, in this case we do not have an option. So we introduce a type specific to sockets.

This structure just holds a timestamp. It does not seem socket specific. I don't mean to bikeshed the naming point too much, but timeval_ll or so may be more representative than tying it to a socket.

As for the general naming, xxx64 or xxx2038 are more descriptive than xxx_NEW.

#27 lore raw

Re: [PATCH 7/8] socket: Add SO_TIMESTAMP[NS]_NEW

In reply to Deepa Dinamani
Quoted 7 lines · Deepa Dinamani
Quoted 7 lines
Quoted 7 lines
Quoted 6 lines
net/core/sock.c +5 -0
+       if (type == SO_TIMESTAMP_NEW || type == SO_TIMESTAMPNS_NEW)
+               sock_set_flag(sk, SOCK_TSTAMP_NEW);
+       else
+               sock_reset_flag(sk, SOCK_TSTAMP_NEW);
+
Quoted 8 lines
Quoted 4 lines
Quoted 4 lines

if adding a boolean whether the socket uses new or old-style timestamps, perhaps fail hard if a process tries to set a new-style option while an old-style is already set and vice versa. Also include SO_TIMESTAMPING_NEW as it toggles the same option.

I do not think this is a problem.
Consider this example, if there is a user application with updated socket timestamps is linking into a library that is yet to be updated.

Also consider applications that do not use libraries.

Quoted 2 lines

Besides, the old timestamps should work perfectly fine on 64 bit arches even beyond 2038.

In that case, can we structure the code to not add branching on 64-bit platforms.

For instance, structure

if (sock_flag(sk, SOCK_TSTAMP_NEW))
__sock_recv_timestamp_2038(msg, sk, skb);

instead as a boolean function that

                  if (__sock_recv_timestamp_2038(msg, sk, skb))

and have that function's contents wrapped in an ifdef that removes it on 64-bit platforms and simply returns false?

Or more rigorously restrict these extensions to a 32-bit compat layer.

Quoted 2 lines

So failing here means adding a bunch of ifdef's to verify it is not executing on 64 bit arch or something like x32.

The code as is adds branches on platforms that do not need it. Ifdefs are ugly, but if they can be contained to the few helper functions needed for the _2038 variants of cmsg_put, that is acceptable in my opinion.

Quoted 27 lines
Quoted 27 lines
Quoted 11 lines

net/socket.c void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, · line 721

Quoted 7 lines

/*
* called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
* or sock_flag(sk, SOCK_RCVTSTAMPNS)

net/socket.c +0 -1
@@ -719,19 +751,8 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
                false_tstamp = 1;
        }
-       if (need_software_tstamp) {

Considerably less code churn if adding __sock_recv_timestamp_2038 and calling that here:

Quoted 6 lines
                   if (sock_flag(sk, SOCK_TSTAMP_NEW))
                           __sock_recv_timestamp_2038(msg, sk, skb);
                   else if ...

Same for the tcp case above, really, and in the case of the next patch for SO_TIMESTAMPING_NEW

That naming convention, ..._2038, is not the nicest, of course. That is not the relevant bit in the above comment.

Come to think of it, and related to my question in patch 2 why the need to rename at all, could all new structs, constants and functions be named consistently with 64 suffix? __sock_recv_timestamp64, SO_TIMESTAMPING64 and timeval64 (instead of sock_timeval, it isn't really a sock specific struct)?

Quoted 5 lines
Quoted 3 lines

I guess that there is a good reason for the renaming exercise and conditional mapping of SO_TIMESTAMP onto old or new interface. Please elucidate in the commit message.

I think there is some confusion here.

Yes, I know this socket timestamping code, but am less familiar with the wider discusson on 2038 timestamp conversion. It would be helpful if this patchset can be self-describing without that context or point to the discussion (unfortunately, I had miss Arnd's talk at LPC).

Quoted 11 lines

The existing timestamp options: SO_TIMESTAMP* fail to provide proper timestamps beyond year 2038 on 32 bit ABIs.
But, these work fine on 64 bit native ABIs.
So now we need a way of updating these timestamps so that we do not break existing userspace: 64 bit ABIs should not have to change userspace, 32 bit ABIs should work as is until 2038 after which they have bad timestamps.
So we introduce new y2038 safe timestamp options for 32 bit ABIs. We assume that 32 bit applications will switch to new ABIs at some point, but leave the older timestamps as is.
I can update the commit text as per above.

So on 32-bit platforms SO_TIMESTAMP_NEW introduces a new struct sock_timeval with both 64-bit fields.

Does this not break existing applications that compile against SO_TIMESTAMP and expect struct timeval? For one example, the selftests under tools/testing.

The kernel will now convert SO_TIMESTAMP (previously constant 29) to different SO_TIMESTAMP_NEW (62) and returns a different struct. Perhaps with a library like libc in the middle this can be fixed up transparently, but for
applications that don't have a more recent libc or use a library at all, it breaks
the ABI.

I suspect that these finer ABI points may have been discussed outside the narrow confines of socket timestamping. But on its own, this does worry me.
_______________________________________________
Y2038 mailing list
[email protected]
https://lists.linaro.org/mailman/listinfo/y2038

maintainer
#28 lore raw

Re: [PATCH 7/8] socket: Add SO_TIMESTAMP[NS]_NEW

Quoted 7 lines · Willem de Bruijn
Quoted 2 lines · Deepa Dinamani

So failing here means adding a bunch of ifdef's to verify it is not executing on 64 bit arch or something like x32.

The code as is adds branches on platforms that do not need it. Ifdefs are ugly, but if they can be contained to the few helper functions needed for the _2038 variants of cmsg_put, that is acceptable in my opinion.

In general, I think we should plan for the new code to be the fast path, not the old one. Initially that obviously won't be the case, but I hope that in a couple of years from now, 32-bit user space will normally use 64-bit time_t.

This also means that the compat handling for these timestamps can be identical to the native 64-bit bit version, while the old 32-bit code can be hidden behind a flag that is only active as the slowpath in native 32-bit mode or in compat mode.

I'd also want to see the same thing for the naming, with the 64-bit time_t based code having the obvious name. SOCK_TSTAMP_NEW is fine, otherwise we can try to just use SOCK_TSTAMP as the name in the kernel but make it refer to the new version.

The two special cases we have consider are x86 with x32 user space, which wants 64-bit timestamps in compat mode with SOCK_TSTAMP_OLD, and sparc64, which has an incompatible layout of timeval, so we need to make sure that sparc64 can handle all three layouts correctly.

Quoted 26 lines
Quoted 11 lines

The existing timestamp options: SO_TIMESTAMP* fail to provide proper timestamps beyond year 2038 on 32 bit ABIs.
But, these work fine on 64 bit native ABIs.
So now we need a way of updating these timestamps so that we do not break existing userspace: 64 bit ABIs should not have to change userspace, 32 bit ABIs should work as is until 2038 after which they have bad timestamps.
So we introduce new y2038 safe timestamp options for 32 bit ABIs. We assume that 32 bit applications will switch to new ABIs at some point, but leave the older timestamps as is.
I can update the commit text as per above.

So on 32-bit platforms SO_TIMESTAMP_NEW introduces a new struct sock_timeval with both 64-bit fields.

Does this not break existing applications that compile against SO_TIMESTAMP and expect struct timeval? For one example, the selftests under tools/testing.

The kernel will now convert SO_TIMESTAMP (previously constant 29) to different SO_TIMESTAMP_NEW (62) and returns a different struct. Perhaps with a library like libc in the middle this can be fixed up transparently, but for
applications that don't have a more recent libc or use a library at all, it breaks
the ABI.

Quoted 2 lines

I suspect that these finer ABI points may have been discussed outside the narrow confines of socket timestamping. But on its own, this does worry me.

The entire purpose of the complexities in the patch set is to not break the user space ABI after an application gets recompiled with a 64-bit time_t defined by a new libc version:

#define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? \
SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)

This delays the evaluation of SO_TIMESTAMP to the point where it is first used, the assumption being that at this point we have included the libc header file that defines both 'time_t' and 'struct timeval'. [If we have not included that header, we get a compile-time error, which is also necessary because the compiler has no way of deciding whether to use SO_TIMESTAMP_OLD or SO_TIMESTAMP_NEW
in that case].

If the application is built with a 32-bit time_t, or with on a 64-bit architecture (all of which have 64-bit time_t and __kernel_long_t), or on x32 (which also has 64-bit time_t and __kernel_long_t), the result is SO_TIMESTAMP_OLD, so we tell the kernel
to send back a timestamp in the old format, and everything works as it did before.

The only thing that changes is 32-bit user space (other than x32) with a 64-bit time_t. In this case, the application expects a structure that corresponds to the new sock_timeval (which is compatible with the user space timeval based on 64-bit time_t), so we must use the new constant in order to tell the kernel which one we want.

Arnd

#29 lore raw

Re: [PATCH 7/8] socket: Add SO_TIMESTAMP[NS]_NEW

Quoted 51 lines
Quoted 26 lines
Quoted 11 lines

The existing timestamp options: SO_TIMESTAMP* fail to provide proper timestamps beyond year 2038 on 32 bit ABIs.
But, these work fine on 64 bit native ABIs.
So now we need a way of updating these timestamps so that we do not break existing userspace: 64 bit ABIs should not have to change userspace, 32 bit ABIs should work as is until 2038 after which they have bad timestamps.
So we introduce new y2038 safe timestamp options for 32 bit ABIs. We assume that 32 bit applications will switch to new ABIs at some point, but leave the older timestamps as is.
I can update the commit text as per above.

So on 32-bit platforms SO_TIMESTAMP_NEW introduces a new struct sock_timeval with both 64-bit fields.

Does this not break existing applications that compile against SO_TIMESTAMP and expect struct timeval? For one example, the selftests under tools/testing.

The kernel will now convert SO_TIMESTAMP (previously constant 29) to different SO_TIMESTAMP_NEW (62) and returns a different struct. Perhaps with a library like libc in the middle this can be fixed up transparently, but for
applications that don't have a more recent libc or use a library at all, it breaks
the ABI.

Quoted 2 lines

I suspect that these finer ABI points may have been discussed outside the narrow confines of socket timestamping. But on its own, this does worry me.

The entire purpose of the complexities in the patch set is to not break the user space ABI after an application gets recompiled with a 64-bit time_t defined by a new libc version:

#define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? \
SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)

This delays the evaluation of SO_TIMESTAMP to the point where it is first used, the assumption being that at this point we have included the libc header file that defines both 'time_t' and 'struct timeval'. [If we have not included that header, we get a compile-time error, which is also necessary because the compiler has no way of deciding whether to use SO_TIMESTAMP_OLD or SO_TIMESTAMP_NEW
in that case].

If the application is built with a 32-bit time_t, or with on a 64-bit architecture (all of which have 64-bit time_t and __kernel_long_t), or on x32 (which also has 64-bit time_t and __kernel_long_t), the result is SO_TIMESTAMP_OLD, so we tell the kernel
to send back a timestamp in the old format, and everything works as it did before.

Quoted 5 lines

The only thing that changes is 32-bit user space (other than x32) with a 64-bit time_t. In this case, the application expects a structure that corresponds to the new sock_timeval (which is compatible with the user space timeval based on 64-bit time_t), so we must use the new constant in order to tell the kernel which one we want.

Thanks. That was exactly the context that I was missing. I hadn't figured out that the test was based on a libc definition. This all makes perfect sense.

#30 lore raw

Re: [PATCH 7/8] socket: Add SO_TIMESTAMP[NS]_NEW

In reply to Willem de Bruijn
Quoted 14 lines · Willem de Bruijn
Quoted 12 lines · Deepa Dinamani
Quoted 11 lines
Quoted 11 lines

net/core/sock.c static void setsockopt_timestamp(struct sock *sk, int type, int val) · line 663

Quoted 6 lines
net/core/sock.c +5 -0
+       if (type == SO_TIMESTAMP_NEW || type == SO_TIMESTAMPNS_NEW)
+               sock_set_flag(sk, SOCK_TSTAMP_NEW);
+       else
+               sock_reset_flag(sk, SOCK_TSTAMP_NEW);
+

if adding a boolean whether the socket uses new or old-style timestamps, perhaps fail hard if a process tries to set a new-style option while an old-style is already set and vice versa. Also include SO_TIMESTAMPING_NEW as it toggles the same option.

Quoted 5 lines
Quoted 3 lines

I do not think this is a problem.
Consider this example, if there is a user application with updated socket timestamps is linking into a library that is yet to be updated.

Also consider applications that do not use libraries.

Arnd and I talked about this.
We thought that the new options should behave like the already existing options. The patch already does this.
Eg: Today if we set SO_TIMESTAMP and then try to switch to SO_TIMESTAMPNS then there is no fail.

Do you still want a hard fail?

-Deepa

#31 lore raw

Re: [PATCH 7/8] socket: Add SO_TIMESTAMP[NS]_NEW

Quoted 23 lines · Deepa Dinamani
Quoted 14 lines · Willem de Bruijn
Quoted 12 lines · Deepa Dinamani
Quoted 11 lines
Quoted 11 lines

net/core/sock.c static void setsockopt_timestamp(struct sock *sk, int type, int val) · line 663

Quoted 6 lines
net/core/sock.c +5 -0
+       if (type == SO_TIMESTAMP_NEW || type == SO_TIMESTAMPNS_NEW)
+               sock_set_flag(sk, SOCK_TSTAMP_NEW);
+       else
+               sock_reset_flag(sk, SOCK_TSTAMP_NEW);
+

if adding a boolean whether the socket uses new or old-style timestamps, perhaps fail hard if a process tries to set a new-style option while an old-style is already set and vice versa. Also include SO_TIMESTAMPING_NEW as it toggles the same option.

Quoted 5 lines
Quoted 3 lines

I do not think this is a problem.
Consider this example, if there is a user application with updated socket timestamps is linking into a library that is yet to be updated.

Also consider applications that do not use libraries.

Quoted 7 lines

Arnd and I talked about this.
We thought that the new options should behave like the already existing options. The patch already does this.
Eg: Today if we set SO_TIMESTAMP and then try to switch to SO_TIMESTAMPNS then there is no fail.

Do you still want a hard fail?

I do think that it is preferable. In general, and in this specific case.

We have had had many bug reports from syzkaller where the fuzzer manages to trigger unexpected behavior by combining two APIs that were never intended to be used together.

However inane the combination may be, once an API is published, we cannot simply add an EINVAL and stop supporting it. So it is safer to explicitly block unsafe combinations from the start. If there is a legitimate use it is always possible to loosen that restriction later.

I don't see any sensible use for mixing both the old and the new interface on the same socket.

That said, just a suggestion.
_______________________________________________
Y2038 mailing list
[email protected]
https://lists.linaro.org/mailman/listinfo/y2038

#32 lore raw

PATCH 8/8 socket: Add SO_TIMESTAMPING_NEW

In reply to Deepa Dinamani

Add SO_TIMESTAMPING_NEW variant of socket timestamp options. This is the y2038 safe versions of the SO_TIMESTAMPING_OLD for all architectures.

---
 arch/alpha/include/uapi/asm/socket.h  |  5 +-
 arch/mips/include/uapi/asm/socket.h   |  5 +-
 arch/parisc/include/uapi/asm/socket.h |  5 +-
 arch/sparc/include/uapi/asm/socket.h  |  8 +--
 include/linux/socket.h                |  7 +++
 include/uapi/asm-generic/socket.h     |  5 +-
 include/uapi/linux/errqueue.h         |  4 ++
 net/core/scm.c                        | 27 ++++++++++
 net/core/sock.c                       | 73 +++++++++++++++------------
 net/ipv4/tcp.c                        | 29 ++++++-----
 net/smc/af_smc.c                      |  3 +-
 net/socket.c                          | 16 +++---
 12 files changed, 122 insertions(+), 65 deletions(-)
arch/alpha/include/uapi/asm/socket.h +3 -2
index 352e3dc0b3d9..8b9f6f7f8087 100644
@@ -116,19 +116,20 @@
 
 #define SO_TIMESTAMP_NEW         62
 #define SO_TIMESTAMPNS_NEW       63
+#define SO_TIMESTAMPING_NEW      64
 
 #if !defined(__KERNEL__)
 
 #if __BITS_PER_LONG == 64
 #define SO_TIMESTAMP		SO_TIMESTAMP_OLD
 #define SO_TIMESTAMPNS		SO_TIMESTAMPNS_OLD
+#define SO_TIMESTAMPING		SO_TIMESTAMPING_OLD
 #else
 #define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)
 #define SO_TIMESTAMPNS (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPNS_OLD : SO_TIMESTAMPNS_NEW)
+#define SO_TIMESTAMPING (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPING_OLD : SO_TIMESTAMPING_NEW)
 #endif
 
-#define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
-
 #define SCM_TIMESTAMP          SO_TIMESTAMP
 #define SCM_TIMESTAMPNS        SO_TIMESTAMPNS
 #define SCM_TIMESTAMPING       SO_TIMESTAMPING
arch/mips/include/uapi/asm/socket.h +3 -2
index d1752e3f1248..9fc80c5d54e4 100644
@@ -126,19 +126,20 @@
 
 #define SO_TIMESTAMP_NEW         62
 #define SO_TIMESTAMPNS_NEW       63
+#define SO_TIMESTAMPING_NEW      64
 
 #if !defined(__KERNEL__)
 
 #if __BITS_PER_LONG == 64
 #define SO_TIMESTAMP		SO_TIMESTAMP_OLD
 #define SO_TIMESTAMPNS		SO_TIMESTAMPNS_OLD
+#define SO_TIMESTAMPING		SO_TIMESTAMPING_OLD
 #else
 #define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)
 #define SO_TIMESTAMPNS (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPNS_OLD : SO_TIMESTAMPNS_NEW)
+#define SO_TIMESTAMPING (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPING_OLD : SO_TIMESTAMPING_NEW)
 #endif
 
-#define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
-
 #define SCM_TIMESTAMP          SO_TIMESTAMP
 #define SCM_TIMESTAMPNS        SO_TIMESTAMPNS
 #define SCM_TIMESTAMPING       SO_TIMESTAMPING
arch/parisc/include/uapi/asm/socket.h +3 -2
index 0a45b668abd1..82f1c9447d6b 100644
@@ -107,19 +107,20 @@
 
 #define SO_TIMESTAMP_NEW         0x4037
 #define SO_TIMESTAMPNS_NEW       0x4038
+#define SO_TIMESTAMPING_NEW      0x4039
 
 #if !defined(__KERNEL__)
 
 #if __BITS_PER_LONG == 64
 #define SO_TIMESTAMP		SO_TIMESTAMP_OLD
 #define SO_TIMESTAMPNS		SO_TIMESTAMPNS_OLD
+#define SO_TIMESTAMPING		SO_TIMESTAMPING_OLD
 #else
 #define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)
 #define SO_TIMESTAMPNS (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPNS_OLD : SO_TIMESTAMPNS_NEW)
+#define SO_TIMESTAMPING (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPING_OLD : SO_TIMESTAMPING_NEW)
 #endif
 
-#define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
-
 #define SCM_TIMESTAMP          SO_TIMESTAMP
 #define SCM_TIMESTAMPNS        SO_TIMESTAMPNS
 #define SCM_TIMESTAMPING       SO_TIMESTAMPING
arch/sparc/include/uapi/asm/socket.h +5 -3
index dc8527cae5a7..5bdbb25c28d2 100644
@@ -106,20 +106,22 @@
 #define SO_TIMESTAMPNS_OLD       0x0021
 #define SO_TIMESTAMPING_OLD      0x0023
 
-#define SO_TIMESTAMP_NEW         0x0040
-#define SO_TIMESTAMPNS_NEW       0x0041
+#define SO_TIMESTAMP_NEW         0x0041
+#define SO_TIMESTAMPNS_NEW       0x0042
+#define SO_TIMESTAMPING_NEW      0x0043
 
 #if !defined(__KERNEL__)
 
 #if __BITS_PER_LONG == 64
 #define SO_TIMESTAMP		SO_TIMESTAMP_OLD
 #define SO_TIMESTAMPNS		SO_TIMESTAMPNS_OLD
+#define SO_TIMESTAMPING		SO_TIMESTAMPING_OLD
 #else
 #define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)
 #define SO_TIMESTAMPNS (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPNS_OLD : SO_TIMESTAMPNS_NEW)
+#define SO_TIMESTAMPING (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPING_OLD : SO_TIMESTAMPING_NEW)
 #endif
 
-#define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
 
 #define SCM_TIMESTAMP          SO_TIMESTAMP
 #define SCM_TIMESTAMPNS        SO_TIMESTAMPNS
include/linux/socket.h +7 -0
index 8b571e9b9f76..372fd77698a2 100644
@@ -350,6 +350,13 @@ extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
 
 struct timespec64;
 
+struct scm_timestamping_internal {
+	struct timespec64 ts[3];
+};
+
+extern void put_cmsg_scm_timestamping64(struct msghdr *msg, struct scm_timestamping_internal *tss);
+extern void put_cmsg_scm_timestamping(struct msghdr *msg, struct scm_timestamping_internal *tss);
+
 /* The __sys_...msg variants allow MSG_CMSG_COMPAT iff
  * forbid_cmsg_compat==false
  */
include/uapi/asm-generic/socket.h +3 -2
index 0b0fae6b57a9..2fdfb6126246 100644
@@ -110,6 +110,7 @@
 
 #define SO_TIMESTAMP_NEW         62
 #define SO_TIMESTAMPNS_NEW       63
+#define SO_TIMESTAMPING_NEW         64
 
 #if !defined(__KERNEL__)
 
@@ -117,13 +118,13 @@
 /* on 64-bit and x32, avoid the ?: operator */
 #define SO_TIMESTAMP		SO_TIMESTAMP_OLD
 #define SO_TIMESTAMPNS		SO_TIMESTAMPNS_OLD
+#define SO_TIMESTAMPING		SO_TIMESTAMPING_OLD
 #else
 #define SO_TIMESTAMP (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMP_OLD : SO_TIMESTAMP_NEW)
 #define SO_TIMESTAMPNS (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPNS_OLD : SO_TIMESTAMPNS_NEW)
+#define SO_TIMESTAMPING (sizeof(time_t) == sizeof(__kernel_long_t) ? SO_TIMESTAMPING_OLD : SO_TIMESTAMPING_NEW)
 #endif
 
-#define SO_TIMESTAMPING        SO_TIMESTAMPING_OLD
-
 #define SCM_TIMESTAMP          SO_TIMESTAMP
 #define SCM_TIMESTAMPNS        SO_TIMESTAMPNS
 #define SCM_TIMESTAMPING       SO_TIMESTAMPING
include/uapi/linux/errqueue.h +4 -0
index c0151200f7d1..d955b9e32288 100644
@@ -41,6 +41,10 @@ struct scm_timestamping {
 	struct timespec ts[3];
 };
 
+struct scm_timestamping64 {
+	struct __kernel_timespec ts[3];
+};
+
 /* The type of scm_timestamping, passed in sock_extended_err ee_info.
  * This defines the type of ts[0]. For SCM_TSTAMP_SND only, if ts[0]
  * is zero, then this is a hardware timestamp and recorded in ts[2].
net/core/scm.c +27 -0
index b1ff8a441748..52ef219cf6df 100644
@@ -29,6 +29,7 @@
 #include <linux/pid.h>
 #include <linux/nsproxy.h>
 #include <linux/slab.h>
+#include <linux/errqueue.h>
 
 #include <linux/uaccess.h>
 
@@ -252,6 +253,32 @@ int put_cmsg(struct msghdr * msg, int level, int type, int len, void *data)
 }
 EXPORT_SYMBOL(put_cmsg);
 
+void put_cmsg_scm_timestamping64(struct msghdr *msg, struct scm_timestamping_internal *tss_internal)
+{
+	struct scm_timestamping64 tss;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(tss.ts); i++) {
+		tss.ts[i].tv_sec = tss_internal->ts[i].tv_sec;
+		tss.ts[i].tv_nsec = tss_internal->ts[i].tv_nsec;
+	}
+
+	put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPING_NEW, sizeof(tss), &tss);
+}
+EXPORT_SYMBOL(put_cmsg_scm_timestamping64);
+
+void put_cmsg_scm_timestamping(struct msghdr *msg, struct scm_timestamping_internal *tss_internal)
+{
+	struct scm_timestamping tss;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(tss.ts); i++)
+		tss.ts[i] = timespec64_to_timespec(tss_internal->ts[i]);
+
+	put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPING_OLD, sizeof(tss), &tss);
+}
+EXPORT_SYMBOL(put_cmsg_scm_timestamping);
+
 void scm_detach_fds(struct msghdr *msg, struct scm_cookie *scm)
 {
 	struct cmsghdr __user *cm
net/core/sock.c +40 -33

85 lines not on this page · raw message

net/ipv4/tcp.c +15 -14
index b470f470343a..09ef0d8141fb 100644
@@ -1847,17 +1847,17 @@ static int tcp_zerocopy_receive(struct sock *sk,
 #endif
 
 static void tcp_update_recv_tstamps(struct sk_buff *skb,
-				    struct scm_timestamping *tss)
+				    struct scm_timestamping_internal *tss)
 {
 	if (skb->tstamp)
-		tss->ts[0] = ktime_to_timespec(skb->tstamp);
+		tss->ts[0] = ktime_to_timespec64(skb->tstamp);
 	else
-		tss->ts[0] = (struct timespec) {0};
+		tss->ts[0] = (struct timespec64) {0};
 
 	if (skb_hwtstamps(skb)->hwtstamp)
-		tss->ts[2] = ktime_to_timespec(skb_hwtstamps(skb)->hwtstamp);
+		tss->ts[2] = ktime_to_timespec64(skb_hwtstamps(skb)->hwtstamp);
 	else
-		tss->ts[2] = (struct timespec) {0};
+		tss->ts[2] = (struct timespec64) {0};
 }
 
 static void tcp_recv_sw_timestamp(struct msghdr *msg, const struct sock *sk, struct timespec64 *ts)
@@ -1900,29 +1900,30 @@ static void tcp_recv_sw_timestamp(struct msghdr *msg, const struct sock *sk, str
 
 /* Similar to __sock_recv_timestamp, but does not require an skb */
 static void tcp_recv_timestamp(struct msghdr *msg, const struct sock *sk,
-			       struct scm_timestamping *tss)
+			       struct scm_timestamping_internal *tss)
 {
 	bool has_timestamping = false;
-	struct timespec64 ts = timespec_to_timespec64(tss->ts[0]);
 
-	tcp_recv_sw_timestamp(msg, sk, &ts);
+	tcp_recv_sw_timestamp(msg, sk, &tss->ts[0]);
 
 	if (sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE)
 		has_timestamping = true;
 	else
-		tss->ts[0] = (struct timespec) {0};
+		tss->ts[0] = (struct timespec64) {0};
 
 	if (tss->ts[2].tv_sec || tss->ts[2].tv_nsec) {
 		if (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE)
 			has_timestamping = true;
 		else
-			tss->ts[2] = (struct timespec) {0};
+			tss->ts[2] = (struct timespec64) {0};
 	}
 
 	if (has_timestamping) {
-		tss->ts[1] = (struct timespec) {0};
-		put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPING_OLD,
-			 sizeof(*tss), tss);
+		tss->ts[1] = (struct timespec64) {0};
+		if (sock_flag(sk, SOCK_TSTAMP_NEW))
+			put_cmsg_scm_timestamping64(msg, tss);
+		else
+			put_cmsg_scm_timestamping(msg, tss);
 	}
 }
 
@@ -1963,7 +1964,7 @@ int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
 	long timeo;
 	struct sk_buff *skb, *last;
 	u32 urg_hole = 0;
-	struct scm_timestamping tss;
+	struct scm_timestamping_internal tss;
 	bool has_tss = false;
 	bool has_cmsg;
 
net/smc/af_smc.c +2 -1
index 80e2119f1c70..e588305e9cf4 100644
@@ -280,7 +280,8 @@ static void smc_copy_sock_settings(struct sock *nsk, struct sock *osk,
 			     (1UL << SOCK_RXQ_OVFL) | \
 			     (1UL << SOCK_WIFI_STATUS) | \
 			     (1UL << SOCK_NOFCS) | \
-			     (1UL << SOCK_FILTER_LOCKED))
+			     (1UL << SOCK_FILTER_LOCKED) | \
+			     (1UL << SOCK_TSTAMP_NEW))
 /* copy only relevant settings and flags of SOL_SOCKET level from smc to
  * clc socket (since smc is not called for these options from net/core)
  */
net/socket.c +10 -6
index 9abeb6bc9cfe..14fa6febfc3d 100644
@@ -731,6 +731,7 @@ static void sock_recv_sw_timestamp(struct msghdr *msg, struct sock *sk,
 			 sizeof(ts), &ts);
 	}
 }
+
 /*
  * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
  * or sock_flag(sk, SOCK_RCVTSTAMPNS)
@@ -739,8 +740,8 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
 	struct sk_buff *skb)
 {
 	int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP) || sock_flag(sk, SOCK_RCVTSTAMPNS);
-	struct scm_timestamping tss;
-	int empty = 1, false_tstamp = 0;
+	struct scm_timestamping_internal tss;
+	int empty = 1, false_tstamp = 0, new_tstamp = 0;
 	struct skb_shared_hwtstamps *shhwtstamps =
 		skb_hwtstamps(skb);
 
@@ -756,20 +757,23 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
 
 	memset(&tss, 0, sizeof(tss));
 	if ((sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) &&
-	    ktime_to_timespec_cond(skb->tstamp, tss.ts + 0))
+	    ktime_to_timespec64_cond(skb->tstamp, tss.ts + 0))
 		empty = 0;
 	if (shhwtstamps &&
 	    (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
 	    !skb_is_swtx_tstamp(skb, false_tstamp) &&
-	    ktime_to_timespec_cond(shhwtstamps->hwtstamp, tss.ts + 2)) {
+	    ktime_to_timespec64_cond(shhwtstamps->hwtstamp, tss.ts + 2)) {
 		empty = 0;
 		if ((sk->sk_tsflags & SOF_TIMESTAMPING_OPT_PKTINFO) &&
 		    !skb_is_err_queue(skb))
 			put_ts_pktinfo(msg, skb);
 	}
 	if (!empty) {
-		put_cmsg(msg, SOL_SOCKET,
-			 SO_TIMESTAMPING_OLD, sizeof(tss), &tss);
+		new_tstamp = sock_flag(sk, SOCK_TSTAMP_NEW);
+		if (new_tstamp)
+			put_cmsg_scm_timestamping64(msg, &tss);
+		else
+			put_cmsg_scm_timestamping(msg, &tss);
 
 		if (skb_is_err_queue(skb) && skb->len &&
 		    SKB_EXT_ERR(skb)->opt_stats)
Signature · 1 line
2.17.1
#33 lore raw

Re: [PATCH 8/8] socket: Add SO_TIMESTAMPING_NEW

Quoted 46 lines · Deepa Dinamani

Add SO_TIMESTAMPING_NEW variant of socket timestamp options. This is the y2038 safe versions of the SO_TIMESTAMPING_OLD for all architectures.

---

/*
* called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
* or sock_flag(sk, SOCK_RCVTSTAMPNS)

net/socket.c +4 -4
@@ -739,8 +740,8 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
        struct sk_buff *skb)
 {
        int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP) || sock_flag(sk, SOCK_RCVTSTAMPNS);
-       struct scm_timestamping tss;
-       int empty = 1, false_tstamp = 0;
+       struct scm_timestamping_internal tss;
+       int empty = 1, false_tstamp = 0, new_tstamp = 0;
        struct skb_shared_hwtstamps *shhwtstamps =
                skb_hwtstamps(skb);
 
@@ -756,20 +757,23 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
 
        memset(&tss, 0, sizeof(tss));
        if ((sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) &&
-           ktime_to_timespec_cond(skb->tstamp, tss.ts + 0))
+           ktime_to_timespec64_cond(skb->tstamp, tss.ts + 0))
                empty = 0;
        if (shhwtstamps &&
            (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
            !skb_is_swtx_tstamp(skb, false_tstamp) &&
-           ktime_to_timespec_cond(shhwtstamps->hwtstamp, tss.ts + 2)) {
+           ktime_to_timespec64_cond(shhwtstamps->hwtstamp, tss.ts + 2)) {

net/socket.c void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, · line 773

Quoted 10 lines
net/socket.c +2 -2
                empty = 0;
                if ((sk->sk_tsflags & SOF_TIMESTAMPING_OPT_PKTINFO) &&
                    !skb_is_err_queue(skb))
                        put_ts_pktinfo(msg, skb);
        }
        if (!empty) {
-               put_cmsg(msg, SOL_SOCKET,
-                        SO_TIMESTAMPING_OLD, sizeof(tss), &tss);
+               new_tstamp = sock_flag(sk, SOCK_TSTAMP_NEW);
+               if (new_tstamp)

nit: no need for explicit variable

Quoted 9 lines
net/socket.c +3 -1
+                       put_cmsg_scm_timestamping64(msg, &tss);
+               else
+                       put_cmsg_scm_timestamping(msg, &tss);
 
                if (skb_is_err_queue(skb) && skb->len &&
                    SKB_EXT_ERR(skb)->opt_stats)
--

2.17.1

#34 lore raw

Re: [PATCH 8/8] socket: Add SO_TIMESTAMPING_NEW

Quoted 4 lines

net/socket.c void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, · line 773

Quoted 2 lines
net/socket.c +2 -0
+               new_tstamp = sock_flag(sk, SOCK_TSTAMP_NEW);
+               if (new_tstamp)

nit: no need for explicit variable

Sure, will drop it.

-Deepa