Message ID | 20220128175043.161446-4-adhemerval.zanella@linaro.org |
---|---|
State | New |
Headers | show |
Series | Fix socket ancillary timestamp on 32 bit time_t ABIs | expand |
* Adhemerval Zanella: > The timestamps created by __convert_scm_timestamps only make sense for > 64 bit time_t programs, 32 bit time_t programs will ignore 64 bit time_t > timestamps since SO_TIMESTAMP will be defined to old values (either by > glibc or kernel headers). > > Worse, if the buffer is not suffice MSG_CTRUNC is set to indicate it > (which breaks some programs [1]). > > This patch makes only 64 bit time_t recvmsg and recvmmsg to call > __convert_scm_timestamps. Also, the assumption to called it is changed > from __ASSUME_TIME64_SYSCALLS to __TIMESIZE != 64 since the setsockopt > might be called by libraries built without __TIME_BITS=64. The > MSG_CTRUNC is only set for the 64 bit symbols, it should happen only > if 64 bit time_t programs run older kernels. > > Checked on x86_64-linux-gnu and i686-linux-gnu. > > [1] https://github.com/systemd/systemd/pull/20567 > --- > include/sys/socket.h | 10 +- > sysdeps/unix/sysv/linux/Makefile | 10 +- > sysdeps/unix/sysv/linux/recvmmsg.c | 45 ++- > sysdeps/unix/sysv/linux/recvmsg.c | 34 ++- > .../tst-socket-timestamp-compat-time64.c | 1 + > .../sysv/linux/tst-socket-timestamp-compat.c | 265 ++++++++++++++++++ > 6 files changed, 336 insertions(+), 29 deletions(-) > create mode 100644 sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c > create mode 100644 sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c Looks okay. Reviewed-by: Florian Weimer <fweimer@redhat.com> Thanks, Florian
On 1/28/22 13:19, Florian Weimer via Libc-alpha wrote: > * Adhemerval Zanella: > >> The timestamps created by __convert_scm_timestamps only make sense for >> 64 bit time_t programs, 32 bit time_t programs will ignore 64 bit time_t >> timestamps since SO_TIMESTAMP will be defined to old values (either by >> glibc or kernel headers). >> >> Worse, if the buffer is not suffice MSG_CTRUNC is set to indicate it >> (which breaks some programs [1]). >> >> This patch makes only 64 bit time_t recvmsg and recvmmsg to call >> __convert_scm_timestamps. Also, the assumption to called it is changed >> from __ASSUME_TIME64_SYSCALLS to __TIMESIZE != 64 since the setsockopt >> might be called by libraries built without __TIME_BITS=64. The >> MSG_CTRUNC is only set for the 64 bit symbols, it should happen only >> if 64 bit time_t programs run older kernels. >> >> Checked on x86_64-linux-gnu and i686-linux-gnu. >> >> [1] https://github.com/systemd/systemd/pull/20567 >> --- >> include/sys/socket.h | 10 +- >> sysdeps/unix/sysv/linux/Makefile | 10 +- >> sysdeps/unix/sysv/linux/recvmmsg.c | 45 ++- >> sysdeps/unix/sysv/linux/recvmsg.c | 34 ++- >> .../tst-socket-timestamp-compat-time64.c | 1 + >> .../sysv/linux/tst-socket-timestamp-compat.c | 265 ++++++++++++++++++ >> 6 files changed, 336 insertions(+), 29 deletions(-) >> create mode 100644 sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c >> create mode 100644 sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c > > Looks okay. > > Reviewed-by: Florian Weimer <fweimer@redhat.com> OK to push for glibc 2.35. This fixes a blocker for the release.
On Fri, Jan 28, 2022 at 9:57 AM Adhemerval Zanella via Libc-alpha <libc-alpha@sourceware.org> wrote: > > The timestamps created by __convert_scm_timestamps only make sense for > 64 bit time_t programs, 32 bit time_t programs will ignore 64 bit time_t > timestamps since SO_TIMESTAMP will be defined to old values (either by > glibc or kernel headers). > > Worse, if the buffer is not suffice MSG_CTRUNC is set to indicate it > (which breaks some programs [1]). > > This patch makes only 64 bit time_t recvmsg and recvmmsg to call > __convert_scm_timestamps. Also, the assumption to called it is changed > from __ASSUME_TIME64_SYSCALLS to __TIMESIZE != 64 since the setsockopt > might be called by libraries built without __TIME_BITS=64. The > MSG_CTRUNC is only set for the 64 bit symbols, it should happen only > if 64 bit time_t programs run older kernels. > > Checked on x86_64-linux-gnu and i686-linux-gnu. > > [1] https://github.com/systemd/systemd/pull/20567 > --- > include/sys/socket.h | 10 +- > sysdeps/unix/sysv/linux/Makefile | 10 +- > sysdeps/unix/sysv/linux/recvmmsg.c | 45 ++- > sysdeps/unix/sysv/linux/recvmsg.c | 34 ++- > .../tst-socket-timestamp-compat-time64.c | 1 + > .../sysv/linux/tst-socket-timestamp-compat.c | 265 ++++++++++++++++++ > 6 files changed, 336 insertions(+), 29 deletions(-) > create mode 100644 sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c > create mode 100644 sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c > > diff --git a/include/sys/socket.h b/include/sys/socket.h > index a1d749f9fa..6e4cf5077f 100644 > --- a/include/sys/socket.h > +++ b/include/sys/socket.h > @@ -98,15 +98,21 @@ extern int __sendmmsg (int __fd, struct mmsghdr *__vmessages, > libc_hidden_proto (__sendmmsg) > #endif > > -/* Receive a message as described by MESSAGE from socket FD. > - Returns the number of bytes read or -1 for errors. */ > extern ssize_t __libc_recvmsg (int __fd, struct msghdr *__message, > int __flags); > extern ssize_t __recvmsg (int __fd, struct msghdr *__message, > int __flags) attribute_hidden; > #if __TIMESIZE == 64 > +# define __libc_recvmsg64 __libc_recvmsg > +# define __recvmsg64 __recvmsg > # define __recvmmsg64 __recvmmsg > #else > +extern ssize_t __libc_recvmsg64 (int __fd, struct msghdr *__message, > + int __flags); > +extern ssize_t __recvmsg64 (int __fd, struct msghdr *__message, > + int __flags); > +/* Receive a message as described by MESSAGE from socket FD. > + Returns the number of bytes read or -1 for errors. */ > extern int __recvmmsg64 (int __fd, struct mmsghdr *vmessages, > unsigned int vlen, int flags, > struct __timespec64 *timeout); > diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile > index 4c80ff809c..7122f55975 100644 > --- a/sysdeps/unix/sysv/linux/Makefile > +++ b/sysdeps/unix/sysv/linux/Makefile > @@ -277,8 +277,14 @@ sysdep_routines += cmsg_nxthdr > CFLAGS-recvmmsg.c = -fexceptions -fasynchronous-unwind-tables > CFLAGS-sendmmsg.c = -fexceptions -fasynchronous-unwind-tables > > -tests += tst-socket-timestamp > -tests-time64 += tst-socket-timestamp-time64 > +tests += \ > + tst-socket-timestamp \ > + tst-socket-timestamp-compat \ > + # tests > +tests-time64 += \ > + tst-socket-timestamp-time64 \ > + tst-socket-timestamp-compat-time64 > + # tests-time64 > > tests-special += $(objpfx)tst-socket-consts.out > $(objpfx)tst-socket-consts.out: ../sysdeps/unix/sysv/linux/tst-socket-consts.py > diff --git a/sysdeps/unix/sysv/linux/recvmmsg.c b/sysdeps/unix/sysv/linux/recvmmsg.c > index 3b9b5f9d1f..1943b9b3d4 100644 > --- a/sysdeps/unix/sysv/linux/recvmmsg.c > +++ b/sysdeps/unix/sysv/linux/recvmmsg.c > @@ -19,9 +19,9 @@ > #include <sysdep.h> > #include <socketcall.h> > > -int > -__recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, > - struct __timespec64 *timeout) > +static int > +recvmmsg_syscall (int fd, struct mmsghdr *vmessages, unsigned int vlen, > + int flags, struct __timespec64 *timeout) > { > #ifndef __NR_recvmmsg_time64 > # define __NR_recvmmsg_time64 __NR_recvmmsg > @@ -44,12 +44,6 @@ __recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, > pts32 = &ts32; > } > > - socklen_t csize[IOV_MAX]; > - if (vlen > IOV_MAX) > - vlen = IOV_MAX; > - for (int i = 0; i < vlen; i++) > - csize[i] = vmessages[i].msg_hdr.msg_controllen; > - > # ifdef __ASSUME_RECVMMSG_SYSCALL > r = SYSCALL_CANCEL (recvmmsg, fd, vmessages, vlen, flags, pts32); > # else > @@ -59,11 +53,31 @@ __recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, > { > if (timeout != NULL) > *timeout = valid_timespec_to_timespec64 (ts32); > + } > +#endif > + return r; > +} > + > +int > +__recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, > + struct __timespec64 *timeout) > +{ > +#if __TIMESIZE != 64 > + socklen_t csize[IOV_MAX]; > + if (vlen > IOV_MAX) > + vlen = IOV_MAX; > + for (int i = 0; i < vlen; i++) > + csize[i] = vmessages[i].msg_hdr.msg_controllen; > +#endif > > + int r = recvmmsg_syscall (fd, vmessages, vlen, flags, timeout); > +#if __TIMESIZE != 64 > + if (r > 0) > + { > for (int i=0; i < r; i++) > __convert_scm_timestamps (&vmessages[i].msg_hdr, csize[i]); > } > -#endif /* __ASSUME_TIME64_SYSCALLS */ > +#endif > return r; > } > #if __TIMESIZE != 64 > @@ -79,10 +93,13 @@ __recvmmsg (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, > ts64 = valid_timespec_to_timespec64 (*timeout); > pts64 = &ts64; > } > - int r = __recvmmsg64 (fd, vmessages, vlen, flags, pts64); > - if (r >= 0 && timeout != NULL) > - /* The remanining timeout will be always less the input TIMEOUT. */ > - *timeout = valid_timespec64_to_timespec (ts64); > + int r = recvmmsg_syscall (fd, vmessages, vlen, flags, pts64); > + if (r >= 0) > + { > + /* The remanining timeout will be always less the input TIMEOUT. */ > + if (timeout != NULL) > + *timeout = valid_timespec64_to_timespec (ts64); > + } > return r; > } > #endif > diff --git a/sysdeps/unix/sysv/linux/recvmsg.c b/sysdeps/unix/sysv/linux/recvmsg.c > index 53e567ed31..401d415b2c 100644 > --- a/sysdeps/unix/sysv/linux/recvmsg.c > +++ b/sysdeps/unix/sysv/linux/recvmsg.c > @@ -20,29 +20,41 @@ > #include <sysdep-cancel.h> > #include <socketcall.h> > > +static int > +__recvmsg_syscall (int fd, struct msghdr *msg, int flags) > +{ > +#ifdef __ASSUME_RECVMSG_SYSCALL > + return SYSCALL_CANCEL (recvmsg, fd, msg, flags); > +#else > + return SOCKETCALL_CANCEL (recvmsg, fd, msg, flags); > +#endif > +} > + > ssize_t > -__libc_recvmsg (int fd, struct msghdr *msg, int flags) > +__libc_recvmsg64 (int fd, struct msghdr *msg, int flags) > { > ssize_t r; > -#ifndef __ASSUME_TIME64_SYSCALLS > +#if __TIMESIZE != 64 > socklen_t orig_controllen = msg != NULL ? msg->msg_controllen : 0; > #endif > > -#ifdef __ASSUME_RECVMSG_SYSCALL > - r = SYSCALL_CANCEL (recvmsg, fd, msg, flags); > -#else > - r = SOCKETCALL_CANCEL (recvmsg, fd, msg, flags); > -#endif > + r = __recvmsg_syscall (fd, msg, flags); > > -#ifndef __ASSUME_TIME64_SYSCALLS > +#if __TIMESIZE != 64 > if (r >= 0 && orig_controllen != 0) > __convert_scm_timestamps (msg, orig_controllen); > #endif > > return r; > } > -weak_alias (__libc_recvmsg, recvmsg) > -weak_alias (__libc_recvmsg, __recvmsg) > #if __TIMESIZE != 64 > -weak_alias (__recvmsg, __recvmsg64) > +weak_alias (__libc_recvmsg64, __recvmsg64) > + > +ssize_t > +__libc_recvmsg (int fd, struct msghdr *msg, int flags) > +{ > + return __recvmsg_syscall (fd, msg, flags); > +} > #endif > +weak_alias (__libc_recvmsg, recvmsg) > +weak_alias (__libc_recvmsg, __recvmsg) > diff --git a/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c > new file mode 100644 > index 0000000000..96a0bef0bf > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c > @@ -0,0 +1 @@ > +#include "tst-socket-timestamp-compat.c" > diff --git a/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c > new file mode 100644 > index 0000000000..de261dae5a > --- /dev/null > +++ b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c > @@ -0,0 +1,265 @@ > +/* Check recvmsg/recvmmsg 64-bit timestamp support. > + Copyright (C) 2022 Free Software Foundation, Inc. > + This file is part of the GNU C Library. > + > + The GNU C Library is free software; you can redistribute it and/or > + modify it under the terms of the GNU Lesser General Public > + License as published by the Free Software Foundation; either > + version 2.1 of the License, or (at your option) any later version. > + > + The GNU C Library is distributed in the hope that it will be useful, > + but WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + Lesser General Public License for more details. > + > + You should have received a copy of the GNU Lesser General Public > + License along with the GNU C Library; if not, see > + <https://www.gnu.org/licenses/>. */ > + > +#include <arpa/inet.h> > +#include <string.h> > +#include <support/check.h> > +#include <support/xsocket.h> > +#include <support/xunistd.h> > +#include <stdbool.h> > + > +/* AF_INET socket and address used to receive data. */ > +static int srv; > +static struct sockaddr_in srv_addr; > + > +static int > +do_sendto (const struct sockaddr_in *addr, int payload) > +{ > + int s = xsocket (AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0); > + xconnect (s, (const struct sockaddr *) addr, sizeof (*addr)); > + > + xsendto (s, &payload, sizeof (payload), 0, (const struct sockaddr *) addr, > + sizeof (*addr)); > + > + xclose (s); > + > + return 0; > +} > + > +static void > +do_recvmsg_ancillary (bool use_multi_call, struct mmsghdr *mmhdr, > + void *msgbuf, size_t msgbuflen, int exp_payload) > +{ > + int payload; > + struct iovec iov = > + { > + .iov_base = &payload, > + .iov_len = sizeof (payload) > + }; > + mmhdr->msg_hdr.msg_name = NULL; > + mmhdr->msg_hdr.msg_iov = &iov; > + mmhdr->msg_hdr.msg_iovlen = 1; > + mmhdr->msg_hdr.msg_control = msgbuf; > + mmhdr->msg_hdr.msg_controllen = msgbuflen; > + > + int r; > + if (use_multi_call) > + { > + r = recvmmsg (srv, mmhdr, 1, 0, NULL); > + if (r >= 0) > + r = mmhdr->msg_len; > + } > + else > + r = recvmsg (srv, &mmhdr->msg_hdr, 0); > + TEST_COMPARE (r, sizeof (int)); > + TEST_COMPARE (payload, exp_payload); > +} > + > +/* Check if recvmsg create the additional 64 bit timestamp if only 32 bit > + is enabled for 64 bit recvmsg symbol. */ > +static void > +do_test_large_buffer (bool mc) > +{ > + struct mmsghdr mmhdr = { 0 }; > + /* It should be large enought for either timeval/timespec and the > + 64 time type as well. */ > + > + union > + { > + struct cmsghdr cmsghdr; > + char msgbuf[512]; > + } control; > + > + /* Enable 32 bit timeval precision and check if no 64 bit timeval stamp > + is created. */ > + { > + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMP_OLD, &(int){1}, > + sizeof (int)); > + TEST_VERIFY_EXIT (r != -1); > + > + do_sendto (&srv_addr, 42); > + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); > + > + bool found_timestamp = false; > + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); > + cmsg != NULL; > + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) > + { > + if (cmsg->cmsg_level != SOL_SOCKET) > + continue; > + > + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMP_NEW) > + found_timestamp = true; > + else > + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMP_NEW); > + } > + > + TEST_COMPARE (found_timestamp, sizeof (time_t) > 4); > + } > + > + /* Same as before, but for timespec. */ > + { > + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMPNS_OLD, &(int){1}, > + sizeof (int)); > + TEST_VERIFY_EXIT (r != -1); > + > + do_sendto (&srv_addr, 42); > + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); > + > + bool found_timestamp = false; > + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); > + cmsg != NULL; > + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) > + { > + if (cmsg->cmsg_level != SOL_SOCKET) > + continue; > + > + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMPNS_NEW) > + found_timestamp = true; > + else > + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMPNS_NEW); > + } > + > + TEST_COMPARE (found_timestamp, sizeof (time_t) > 4); > + } > +} > + > +/* Check if recvmsg does not create the additional 64 bit timestamp if > + only 32 bit timestamp is enabled if the ancillary buffer is not large > + enought. Also checks if MSG_CTRUNC is set iff for 64 bit recvmsg > + symbol. */ > +static void > +do_test_small_buffer (bool mc) > +{ > + struct mmsghdr mmhdr = { 0 }; > + > + /* Enable 32 bit timeval precision and check if no 64 bit timeval stamp > + is created. */ > + { > + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMP_OLD, &(int){1}, > + sizeof (int)); > + TEST_VERIFY_EXIT (r != -1); > + > + union > + { > + struct cmsghdr cmsghdr; > + char msgbuf[CMSG_SPACE (sizeof (struct timeval))]; > + } control; > + > + do_sendto (&srv_addr, 42); > + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); > + > + bool found_timestamp = false; > + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); > + cmsg != NULL; > + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) > + { > + if (cmsg->cmsg_level != SOL_SOCKET) > + continue; > + > + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMP_NEW) > + found_timestamp = true; > + else > + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMP_NEW); > + } > + > + if (sizeof (time_t) > 4) > + { > + TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC)); > + TEST_COMPARE (found_timestamp, 0); > + } > + else > + { > + TEST_VERIFY (!(mmhdr.msg_hdr.msg_flags & MSG_CTRUNC)); > + TEST_COMPARE (found_timestamp, 0); > + } > + } > + > + /* Same as before, but for timespec. */ > + { > + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMPNS_OLD, &(int){1}, > + sizeof (int)); > + TEST_VERIFY_EXIT (r != -1); > + > + union > + { > + struct cmsghdr cmsghdr; > + char msgbuf[CMSG_SPACE (sizeof (struct timespec))]; > + } control; > + > + do_sendto (&srv_addr, 42); > + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); > + > + bool found_timestamp = false; > + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); > + cmsg != NULL; > + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) > + { > + if (cmsg->cmsg_level != SOL_SOCKET) > + continue; > + > + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMPNS_NEW) > + found_timestamp = true; > + else > + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMPNS_NEW); > + } > + > + if (sizeof (time_t) > 4) > + { > + TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC)); > + TEST_COMPARE (found_timestamp, 0); > + } > + else > + { > + TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC) == 0); > + TEST_COMPARE (found_timestamp, 0); > + } > + } > +} > + > +static int > +do_test (void) > +{ > + /* This test only make sense for ABIs that support 32 bit time_t socket > + timestampss. */ > + if (sizeof (time_t) > 4 && __WORDSIZE == 64) This is wrong for x32 which has 64-bit time_t from day one, but __WORDSIZE is 32. > + return 0; > + > + srv = xsocket (AF_INET, SOCK_DGRAM, 0); > + srv_addr = (struct sockaddr_in) { > + .sin_family = AF_INET, > + .sin_addr = {.s_addr = htonl (INADDR_LOOPBACK) }, > + }; > + xbind (srv, (struct sockaddr *) &srv_addr, sizeof (srv_addr)); > + { > + socklen_t sa_len = sizeof (srv_addr); > + xgetsockname (srv, (struct sockaddr *) &srv_addr, &sa_len); > + TEST_VERIFY (sa_len == sizeof (srv_addr)); > + } > + > + /* Check recvmsg; */ > + do_test_large_buffer (false); > + do_test_small_buffer (false); > + /* Check recvmmsg. */ > + do_test_large_buffer (true); > + do_test_small_buffer (true); > + > + return 0; > +} > + > +#include <support/test-driver.c> > -- > 2.32.0 >
The 01/28/2022 14:50, Adhemerval Zanella via Libc-alpha wrote: > The timestamps created by __convert_scm_timestamps only make sense for > 64 bit time_t programs, 32 bit time_t programs will ignore 64 bit time_t > timestamps since SO_TIMESTAMP will be defined to old values (either by > glibc or kernel headers). > > Worse, if the buffer is not suffice MSG_CTRUNC is set to indicate it > (which breaks some programs [1]). > > This patch makes only 64 bit time_t recvmsg and recvmmsg to call > __convert_scm_timestamps. Also, the assumption to called it is changed > from __ASSUME_TIME64_SYSCALLS to __TIMESIZE != 64 since the setsockopt > might be called by libraries built without __TIME_BITS=64. The > MSG_CTRUNC is only set for the 64 bit symbols, it should happen only > if 64 bit time_t programs run older kernels. > > Checked on x86_64-linux-gnu and i686-linux-gnu. > > [1] https://github.com/systemd/systemd/pull/20567 i think this can cause a build issue on 32bit timesize targets: https://sourceware.org/bugzilla/show_bug.cgi?id=28860
On 03/02/2022 15:34, Szabolcs Nagy wrote: > The 01/28/2022 14:50, Adhemerval Zanella via Libc-alpha wrote: >> The timestamps created by __convert_scm_timestamps only make sense for >> 64 bit time_t programs, 32 bit time_t programs will ignore 64 bit time_t >> timestamps since SO_TIMESTAMP will be defined to old values (either by >> glibc or kernel headers). >> >> Worse, if the buffer is not suffice MSG_CTRUNC is set to indicate it >> (which breaks some programs [1]). >> >> This patch makes only 64 bit time_t recvmsg and recvmmsg to call >> __convert_scm_timestamps. Also, the assumption to called it is changed >> from __ASSUME_TIME64_SYSCALLS to __TIMESIZE != 64 since the setsockopt >> might be called by libraries built without __TIME_BITS=64. The >> MSG_CTRUNC is only set for the 64 bit symbols, it should happen only >> if 64 bit time_t programs run older kernels. >> >> Checked on x86_64-linux-gnu and i686-linux-gnu. >> >> [1] https://github.com/systemd/systemd/pull/20567 > > > i think this can cause a build issue on 32bit timesize targets: > > https://sourceware.org/bugzilla/show_bug.cgi?id=28860 Yeah, I will fix it (the __convert_scm_timestamps should be always be built now instead of just for __ASSUME_TIME64_SYSCALLS).
diff --git a/include/sys/socket.h b/include/sys/socket.h index a1d749f9fa..6e4cf5077f 100644 --- a/include/sys/socket.h +++ b/include/sys/socket.h @@ -98,15 +98,21 @@ extern int __sendmmsg (int __fd, struct mmsghdr *__vmessages, libc_hidden_proto (__sendmmsg) #endif -/* Receive a message as described by MESSAGE from socket FD. - Returns the number of bytes read or -1 for errors. */ extern ssize_t __libc_recvmsg (int __fd, struct msghdr *__message, int __flags); extern ssize_t __recvmsg (int __fd, struct msghdr *__message, int __flags) attribute_hidden; #if __TIMESIZE == 64 +# define __libc_recvmsg64 __libc_recvmsg +# define __recvmsg64 __recvmsg # define __recvmmsg64 __recvmmsg #else +extern ssize_t __libc_recvmsg64 (int __fd, struct msghdr *__message, + int __flags); +extern ssize_t __recvmsg64 (int __fd, struct msghdr *__message, + int __flags); +/* Receive a message as described by MESSAGE from socket FD. + Returns the number of bytes read or -1 for errors. */ extern int __recvmmsg64 (int __fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, struct __timespec64 *timeout); diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile index 4c80ff809c..7122f55975 100644 --- a/sysdeps/unix/sysv/linux/Makefile +++ b/sysdeps/unix/sysv/linux/Makefile @@ -277,8 +277,14 @@ sysdep_routines += cmsg_nxthdr CFLAGS-recvmmsg.c = -fexceptions -fasynchronous-unwind-tables CFLAGS-sendmmsg.c = -fexceptions -fasynchronous-unwind-tables -tests += tst-socket-timestamp -tests-time64 += tst-socket-timestamp-time64 +tests += \ + tst-socket-timestamp \ + tst-socket-timestamp-compat \ + # tests +tests-time64 += \ + tst-socket-timestamp-time64 \ + tst-socket-timestamp-compat-time64 + # tests-time64 tests-special += $(objpfx)tst-socket-consts.out $(objpfx)tst-socket-consts.out: ../sysdeps/unix/sysv/linux/tst-socket-consts.py diff --git a/sysdeps/unix/sysv/linux/recvmmsg.c b/sysdeps/unix/sysv/linux/recvmmsg.c index 3b9b5f9d1f..1943b9b3d4 100644 --- a/sysdeps/unix/sysv/linux/recvmmsg.c +++ b/sysdeps/unix/sysv/linux/recvmmsg.c @@ -19,9 +19,9 @@ #include <sysdep.h> #include <socketcall.h> -int -__recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, - struct __timespec64 *timeout) +static int +recvmmsg_syscall (int fd, struct mmsghdr *vmessages, unsigned int vlen, + int flags, struct __timespec64 *timeout) { #ifndef __NR_recvmmsg_time64 # define __NR_recvmmsg_time64 __NR_recvmmsg @@ -44,12 +44,6 @@ __recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, pts32 = &ts32; } - socklen_t csize[IOV_MAX]; - if (vlen > IOV_MAX) - vlen = IOV_MAX; - for (int i = 0; i < vlen; i++) - csize[i] = vmessages[i].msg_hdr.msg_controllen; - # ifdef __ASSUME_RECVMMSG_SYSCALL r = SYSCALL_CANCEL (recvmmsg, fd, vmessages, vlen, flags, pts32); # else @@ -59,11 +53,31 @@ __recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, { if (timeout != NULL) *timeout = valid_timespec_to_timespec64 (ts32); + } +#endif + return r; +} + +int +__recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, + struct __timespec64 *timeout) +{ +#if __TIMESIZE != 64 + socklen_t csize[IOV_MAX]; + if (vlen > IOV_MAX) + vlen = IOV_MAX; + for (int i = 0; i < vlen; i++) + csize[i] = vmessages[i].msg_hdr.msg_controllen; +#endif + int r = recvmmsg_syscall (fd, vmessages, vlen, flags, timeout); +#if __TIMESIZE != 64 + if (r > 0) + { for (int i=0; i < r; i++) __convert_scm_timestamps (&vmessages[i].msg_hdr, csize[i]); } -#endif /* __ASSUME_TIME64_SYSCALLS */ +#endif return r; } #if __TIMESIZE != 64 @@ -79,10 +93,13 @@ __recvmmsg (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, ts64 = valid_timespec_to_timespec64 (*timeout); pts64 = &ts64; } - int r = __recvmmsg64 (fd, vmessages, vlen, flags, pts64); - if (r >= 0 && timeout != NULL) - /* The remanining timeout will be always less the input TIMEOUT. */ - *timeout = valid_timespec64_to_timespec (ts64); + int r = recvmmsg_syscall (fd, vmessages, vlen, flags, pts64); + if (r >= 0) + { + /* The remanining timeout will be always less the input TIMEOUT. */ + if (timeout != NULL) + *timeout = valid_timespec64_to_timespec (ts64); + } return r; } #endif diff --git a/sysdeps/unix/sysv/linux/recvmsg.c b/sysdeps/unix/sysv/linux/recvmsg.c index 53e567ed31..401d415b2c 100644 --- a/sysdeps/unix/sysv/linux/recvmsg.c +++ b/sysdeps/unix/sysv/linux/recvmsg.c @@ -20,29 +20,41 @@ #include <sysdep-cancel.h> #include <socketcall.h> +static int +__recvmsg_syscall (int fd, struct msghdr *msg, int flags) +{ +#ifdef __ASSUME_RECVMSG_SYSCALL + return SYSCALL_CANCEL (recvmsg, fd, msg, flags); +#else + return SOCKETCALL_CANCEL (recvmsg, fd, msg, flags); +#endif +} + ssize_t -__libc_recvmsg (int fd, struct msghdr *msg, int flags) +__libc_recvmsg64 (int fd, struct msghdr *msg, int flags) { ssize_t r; -#ifndef __ASSUME_TIME64_SYSCALLS +#if __TIMESIZE != 64 socklen_t orig_controllen = msg != NULL ? msg->msg_controllen : 0; #endif -#ifdef __ASSUME_RECVMSG_SYSCALL - r = SYSCALL_CANCEL (recvmsg, fd, msg, flags); -#else - r = SOCKETCALL_CANCEL (recvmsg, fd, msg, flags); -#endif + r = __recvmsg_syscall (fd, msg, flags); -#ifndef __ASSUME_TIME64_SYSCALLS +#if __TIMESIZE != 64 if (r >= 0 && orig_controllen != 0) __convert_scm_timestamps (msg, orig_controllen); #endif return r; } -weak_alias (__libc_recvmsg, recvmsg) -weak_alias (__libc_recvmsg, __recvmsg) #if __TIMESIZE != 64 -weak_alias (__recvmsg, __recvmsg64) +weak_alias (__libc_recvmsg64, __recvmsg64) + +ssize_t +__libc_recvmsg (int fd, struct msghdr *msg, int flags) +{ + return __recvmsg_syscall (fd, msg, flags); +} #endif +weak_alias (__libc_recvmsg, recvmsg) +weak_alias (__libc_recvmsg, __recvmsg) diff --git a/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c new file mode 100644 index 0000000000..96a0bef0bf --- /dev/null +++ b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c @@ -0,0 +1 @@ +#include "tst-socket-timestamp-compat.c" diff --git a/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c new file mode 100644 index 0000000000..de261dae5a --- /dev/null +++ b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c @@ -0,0 +1,265 @@ +/* Check recvmsg/recvmmsg 64-bit timestamp support. + Copyright (C) 2022 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <https://www.gnu.org/licenses/>. */ + +#include <arpa/inet.h> +#include <string.h> +#include <support/check.h> +#include <support/xsocket.h> +#include <support/xunistd.h> +#include <stdbool.h> + +/* AF_INET socket and address used to receive data. */ +static int srv; +static struct sockaddr_in srv_addr; + +static int +do_sendto (const struct sockaddr_in *addr, int payload) +{ + int s = xsocket (AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0); + xconnect (s, (const struct sockaddr *) addr, sizeof (*addr)); + + xsendto (s, &payload, sizeof (payload), 0, (const struct sockaddr *) addr, + sizeof (*addr)); + + xclose (s); + + return 0; +} + +static void +do_recvmsg_ancillary (bool use_multi_call, struct mmsghdr *mmhdr, + void *msgbuf, size_t msgbuflen, int exp_payload) +{ + int payload; + struct iovec iov = + { + .iov_base = &payload, + .iov_len = sizeof (payload) + }; + mmhdr->msg_hdr.msg_name = NULL; + mmhdr->msg_hdr.msg_iov = &iov; + mmhdr->msg_hdr.msg_iovlen = 1; + mmhdr->msg_hdr.msg_control = msgbuf; + mmhdr->msg_hdr.msg_controllen = msgbuflen; + + int r; + if (use_multi_call) + { + r = recvmmsg (srv, mmhdr, 1, 0, NULL); + if (r >= 0) + r = mmhdr->msg_len; + } + else + r = recvmsg (srv, &mmhdr->msg_hdr, 0); + TEST_COMPARE (r, sizeof (int)); + TEST_COMPARE (payload, exp_payload); +} + +/* Check if recvmsg create the additional 64 bit timestamp if only 32 bit + is enabled for 64 bit recvmsg symbol. */ +static void +do_test_large_buffer (bool mc) +{ + struct mmsghdr mmhdr = { 0 }; + /* It should be large enought for either timeval/timespec and the + 64 time type as well. */ + + union + { + struct cmsghdr cmsghdr; + char msgbuf[512]; + } control; + + /* Enable 32 bit timeval precision and check if no 64 bit timeval stamp + is created. */ + { + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMP_OLD, &(int){1}, + sizeof (int)); + TEST_VERIFY_EXIT (r != -1); + + do_sendto (&srv_addr, 42); + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); + + bool found_timestamp = false; + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); + cmsg != NULL; + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) + { + if (cmsg->cmsg_level != SOL_SOCKET) + continue; + + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMP_NEW) + found_timestamp = true; + else + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMP_NEW); + } + + TEST_COMPARE (found_timestamp, sizeof (time_t) > 4); + } + + /* Same as before, but for timespec. */ + { + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMPNS_OLD, &(int){1}, + sizeof (int)); + TEST_VERIFY_EXIT (r != -1); + + do_sendto (&srv_addr, 42); + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); + + bool found_timestamp = false; + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); + cmsg != NULL; + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) + { + if (cmsg->cmsg_level != SOL_SOCKET) + continue; + + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMPNS_NEW) + found_timestamp = true; + else + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMPNS_NEW); + } + + TEST_COMPARE (found_timestamp, sizeof (time_t) > 4); + } +} + +/* Check if recvmsg does not create the additional 64 bit timestamp if + only 32 bit timestamp is enabled if the ancillary buffer is not large + enought. Also checks if MSG_CTRUNC is set iff for 64 bit recvmsg + symbol. */ +static void +do_test_small_buffer (bool mc) +{ + struct mmsghdr mmhdr = { 0 }; + + /* Enable 32 bit timeval precision and check if no 64 bit timeval stamp + is created. */ + { + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMP_OLD, &(int){1}, + sizeof (int)); + TEST_VERIFY_EXIT (r != -1); + + union + { + struct cmsghdr cmsghdr; + char msgbuf[CMSG_SPACE (sizeof (struct timeval))]; + } control; + + do_sendto (&srv_addr, 42); + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); + + bool found_timestamp = false; + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); + cmsg != NULL; + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) + { + if (cmsg->cmsg_level != SOL_SOCKET) + continue; + + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMP_NEW) + found_timestamp = true; + else + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMP_NEW); + } + + if (sizeof (time_t) > 4) + { + TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC)); + TEST_COMPARE (found_timestamp, 0); + } + else + { + TEST_VERIFY (!(mmhdr.msg_hdr.msg_flags & MSG_CTRUNC)); + TEST_COMPARE (found_timestamp, 0); + } + } + + /* Same as before, but for timespec. */ + { + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMPNS_OLD, &(int){1}, + sizeof (int)); + TEST_VERIFY_EXIT (r != -1); + + union + { + struct cmsghdr cmsghdr; + char msgbuf[CMSG_SPACE (sizeof (struct timespec))]; + } control; + + do_sendto (&srv_addr, 42); + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); + + bool found_timestamp = false; + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); + cmsg != NULL; + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) + { + if (cmsg->cmsg_level != SOL_SOCKET) + continue; + + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMPNS_NEW) + found_timestamp = true; + else + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMPNS_NEW); + } + + if (sizeof (time_t) > 4) + { + TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC)); + TEST_COMPARE (found_timestamp, 0); + } + else + { + TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC) == 0); + TEST_COMPARE (found_timestamp, 0); + } + } +} + +static int +do_test (void) +{ + /* This test only make sense for ABIs that support 32 bit time_t socket + timestampss. */ + if (sizeof (time_t) > 4 && __WORDSIZE == 64) + return 0; + + srv = xsocket (AF_INET, SOCK_DGRAM, 0); + srv_addr = (struct sockaddr_in) { + .sin_family = AF_INET, + .sin_addr = {.s_addr = htonl (INADDR_LOOPBACK) }, + }; + xbind (srv, (struct sockaddr *) &srv_addr, sizeof (srv_addr)); + { + socklen_t sa_len = sizeof (srv_addr); + xgetsockname (srv, (struct sockaddr *) &srv_addr, &sa_len); + TEST_VERIFY (sa_len == sizeof (srv_addr)); + } + + /* Check recvmsg; */ + do_test_large_buffer (false); + do_test_small_buffer (false); + /* Check recvmmsg. */ + do_test_large_buffer (true); + do_test_small_buffer (true); + + return 0; +} + +#include <support/test-driver.c>