[PATCH v2 0/2] linux-user: Adding support for a group of 4 time64 syscalls

[PATCH v2 0/2] linux-user: Adding support for a group of 4 time64 syscalls

[Filip Bozuta]

This two patch series introduces functionality for following
Year 2038 safe syscalls:

--Introduced in first patch--
*ppoll_time64()
*pselect6_time64()

--Introduced in second patch--
*utimensat_time64()
*semtimedop_time64()

Testing notes:

   The implementations of these time64 syscalls was tested
   using tests from the LTP test suite which was built inside
   a chroot.

v2:

   -Moved code of 'ppoll()' and 'pselect6()' to a separate
    function
   -Changed 'time64' from 'int' to 'bool'

Filip Bozuta (2):
  linux-user: Add support for ppoll_time64() and pselect6_time64()
  linux-user: Add support for utimensat_time64() and semtimedop_time64()

 linux-user/syscall.c | 520 +++++++++++++++++++++++++------------------
 1 file changed, 300 insertions(+), 220 deletions(-)

-- 
2.25.1

[PATCH v2 1/2] linux-user: Add support for ppoll_time64() and pselect6_time64()

[Filip Bozuta]

This patch introduces functionality for following time64 syscalls:

*ppoll_time64

    This is a year 2038 safe variant of:

    int poll(struct pollfd *fds, nfds_t nfds, int timeout)
    -- wait for some event on a file descriptor --
    man page: https://man7.org/linux/man-pages/man2/ppoll.2.html

*pselect6_time64

    This is a year 2038 safe variant of:

    int pselect6(int nfds, fd_set *readfds, fd_set *writefds,
                 fd_set *exceptfds, const struct timespec *timeout,
                 const sigset_t *sigmask);
    -- synchronous I/O multiplexing --
    man page: https://man7.org/linux/man-pages/man2/pselect6.2.html

Implementation notes:

    Year 2038 safe syscalls in this patch were implemented
    with the same code as their regular variants (ppoll() and pselect()).
    This code was moved to new functions ('do_ppoll()' and 'do_pselect6()')
    that take a 'bool time64' from which a right 'struct timespec' converting
    function is called.
    (target_to_host/host_to_target_timespec() for regular and
     target_to_host/host_to_target_timespec64() for time64 variants)

Signed-off-by: Filip Bozuta <Filip.Bozuta@syrmia.com>
---
 linux-user/syscall.c | 462 +++++++++++++++++++++++--------------------
 1 file changed, 251 insertions(+), 211 deletions(-)

diff --git a/linux-user/syscall.c b/linux-user/syscall.c
index 1211e759c2..fc6a6e32e4 100644
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -397,7 +397,7 @@ static int sys_getcwd1(char *buf, size_t size)
   return strlen(buf)+1;
 }
 
-#ifdef TARGET_NR_utimensat
+#if defined(TARGET_NR_utimensat)
 #if defined(__NR_utimensat)
 #define __NR_sys_utimensat __NR_utimensat
 _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
@@ -763,11 +763,11 @@ safe_syscall5(int, waitid, idtype_t, idtype, id_t, id, siginfo_t *, infop, \
               int, options, struct rusage *, rusage)
 safe_syscall3(int, execve, const char *, filename, char **, argv, char **, envp)
 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
-    defined(TARGET_NR_pselect6)
+    defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
 safe_syscall6(int, pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds, \
               fd_set *, exceptfds, struct timespec *, timeout, void *, sig)
 #endif
-#if defined(TARGET_NR_ppoll) || defined(TARGET_NR_poll)
+#if defined(TARGET_NR_ppoll) || defined(TARGET_NR_ppoll_time64)
 safe_syscall5(int, ppoll, struct pollfd *, ufds, unsigned int, nfds,
               struct timespec *, tsp, const sigset_t *, sigmask,
               size_t, sigsetsize)
@@ -984,7 +984,7 @@ abi_long do_brk(abi_ulong new_brk)
 }
 
 #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
-    defined(TARGET_NR_pselect6)
+    defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
 static inline abi_long copy_from_user_fdset(fd_set *fds,
                                             abi_ulong target_fds_addr,
                                             int n)
@@ -1252,7 +1252,8 @@ static inline abi_long target_to_host_timespec(struct timespec *host_ts,
 }
 #endif
 
-#if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64)
+#if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
+    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
 static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
                                                  abi_ulong target_addr)
 {
@@ -1458,6 +1459,237 @@ static abi_long do_old_select(abi_ulong arg1)
 #endif
 #endif
 
+#if defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
+static abi_long do_pselect6(abi_long arg1, abi_long arg2, abi_long arg3,
+                            abi_long arg4, abi_long arg5, abi_long arg6,
+                            bool time64)
+{
+    abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
+    fd_set rfds, wfds, efds;
+    fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
+    struct timespec ts, *ts_ptr;
+    abi_long ret;
+
+    /*
+     * The 6th arg is actually two args smashed together,
+     * so we cannot use the C library.
+     */
+    sigset_t set;
+    struct {
+        sigset_t *set;
+        size_t size;
+    } sig, *sig_ptr;
+
+    abi_ulong arg_sigset, arg_sigsize, *arg7;
+    target_sigset_t *target_sigset;
+
+    n = arg1;
+    rfd_addr = arg2;
+    wfd_addr = arg3;
+    efd_addr = arg4;
+    ts_addr = arg5;
+
+    ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
+    if (ret) {
+        return ret;
+    }
+    ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
+    if (ret) {
+        return ret;
+    }
+    ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
+    if (ret) {
+        return ret;
+    }
+
+    /*
+     * This takes a timespec, and not a timeval, so we cannot
+     * use the do_select() helper ...
+     */
+    if (ts_addr) {
+        if (time64) {
+            if (target_to_host_timespec64(&ts, ts_addr)) {
+                return -TARGET_EFAULT;
+            }
+        } else {
+            if (target_to_host_timespec(&ts, ts_addr)) {
+                return -TARGET_EFAULT;
+            }
+        }
+            ts_ptr = &ts;
+    } else {
+        ts_ptr = NULL;
+    }
+
+    /* Extract the two packed args for the sigset */
+    if (arg6) {
+        sig_ptr = &sig;
+        sig.size = SIGSET_T_SIZE;
+
+        arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
+        if (!arg7) {
+            return -TARGET_EFAULT;
+        }
+        arg_sigset = tswapal(arg7[0]);
+        arg_sigsize = tswapal(arg7[1]);
+        unlock_user(arg7, arg6, 0);
+
+        if (arg_sigset) {
+            sig.set = &set;
+            if (arg_sigsize != sizeof(*target_sigset)) {
+                /* Like the kernel, we enforce correct size sigsets */
+                return -TARGET_EINVAL;
+            }
+            target_sigset = lock_user(VERIFY_READ, arg_sigset,
+                                      sizeof(*target_sigset), 1);
+            if (!target_sigset) {
+                return -TARGET_EFAULT;
+            }
+            target_to_host_sigset(&set, target_sigset);
+            unlock_user(target_sigset, arg_sigset, 0);
+        } else {
+            sig.set = NULL;
+        }
+    } else {
+        sig_ptr = NULL;
+    }
+
+    ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
+                                  ts_ptr, sig_ptr));
+
+    if (!is_error(ret)) {
+        if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n)) {
+            return -TARGET_EFAULT;
+        }
+        if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n)) {
+            return -TARGET_EFAULT;
+        }
+        if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n)) {
+            return -TARGET_EFAULT;
+        }
+        if (time64) {
+            if (ts_addr && host_to_target_timespec(ts_addr, &ts)) {
+                return -TARGET_EFAULT;
+            }
+        } else {
+            if (ts_addr && host_to_target_timespec64(ts_addr, &ts)) {
+                return -TARGET_EFAULT;
+            }
+        }
+    }
+    return ret;
+}
+#endif
+
+#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll) || \
+    defined(TARGET_NR_ppoll_time64)
+static abi_long do_ppoll(abi_long arg1, abi_long arg2, abi_long arg3,
+                         abi_long arg4, abi_long arg5, bool ppoll, bool time64)
+{
+    struct target_pollfd *target_pfd;
+    unsigned int nfds = arg2;
+    struct pollfd *pfd;
+    unsigned int i;
+    abi_long ret;
+
+    pfd = NULL;
+    target_pfd = NULL;
+    if (nfds) {
+        if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
+            return -TARGET_EINVAL;
+        }
+        target_pfd = lock_user(VERIFY_WRITE, arg1,
+                               sizeof(struct target_pollfd) * nfds, 1);
+        if (!target_pfd) {
+            return -TARGET_EFAULT;
+        }
+
+        pfd = alloca(sizeof(struct pollfd) * nfds);
+        for (i = 0; i < nfds; i++) {
+            pfd[i].fd = tswap32(target_pfd[i].fd);
+            pfd[i].events = tswap16(target_pfd[i].events);
+        }
+    }
+    if (ppoll) {
+        struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
+        target_sigset_t *target_set;
+        sigset_t _set, *set = &_set;
+
+        if (arg3) {
+            if (time64) {
+                if (target_to_host_timespec64(timeout_ts, arg3)) {
+                    unlock_user(target_pfd, arg1, 0);
+                    return -TARGET_EFAULT;
+                }
+            } else {
+                if (target_to_host_timespec(timeout_ts, arg3)) {
+                    unlock_user(target_pfd, arg1, 0);
+                    return -TARGET_EFAULT;
+                }
+            }
+        } else {
+            timeout_ts = NULL;
+        }
+
+        if (arg4) {
+            if (arg5 != sizeof(target_sigset_t)) {
+                unlock_user(target_pfd, arg1, 0);
+                return -TARGET_EINVAL;
+            }
+
+            target_set = lock_user(VERIFY_READ, arg4,
+                                   sizeof(target_sigset_t), 1);
+            if (!target_set) {
+                unlock_user(target_pfd, arg1, 0);
+                return -TARGET_EFAULT;
+            }
+            target_to_host_sigset(set, target_set);
+        } else {
+            set = NULL;
+        }
+
+        ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
+                                   set, SIGSET_T_SIZE));
+
+        if (!is_error(ret) && arg3) {
+            if (time64) {
+                if (host_to_target_timespec64(arg3, timeout_ts)) {
+                    return -TARGET_EFAULT;
+                }
+            } else {
+                if (host_to_target_timespec(arg3, timeout_ts)) {
+                    return -TARGET_EFAULT;
+                }
+            }
+        }
+        if (arg4) {
+            unlock_user(target_set, arg4, 0);
+        }
+    } else {
+          struct timespec ts, *pts;
+
+          if (arg3 >= 0) {
+              /* Convert ms to secs, ns */
+              ts.tv_sec = arg3 / 1000;
+              ts.tv_nsec = (arg3 % 1000) * 1000000LL;
+              pts = &ts;
+          } else {
+              /* -ve poll() timeout means "infinite" */
+              pts = NULL;
+          }
+          ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
+    }
+
+    if (!is_error(ret)) {
+        for (i = 0; i < nfds; i++) {
+            target_pfd[i].revents = tswap16(pfd[i].revents);
+        }
+    }
+    unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
+    return ret;
+}
+#endif
+
 static abi_long do_pipe2(int host_pipe[], int flags)
 {
 #ifdef CONFIG_PIPE2
@@ -9045,106 +9277,11 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
 #endif
 #ifdef TARGET_NR_pselect6
     case TARGET_NR_pselect6:
-        {
-            abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
-            fd_set rfds, wfds, efds;
-            fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
-            struct timespec ts, *ts_ptr;
-
-            /*
-             * The 6th arg is actually two args smashed together,
-             * so we cannot use the C library.
-             */
-            sigset_t set;
-            struct {
-                sigset_t *set;
-                size_t size;
-            } sig, *sig_ptr;
-
-            abi_ulong arg_sigset, arg_sigsize, *arg7;
-            target_sigset_t *target_sigset;
-
-            n = arg1;
-            rfd_addr = arg2;
-            wfd_addr = arg3;
-            efd_addr = arg4;
-            ts_addr = arg5;
-
-            ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
-            if (ret) {
-                return ret;
-            }
-            ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
-            if (ret) {
-                return ret;
-            }
-            ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
-            if (ret) {
-                return ret;
-            }
-
-            /*
-             * This takes a timespec, and not a timeval, so we cannot
-             * use the do_select() helper ...
-             */
-            if (ts_addr) {
-                if (target_to_host_timespec(&ts, ts_addr)) {
-                    return -TARGET_EFAULT;
-                }
-                ts_ptr = &ts;
-            } else {
-                ts_ptr = NULL;
-            }
-
-            /* Extract the two packed args for the sigset */
-            if (arg6) {
-                sig_ptr = &sig;
-                sig.size = SIGSET_T_SIZE;
-
-                arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
-                if (!arg7) {
-                    return -TARGET_EFAULT;
-                }
-                arg_sigset = tswapal(arg7[0]);
-                arg_sigsize = tswapal(arg7[1]);
-                unlock_user(arg7, arg6, 0);
-
-                if (arg_sigset) {
-                    sig.set = &set;
-                    if (arg_sigsize != sizeof(*target_sigset)) {
-                        /* Like the kernel, we enforce correct size sigsets */
-                        return -TARGET_EINVAL;
-                    }
-                    target_sigset = lock_user(VERIFY_READ, arg_sigset,
-                                              sizeof(*target_sigset), 1);
-                    if (!target_sigset) {
-                        return -TARGET_EFAULT;
-                    }
-                    target_to_host_sigset(&set, target_sigset);
-                    unlock_user(target_sigset, arg_sigset, 0);
-                } else {
-                    sig.set = NULL;
-                }
-            } else {
-                sig_ptr = NULL;
-            }
-
-            ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
-                                          ts_ptr, sig_ptr));
-
-            if (!is_error(ret)) {
-                if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
-                    return -TARGET_EFAULT;
-                if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
-                    return -TARGET_EFAULT;
-                if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
-                    return -TARGET_EFAULT;
-
-                if (ts_addr && host_to_target_timespec(ts_addr, &ts))
-                    return -TARGET_EFAULT;
-            }
-        }
-        return ret;
+        return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, false);
+#endif
+#ifdef TARGET_NR_pselect6_time64
+    case TARGET_NR_pselect6_time64:
+        return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, true);
 #endif
 #ifdef TARGET_NR_symlink
     case TARGET_NR_symlink:
@@ -10076,114 +10213,17 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
     case TARGET_NR__newselect:
         return do_select(arg1, arg2, arg3, arg4, arg5);
 #endif
-#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
-# ifdef TARGET_NR_poll
+#ifdef TARGET_NR_poll
     case TARGET_NR_poll:
-# endif
-# ifdef TARGET_NR_ppoll
+        return do_ppoll(arg1, arg2, arg3, arg4, arg5, false, false);
+#endif
+#ifdef TARGET_NR_ppoll
     case TARGET_NR_ppoll:
-# endif
-        {
-            struct target_pollfd *target_pfd;
-            unsigned int nfds = arg2;
-            struct pollfd *pfd;
-            unsigned int i;
-
-            pfd = NULL;
-            target_pfd = NULL;
-            if (nfds) {
-                if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
-                    return -TARGET_EINVAL;
-                }
-
-                target_pfd = lock_user(VERIFY_WRITE, arg1,
-                                       sizeof(struct target_pollfd) * nfds, 1);
-                if (!target_pfd) {
-                    return -TARGET_EFAULT;
-                }
-
-                pfd = alloca(sizeof(struct pollfd) * nfds);
-                for (i = 0; i < nfds; i++) {
-                    pfd[i].fd = tswap32(target_pfd[i].fd);
-                    pfd[i].events = tswap16(target_pfd[i].events);
-                }
-            }
-
-            switch (num) {
-# ifdef TARGET_NR_ppoll
-            case TARGET_NR_ppoll:
-            {
-                struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
-                target_sigset_t *target_set;
-                sigset_t _set, *set = &_set;
-
-                if (arg3) {
-                    if (target_to_host_timespec(timeout_ts, arg3)) {
-                        unlock_user(target_pfd, arg1, 0);
-                        return -TARGET_EFAULT;
-                    }
-                } else {
-                    timeout_ts = NULL;
-                }
-
-                if (arg4) {
-                    if (arg5 != sizeof(target_sigset_t)) {
-                        unlock_user(target_pfd, arg1, 0);
-                        return -TARGET_EINVAL;
-                    }
-
-                    target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
-                    if (!target_set) {
-                        unlock_user(target_pfd, arg1, 0);
-                        return -TARGET_EFAULT;
-                    }
-                    target_to_host_sigset(set, target_set);
-                } else {
-                    set = NULL;
-                }
-
-                ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
-                                           set, SIGSET_T_SIZE));
-
-                if (!is_error(ret) && arg3) {
-                    host_to_target_timespec(arg3, timeout_ts);
-                }
-                if (arg4) {
-                    unlock_user(target_set, arg4, 0);
-                }
-                break;
-            }
-# endif
-# ifdef TARGET_NR_poll
-            case TARGET_NR_poll:
-            {
-                struct timespec ts, *pts;
-
-                if (arg3 >= 0) {
-                    /* Convert ms to secs, ns */
-                    ts.tv_sec = arg3 / 1000;
-                    ts.tv_nsec = (arg3 % 1000) * 1000000LL;
-                    pts = &ts;
-                } else {
-                    /* -ve poll() timeout means "infinite" */
-                    pts = NULL;
-                }
-                ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
-                break;
-            }
-# endif
-            default:
-                g_assert_not_reached();
-            }
-
-            if (!is_error(ret)) {
-                for(i = 0; i < nfds; i++) {
-                    target_pfd[i].revents = tswap16(pfd[i].revents);
-                }
-            }
-            unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
-        }
-        return ret;
+        return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, false);
+#endif
+#ifdef TARGET_NR_ppoll_time64
+    case TARGET_NR_ppoll_time64:
+        return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, true);
 #endif
     case TARGET_NR_flock:
         /* NOTE: the flock constant seems to be the same for every
-- 
2.25.1

Re: [PATCH v2 1/2] linux-user: Add support for ppoll_time64() and pselect6_time64()

[Laurent Vivier]

Le 25/08/2020 à 00:30, Filip Bozuta a écrit :
> This patch introduces functionality for following time64 syscalls:
> 
> *ppoll_time64
> 
>     This is a year 2038 safe variant of:
> 
>     int poll(struct pollfd *fds, nfds_t nfds, int timeout)
>     -- wait for some event on a file descriptor --
>     man page: https://man7.org/linux/man-pages/man2/ppoll.2.html
> 
> *pselect6_time64
> 
>     This is a year 2038 safe variant of:
> 
>     int pselect6(int nfds, fd_set *readfds, fd_set *writefds,
>                  fd_set *exceptfds, const struct timespec *timeout,
>                  const sigset_t *sigmask);
>     -- synchronous I/O multiplexing --
>     man page: https://man7.org/linux/man-pages/man2/pselect6.2.html
> 
> Implementation notes:
> 
>     Year 2038 safe syscalls in this patch were implemented
>     with the same code as their regular variants (ppoll() and pselect()).
>     This code was moved to new functions ('do_ppoll()' and 'do_pselect6()')
>     that take a 'bool time64' from which a right 'struct timespec' converting
>     function is called.
>     (target_to_host/host_to_target_timespec() for regular and
>      target_to_host/host_to_target_timespec64() for time64 variants)
> 
> Signed-off-by: Filip Bozuta <Filip.Bozuta@syrmia.com>
> ---
>  linux-user/syscall.c | 462 +++++++++++++++++++++++--------------------
>  1 file changed, 251 insertions(+), 211 deletions(-)
> 
> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> index 1211e759c2..fc6a6e32e4 100644
> --- a/linux-user/syscall.c
> +++ b/linux-user/syscall.c
> @@ -397,7 +397,7 @@ static int sys_getcwd1(char *buf, size_t size)
>    return strlen(buf)+1;
>  }
>  
> -#ifdef TARGET_NR_utimensat
> +#if defined(TARGET_NR_utimensat)
>  #if defined(__NR_utimensat)
>  #define __NR_sys_utimensat __NR_utimensat
>  _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
> @@ -763,11 +763,11 @@ safe_syscall5(int, waitid, idtype_t, idtype, id_t, id, siginfo_t *, infop, \
>                int, options, struct rusage *, rusage)
>  safe_syscall3(int, execve, const char *, filename, char **, argv, char **, envp)
>  #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
> -    defined(TARGET_NR_pselect6)
> +    defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
>  safe_syscall6(int, pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds, \
>                fd_set *, exceptfds, struct timespec *, timeout, void *, sig)
>  #endif
> -#if defined(TARGET_NR_ppoll) || defined(TARGET_NR_poll)
> +#if defined(TARGET_NR_ppoll) || defined(TARGET_NR_ppoll_time64)
>  safe_syscall5(int, ppoll, struct pollfd *, ufds, unsigned int, nfds,
>                struct timespec *, tsp, const sigset_t *, sigmask,
>                size_t, sigsetsize)
> @@ -984,7 +984,7 @@ abi_long do_brk(abi_ulong new_brk)
>  }
>  
>  #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
> -    defined(TARGET_NR_pselect6)
> +    defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
>  static inline abi_long copy_from_user_fdset(fd_set *fds,
>                                              abi_ulong target_fds_addr,
>                                              int n)
> @@ -1252,7 +1252,8 @@ static inline abi_long target_to_host_timespec(struct timespec *host_ts,
>  }
>  #endif
>  
> -#if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64)
> +#if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
> +    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
>  static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
>                                                   abi_ulong target_addr)
>  {
> @@ -1458,6 +1459,237 @@ static abi_long do_old_select(abi_ulong arg1)
>  #endif
>  #endif
>  
> +#if defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
> +static abi_long do_pselect6(abi_long arg1, abi_long arg2, abi_long arg3,
> +                            abi_long arg4, abi_long arg5, abi_long arg6,
> +                            bool time64)
> +{
> +    abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
> +    fd_set rfds, wfds, efds;
> +    fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
> +    struct timespec ts, *ts_ptr;
> +    abi_long ret;
> +
> +    /*
> +     * The 6th arg is actually two args smashed together,
> +     * so we cannot use the C library.
> +     */
> +    sigset_t set;
> +    struct {
> +        sigset_t *set;
> +        size_t size;
> +    } sig, *sig_ptr;
> +
> +    abi_ulong arg_sigset, arg_sigsize, *arg7;
> +    target_sigset_t *target_sigset;
> +
> +    n = arg1;
> +    rfd_addr = arg2;
> +    wfd_addr = arg3;
> +    efd_addr = arg4;
> +    ts_addr = arg5;
> +
> +    ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
> +    if (ret) {
> +        return ret;
> +    }
> +    ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
> +    if (ret) {
> +        return ret;
> +    }
> +    ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
> +    if (ret) {
> +        return ret;
> +    }
> +
> +    /*
> +     * This takes a timespec, and not a timeval, so we cannot
> +     * use the do_select() helper ...
> +     */
> +    if (ts_addr) {
> +        if (time64) {
> +            if (target_to_host_timespec64(&ts, ts_addr)) {
> +                return -TARGET_EFAULT;
> +            }
> +        } else {
> +            if (target_to_host_timespec(&ts, ts_addr)) {
> +                return -TARGET_EFAULT;
> +            }
> +        }
> +            ts_ptr = &ts;
> +    } else {
> +        ts_ptr = NULL;
> +    }
> +
> +    /* Extract the two packed args for the sigset */
> +    if (arg6) {
> +        sig_ptr = &sig;
> +        sig.size = SIGSET_T_SIZE;
> +
> +        arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
> +        if (!arg7) {
> +            return -TARGET_EFAULT;
> +        }
> +        arg_sigset = tswapal(arg7[0]);
> +        arg_sigsize = tswapal(arg7[1]);
> +        unlock_user(arg7, arg6, 0);
> +
> +        if (arg_sigset) {
> +            sig.set = &set;
> +            if (arg_sigsize != sizeof(*target_sigset)) {
> +                /* Like the kernel, we enforce correct size sigsets */
> +                return -TARGET_EINVAL;
> +            }
> +            target_sigset = lock_user(VERIFY_READ, arg_sigset,
> +                                      sizeof(*target_sigset), 1);
> +            if (!target_sigset) {
> +                return -TARGET_EFAULT;
> +            }
> +            target_to_host_sigset(&set, target_sigset);
> +            unlock_user(target_sigset, arg_sigset, 0);
> +        } else {
> +            sig.set = NULL;
> +        }
> +    } else {
> +        sig_ptr = NULL;
> +    }
> +
> +    ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
> +                                  ts_ptr, sig_ptr));
> +
> +    if (!is_error(ret)) {
> +        if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n)) {
> +            return -TARGET_EFAULT;
> +        }
> +        if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n)) {
> +            return -TARGET_EFAULT;
> +        }
> +        if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n)) {
> +            return -TARGET_EFAULT;
> +        }
> +        if (time64) {
> +            if (ts_addr && host_to_target_timespec(ts_addr, &ts)) {
> +                return -TARGET_EFAULT;
> +            }
> +        } else {
> +            if (ts_addr && host_to_target_timespec64(ts_addr, &ts)) {
> +                return -TARGET_EFAULT;
> +            }
> +        }
> +    }
> +    return ret;
> +}
> +#endif
> +
> +#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll) || \
> +    defined(TARGET_NR_ppoll_time64)
> +static abi_long do_ppoll(abi_long arg1, abi_long arg2, abi_long arg3,
> +                         abi_long arg4, abi_long arg5, bool ppoll, bool time64)
> +{
> +    struct target_pollfd *target_pfd;
> +    unsigned int nfds = arg2;
> +    struct pollfd *pfd;
> +    unsigned int i;
> +    abi_long ret;
> +
> +    pfd = NULL;
> +    target_pfd = NULL;
> +    if (nfds) {
> +        if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
> +            return -TARGET_EINVAL;
> +        }
> +        target_pfd = lock_user(VERIFY_WRITE, arg1,
> +                               sizeof(struct target_pollfd) * nfds, 1);
> +        if (!target_pfd) {
> +            return -TARGET_EFAULT;
> +        }
> +
> +        pfd = alloca(sizeof(struct pollfd) * nfds);
> +        for (i = 0; i < nfds; i++) {
> +            pfd[i].fd = tswap32(target_pfd[i].fd);
> +            pfd[i].events = tswap16(target_pfd[i].events);
> +        }
> +    }
> +    if (ppoll) {
> +        struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
> +        target_sigset_t *target_set;
> +        sigset_t _set, *set = &_set;
> +
> +        if (arg3) {
> +            if (time64) {
> +                if (target_to_host_timespec64(timeout_ts, arg3)) {
> +                    unlock_user(target_pfd, arg1, 0);
> +                    return -TARGET_EFAULT;
> +                }
> +            } else {
> +                if (target_to_host_timespec(timeout_ts, arg3)) {
> +                    unlock_user(target_pfd, arg1, 0);
> +                    return -TARGET_EFAULT;
> +                }
> +            }
> +        } else {
> +            timeout_ts = NULL;
> +        }
> +
> +        if (arg4) {
> +            if (arg5 != sizeof(target_sigset_t)) {
> +                unlock_user(target_pfd, arg1, 0);
> +                return -TARGET_EINVAL;
> +            }
> +
> +            target_set = lock_user(VERIFY_READ, arg4,
> +                                   sizeof(target_sigset_t), 1);
> +            if (!target_set) {
> +                unlock_user(target_pfd, arg1, 0);
> +                return -TARGET_EFAULT;
> +            }
> +            target_to_host_sigset(set, target_set);
> +        } else {
> +            set = NULL;
> +        }
> +
> +        ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
> +                                   set, SIGSET_T_SIZE));
> +
> +        if (!is_error(ret) && arg3) {
> +            if (time64) {
> +                if (host_to_target_timespec64(arg3, timeout_ts)) {
> +                    return -TARGET_EFAULT;
> +                }
> +            } else {
> +                if (host_to_target_timespec(arg3, timeout_ts)) {
> +                    return -TARGET_EFAULT;
> +                }
> +            }
> +        }
> +        if (arg4) {
> +            unlock_user(target_set, arg4, 0);
> +        }
> +    } else {
> +          struct timespec ts, *pts;
> +
> +          if (arg3 >= 0) {
> +              /* Convert ms to secs, ns */
> +              ts.tv_sec = arg3 / 1000;
> +              ts.tv_nsec = (arg3 % 1000) * 1000000LL;
> +              pts = &ts;
> +          } else {
> +              /* -ve poll() timeout means "infinite" */
> +              pts = NULL;
> +          }
> +          ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
> +    }
> +
> +    if (!is_error(ret)) {
> +        for (i = 0; i < nfds; i++) {
> +            target_pfd[i].revents = tswap16(pfd[i].revents);
> +        }
> +    }
> +    unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
> +    return ret;
> +}
> +#endif
> +
>  static abi_long do_pipe2(int host_pipe[], int flags)
>  {
>  #ifdef CONFIG_PIPE2
> @@ -9045,106 +9277,11 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>  #endif
>  #ifdef TARGET_NR_pselect6
>      case TARGET_NR_pselect6:
> -        {
> -            abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
> -            fd_set rfds, wfds, efds;
> -            fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
> -            struct timespec ts, *ts_ptr;
> -
> -            /*
> -             * The 6th arg is actually two args smashed together,
> -             * so we cannot use the C library.
> -             */
> -            sigset_t set;
> -            struct {
> -                sigset_t *set;
> -                size_t size;
> -            } sig, *sig_ptr;
> -
> -            abi_ulong arg_sigset, arg_sigsize, *arg7;
> -            target_sigset_t *target_sigset;
> -
> -            n = arg1;
> -            rfd_addr = arg2;
> -            wfd_addr = arg3;
> -            efd_addr = arg4;
> -            ts_addr = arg5;
> -
> -            ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
> -            if (ret) {
> -                return ret;
> -            }
> -            ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
> -            if (ret) {
> -                return ret;
> -            }
> -            ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
> -            if (ret) {
> -                return ret;
> -            }
> -
> -            /*
> -             * This takes a timespec, and not a timeval, so we cannot
> -             * use the do_select() helper ...
> -             */
> -            if (ts_addr) {
> -                if (target_to_host_timespec(&ts, ts_addr)) {
> -                    return -TARGET_EFAULT;
> -                }
> -                ts_ptr = &ts;
> -            } else {
> -                ts_ptr = NULL;
> -            }
> -
> -            /* Extract the two packed args for the sigset */
> -            if (arg6) {
> -                sig_ptr = &sig;
> -                sig.size = SIGSET_T_SIZE;
> -
> -                arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
> -                if (!arg7) {
> -                    return -TARGET_EFAULT;
> -                }
> -                arg_sigset = tswapal(arg7[0]);
> -                arg_sigsize = tswapal(arg7[1]);
> -                unlock_user(arg7, arg6, 0);
> -
> -                if (arg_sigset) {
> -                    sig.set = &set;
> -                    if (arg_sigsize != sizeof(*target_sigset)) {
> -                        /* Like the kernel, we enforce correct size sigsets */
> -                        return -TARGET_EINVAL;
> -                    }
> -                    target_sigset = lock_user(VERIFY_READ, arg_sigset,
> -                                              sizeof(*target_sigset), 1);
> -                    if (!target_sigset) {
> -                        return -TARGET_EFAULT;
> -                    }
> -                    target_to_host_sigset(&set, target_sigset);
> -                    unlock_user(target_sigset, arg_sigset, 0);
> -                } else {
> -                    sig.set = NULL;
> -                }
> -            } else {
> -                sig_ptr = NULL;
> -            }
> -
> -            ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
> -                                          ts_ptr, sig_ptr));
> -
> -            if (!is_error(ret)) {
> -                if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
> -                    return -TARGET_EFAULT;
> -                if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
> -                    return -TARGET_EFAULT;
> -                if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
> -                    return -TARGET_EFAULT;
> -
> -                if (ts_addr && host_to_target_timespec(ts_addr, &ts))
> -                    return -TARGET_EFAULT;
> -            }
> -        }
> -        return ret;
> +        return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, false);
> +#endif
> +#ifdef TARGET_NR_pselect6_time64
> +    case TARGET_NR_pselect6_time64:
> +        return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, true);
>  #endif
>  #ifdef TARGET_NR_symlink
>      case TARGET_NR_symlink:
> @@ -10076,114 +10213,17 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>      case TARGET_NR__newselect:
>          return do_select(arg1, arg2, arg3, arg4, arg5);
>  #endif
> -#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
> -# ifdef TARGET_NR_poll
> +#ifdef TARGET_NR_poll
>      case TARGET_NR_poll:
> -# endif
> -# ifdef TARGET_NR_ppoll
> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, false, false);
> +#endif
> +#ifdef TARGET_NR_ppoll
>      case TARGET_NR_ppoll:
> -# endif
> -        {
> -            struct target_pollfd *target_pfd;
> -            unsigned int nfds = arg2;
> -            struct pollfd *pfd;
> -            unsigned int i;
> -
> -            pfd = NULL;
> -            target_pfd = NULL;
> -            if (nfds) {
> -                if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
> -                    return -TARGET_EINVAL;
> -                }
> -
> -                target_pfd = lock_user(VERIFY_WRITE, arg1,
> -                                       sizeof(struct target_pollfd) * nfds, 1);
> -                if (!target_pfd) {
> -                    return -TARGET_EFAULT;
> -                }
> -
> -                pfd = alloca(sizeof(struct pollfd) * nfds);
> -                for (i = 0; i < nfds; i++) {
> -                    pfd[i].fd = tswap32(target_pfd[i].fd);
> -                    pfd[i].events = tswap16(target_pfd[i].events);
> -                }
> -            }
> -
> -            switch (num) {
> -# ifdef TARGET_NR_ppoll
> -            case TARGET_NR_ppoll:
> -            {
> -                struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
> -                target_sigset_t *target_set;
> -                sigset_t _set, *set = &_set;
> -
> -                if (arg3) {
> -                    if (target_to_host_timespec(timeout_ts, arg3)) {
> -                        unlock_user(target_pfd, arg1, 0);
> -                        return -TARGET_EFAULT;
> -                    }
> -                } else {
> -                    timeout_ts = NULL;
> -                }
> -
> -                if (arg4) {
> -                    if (arg5 != sizeof(target_sigset_t)) {
> -                        unlock_user(target_pfd, arg1, 0);
> -                        return -TARGET_EINVAL;
> -                    }
> -
> -                    target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
> -                    if (!target_set) {
> -                        unlock_user(target_pfd, arg1, 0);
> -                        return -TARGET_EFAULT;
> -                    }
> -                    target_to_host_sigset(set, target_set);
> -                } else {
> -                    set = NULL;
> -                }
> -
> -                ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
> -                                           set, SIGSET_T_SIZE));
> -
> -                if (!is_error(ret) && arg3) {
> -                    host_to_target_timespec(arg3, timeout_ts);
> -                }
> -                if (arg4) {
> -                    unlock_user(target_set, arg4, 0);
> -                }
> -                break;
> -            }
> -# endif
> -# ifdef TARGET_NR_poll
> -            case TARGET_NR_poll:
> -            {
> -                struct timespec ts, *pts;
> -
> -                if (arg3 >= 0) {
> -                    /* Convert ms to secs, ns */
> -                    ts.tv_sec = arg3 / 1000;
> -                    ts.tv_nsec = (arg3 % 1000) * 1000000LL;
> -                    pts = &ts;
> -                } else {
> -                    /* -ve poll() timeout means "infinite" */
> -                    pts = NULL;
> -                }
> -                ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
> -                break;
> -            }
> -# endif
> -            default:
> -                g_assert_not_reached();
> -            }
> -
> -            if (!is_error(ret)) {
> -                for(i = 0; i < nfds; i++) {
> -                    target_pfd[i].revents = tswap16(pfd[i].revents);
> -                }
> -            }
> -            unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
> -        }
> -        return ret;
> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, false);
> +#endif
> +#ifdef TARGET_NR_ppoll_time64
> +    case TARGET_NR_ppoll_time64:
> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, true);
>  #endif
>      case TARGET_NR_flock:
>          /* NOTE: the flock constant seems to be the same for every
> 

Reviewed-by: Laurent Vivier <laurent@vivier.eu>

Re: [PATCH v2 1/2] linux-user: Add support for ppoll_time64() and pselect6_time64()

[Laurent Vivier]

Le 25/08/2020 à 00:30, Filip Bozuta a écrit :
> This patch introduces functionality for following time64 syscalls:
> 
> *ppoll_time64
> 
>     This is a year 2038 safe variant of:
> 
>     int poll(struct pollfd *fds, nfds_t nfds, int timeout)
>     -- wait for some event on a file descriptor --
>     man page: https://man7.org/linux/man-pages/man2/ppoll.2.html
> 
> *pselect6_time64
> 
>     This is a year 2038 safe variant of:
> 
>     int pselect6(int nfds, fd_set *readfds, fd_set *writefds,
>                  fd_set *exceptfds, const struct timespec *timeout,
>                  const sigset_t *sigmask);
>     -- synchronous I/O multiplexing --
>     man page: https://man7.org/linux/man-pages/man2/pselect6.2.html
> 
> Implementation notes:
> 
>     Year 2038 safe syscalls in this patch were implemented
>     with the same code as their regular variants (ppoll() and pselect()).
>     This code was moved to new functions ('do_ppoll()' and 'do_pselect6()')
>     that take a 'bool time64' from which a right 'struct timespec' converting
>     function is called.
>     (target_to_host/host_to_target_timespec() for regular and
>      target_to_host/host_to_target_timespec64() for time64 variants)
> 
> Signed-off-by: Filip Bozuta <Filip.Bozuta@syrmia.com>
> ---
>  linux-user/syscall.c | 462 +++++++++++++++++++++++--------------------
>  1 file changed, 251 insertions(+), 211 deletions(-)
> 
> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> index 1211e759c2..fc6a6e32e4 100644
> --- a/linux-user/syscall.c
> +++ b/linux-user/syscall.c
> @@ -397,7 +397,7 @@ static int sys_getcwd1(char *buf, size_t size)
>    return strlen(buf)+1;
>  }
>  
> -#ifdef TARGET_NR_utimensat
> +#if defined(TARGET_NR_utimensat)
>  #if defined(__NR_utimensat)
>  #define __NR_sys_utimensat __NR_utimensat
>  _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
> @@ -763,11 +763,11 @@ safe_syscall5(int, waitid, idtype_t, idtype, id_t, id, siginfo_t *, infop, \
>                int, options, struct rusage *, rusage)
>  safe_syscall3(int, execve, const char *, filename, char **, argv, char **, envp)
>  #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
> -    defined(TARGET_NR_pselect6)
> +    defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
>  safe_syscall6(int, pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds, \
>                fd_set *, exceptfds, struct timespec *, timeout, void *, sig)
>  #endif
> -#if defined(TARGET_NR_ppoll) || defined(TARGET_NR_poll)
> +#if defined(TARGET_NR_ppoll) || defined(TARGET_NR_ppoll_time64)
>  safe_syscall5(int, ppoll, struct pollfd *, ufds, unsigned int, nfds,
>                struct timespec *, tsp, const sigset_t *, sigmask,
>                size_t, sigsetsize)
> @@ -984,7 +984,7 @@ abi_long do_brk(abi_ulong new_brk)
>  }
>  
>  #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
> -    defined(TARGET_NR_pselect6)
> +    defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
>  static inline abi_long copy_from_user_fdset(fd_set *fds,
>                                              abi_ulong target_fds_addr,
>                                              int n)
> @@ -1252,7 +1252,8 @@ static inline abi_long target_to_host_timespec(struct timespec *host_ts,
>  }
>  #endif
>  
> -#if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64)
> +#if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
> +    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
>  static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
>                                                   abi_ulong target_addr)
>  {
> @@ -1458,6 +1459,237 @@ static abi_long do_old_select(abi_ulong arg1)
>  #endif
>  #endif
>  
> +#if defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
> +static abi_long do_pselect6(abi_long arg1, abi_long arg2, abi_long arg3,
> +                            abi_long arg4, abi_long arg5, abi_long arg6,
> +                            bool time64)
> +{
> +    abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
> +    fd_set rfds, wfds, efds;
> +    fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
> +    struct timespec ts, *ts_ptr;
> +    abi_long ret;
> +
> +    /*
> +     * The 6th arg is actually two args smashed together,
> +     * so we cannot use the C library.
> +     */
> +    sigset_t set;
> +    struct {
> +        sigset_t *set;
> +        size_t size;
> +    } sig, *sig_ptr;
> +
> +    abi_ulong arg_sigset, arg_sigsize, *arg7;
> +    target_sigset_t *target_sigset;
> +
> +    n = arg1;
> +    rfd_addr = arg2;
> +    wfd_addr = arg3;
> +    efd_addr = arg4;
> +    ts_addr = arg5;
> +
> +    ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
> +    if (ret) {
> +        return ret;
> +    }
> +    ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
> +    if (ret) {
> +        return ret;
> +    }
> +    ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
> +    if (ret) {
> +        return ret;
> +    }
> +
> +    /*
> +     * This takes a timespec, and not a timeval, so we cannot
> +     * use the do_select() helper ...
> +     */
> +    if (ts_addr) {
> +        if (time64) {
> +            if (target_to_host_timespec64(&ts, ts_addr)) {
> +                return -TARGET_EFAULT;
> +            }
> +        } else {
> +            if (target_to_host_timespec(&ts, ts_addr)) {
> +                return -TARGET_EFAULT;
> +            }
> +        }
> +            ts_ptr = &ts;
> +    } else {
> +        ts_ptr = NULL;
> +    }
> +
> +    /* Extract the two packed args for the sigset */
> +    if (arg6) {
> +        sig_ptr = &sig;
> +        sig.size = SIGSET_T_SIZE;
> +
> +        arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
> +        if (!arg7) {
> +            return -TARGET_EFAULT;
> +        }
> +        arg_sigset = tswapal(arg7[0]);
> +        arg_sigsize = tswapal(arg7[1]);
> +        unlock_user(arg7, arg6, 0);
> +
> +        if (arg_sigset) {
> +            sig.set = &set;
> +            if (arg_sigsize != sizeof(*target_sigset)) {
> +                /* Like the kernel, we enforce correct size sigsets */
> +                return -TARGET_EINVAL;
> +            }
> +            target_sigset = lock_user(VERIFY_READ, arg_sigset,
> +                                      sizeof(*target_sigset), 1);
> +            if (!target_sigset) {
> +                return -TARGET_EFAULT;
> +            }
> +            target_to_host_sigset(&set, target_sigset);
> +            unlock_user(target_sigset, arg_sigset, 0);
> +        } else {
> +            sig.set = NULL;
> +        }
> +    } else {
> +        sig_ptr = NULL;
> +    }
> +
> +    ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
> +                                  ts_ptr, sig_ptr));
> +
> +    if (!is_error(ret)) {
> +        if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n)) {
> +            return -TARGET_EFAULT;
> +        }
> +        if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n)) {
> +            return -TARGET_EFAULT;
> +        }
> +        if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n)) {
> +            return -TARGET_EFAULT;
> +        }
> +        if (time64) {
> +            if (ts_addr && host_to_target_timespec(ts_addr, &ts)) {
> +                return -TARGET_EFAULT;
> +            }
> +        } else {
> +            if (ts_addr && host_to_target_timespec64(ts_addr, &ts)) {
> +                return -TARGET_EFAULT;
> +            }
> +        }
> +    }
> +    return ret;
> +}
> +#endif
> +
> +#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll) || \
> +    defined(TARGET_NR_ppoll_time64)
> +static abi_long do_ppoll(abi_long arg1, abi_long arg2, abi_long arg3,
> +                         abi_long arg4, abi_long arg5, bool ppoll, bool time64)
> +{
> +    struct target_pollfd *target_pfd;
> +    unsigned int nfds = arg2;
> +    struct pollfd *pfd;
> +    unsigned int i;
> +    abi_long ret;
> +
> +    pfd = NULL;
> +    target_pfd = NULL;
> +    if (nfds) {
> +        if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
> +            return -TARGET_EINVAL;
> +        }
> +        target_pfd = lock_user(VERIFY_WRITE, arg1,
> +                               sizeof(struct target_pollfd) * nfds, 1);
> +        if (!target_pfd) {
> +            return -TARGET_EFAULT;
> +        }
> +
> +        pfd = alloca(sizeof(struct pollfd) * nfds);
> +        for (i = 0; i < nfds; i++) {
> +            pfd[i].fd = tswap32(target_pfd[i].fd);
> +            pfd[i].events = tswap16(target_pfd[i].events);
> +        }
> +    }
> +    if (ppoll) {
> +        struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
> +        target_sigset_t *target_set;
> +        sigset_t _set, *set = &_set;
> +
> +        if (arg3) {
> +            if (time64) {
> +                if (target_to_host_timespec64(timeout_ts, arg3)) {
> +                    unlock_user(target_pfd, arg1, 0);
> +                    return -TARGET_EFAULT;
> +                }
> +            } else {
> +                if (target_to_host_timespec(timeout_ts, arg3)) {
> +                    unlock_user(target_pfd, arg1, 0);
> +                    return -TARGET_EFAULT;
> +                }
> +            }
> +        } else {
> +            timeout_ts = NULL;
> +        }
> +
> +        if (arg4) {
> +            if (arg5 != sizeof(target_sigset_t)) {
> +                unlock_user(target_pfd, arg1, 0);
> +                return -TARGET_EINVAL;
> +            }
> +
> +            target_set = lock_user(VERIFY_READ, arg4,
> +                                   sizeof(target_sigset_t), 1);
> +            if (!target_set) {
> +                unlock_user(target_pfd, arg1, 0);
> +                return -TARGET_EFAULT;
> +            }
> +            target_to_host_sigset(set, target_set);
> +        } else {
> +            set = NULL;
> +        }
> +
> +        ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
> +                                   set, SIGSET_T_SIZE));
> +
> +        if (!is_error(ret) && arg3) {
> +            if (time64) {
> +                if (host_to_target_timespec64(arg3, timeout_ts)) {
> +                    return -TARGET_EFAULT;
> +                }
> +            } else {
> +                if (host_to_target_timespec(arg3, timeout_ts)) {
> +                    return -TARGET_EFAULT;
> +                }
> +            }
> +        }
> +        if (arg4) {
> +            unlock_user(target_set, arg4, 0);
> +        }
> +    } else {
> +          struct timespec ts, *pts;
> +
> +          if (arg3 >= 0) {
> +              /* Convert ms to secs, ns */
> +              ts.tv_sec = arg3 / 1000;
> +              ts.tv_nsec = (arg3 % 1000) * 1000000LL;
> +              pts = &ts;
> +          } else {
> +              /* -ve poll() timeout means "infinite" */
> +              pts = NULL;
> +          }
> +          ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
> +    }
> +
> +    if (!is_error(ret)) {
> +        for (i = 0; i < nfds; i++) {
> +            target_pfd[i].revents = tswap16(pfd[i].revents);
> +        }
> +    }
> +    unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
> +    return ret;
> +}
> +#endif
> +
>  static abi_long do_pipe2(int host_pipe[], int flags)
>  {
>  #ifdef CONFIG_PIPE2
> @@ -9045,106 +9277,11 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>  #endif
>  #ifdef TARGET_NR_pselect6
>      case TARGET_NR_pselect6:
> -        {
> -            abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
> -            fd_set rfds, wfds, efds;
> -            fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
> -            struct timespec ts, *ts_ptr;
> -
> -            /*
> -             * The 6th arg is actually two args smashed together,
> -             * so we cannot use the C library.
> -             */
> -            sigset_t set;
> -            struct {
> -                sigset_t *set;
> -                size_t size;
> -            } sig, *sig_ptr;
> -
> -            abi_ulong arg_sigset, arg_sigsize, *arg7;
> -            target_sigset_t *target_sigset;
> -
> -            n = arg1;
> -            rfd_addr = arg2;
> -            wfd_addr = arg3;
> -            efd_addr = arg4;
> -            ts_addr = arg5;
> -
> -            ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
> -            if (ret) {
> -                return ret;
> -            }
> -            ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
> -            if (ret) {
> -                return ret;
> -            }
> -            ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
> -            if (ret) {
> -                return ret;
> -            }
> -
> -            /*
> -             * This takes a timespec, and not a timeval, so we cannot
> -             * use the do_select() helper ...
> -             */
> -            if (ts_addr) {
> -                if (target_to_host_timespec(&ts, ts_addr)) {
> -                    return -TARGET_EFAULT;
> -                }
> -                ts_ptr = &ts;
> -            } else {
> -                ts_ptr = NULL;
> -            }
> -
> -            /* Extract the two packed args for the sigset */
> -            if (arg6) {
> -                sig_ptr = &sig;
> -                sig.size = SIGSET_T_SIZE;
> -
> -                arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
> -                if (!arg7) {
> -                    return -TARGET_EFAULT;
> -                }
> -                arg_sigset = tswapal(arg7[0]);
> -                arg_sigsize = tswapal(arg7[1]);
> -                unlock_user(arg7, arg6, 0);
> -
> -                if (arg_sigset) {
> -                    sig.set = &set;
> -                    if (arg_sigsize != sizeof(*target_sigset)) {
> -                        /* Like the kernel, we enforce correct size sigsets */
> -                        return -TARGET_EINVAL;
> -                    }
> -                    target_sigset = lock_user(VERIFY_READ, arg_sigset,
> -                                              sizeof(*target_sigset), 1);
> -                    if (!target_sigset) {
> -                        return -TARGET_EFAULT;
> -                    }
> -                    target_to_host_sigset(&set, target_sigset);
> -                    unlock_user(target_sigset, arg_sigset, 0);
> -                } else {
> -                    sig.set = NULL;
> -                }
> -            } else {
> -                sig_ptr = NULL;
> -            }
> -
> -            ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
> -                                          ts_ptr, sig_ptr));
> -
> -            if (!is_error(ret)) {
> -                if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
> -                    return -TARGET_EFAULT;
> -                if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
> -                    return -TARGET_EFAULT;
> -                if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
> -                    return -TARGET_EFAULT;
> -
> -                if (ts_addr && host_to_target_timespec(ts_addr, &ts))
> -                    return -TARGET_EFAULT;
> -            }
> -        }
> -        return ret;
> +        return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, false);
> +#endif
> +#ifdef TARGET_NR_pselect6_time64
> +    case TARGET_NR_pselect6_time64:
> +        return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, true);
>  #endif
>  #ifdef TARGET_NR_symlink
>      case TARGET_NR_symlink:
> @@ -10076,114 +10213,17 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>      case TARGET_NR__newselect:
>          return do_select(arg1, arg2, arg3, arg4, arg5);
>  #endif
> -#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
> -# ifdef TARGET_NR_poll
> +#ifdef TARGET_NR_poll
>      case TARGET_NR_poll:
> -# endif
> -# ifdef TARGET_NR_ppoll
> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, false, false);
> +#endif
> +#ifdef TARGET_NR_ppoll
>      case TARGET_NR_ppoll:
> -# endif
> -        {
> -            struct target_pollfd *target_pfd;
> -            unsigned int nfds = arg2;
> -            struct pollfd *pfd;
> -            unsigned int i;
> -
> -            pfd = NULL;
> -            target_pfd = NULL;
> -            if (nfds) {
> -                if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
> -                    return -TARGET_EINVAL;
> -                }
> -
> -                target_pfd = lock_user(VERIFY_WRITE, arg1,
> -                                       sizeof(struct target_pollfd) * nfds, 1);
> -                if (!target_pfd) {
> -                    return -TARGET_EFAULT;
> -                }
> -
> -                pfd = alloca(sizeof(struct pollfd) * nfds);
> -                for (i = 0; i < nfds; i++) {
> -                    pfd[i].fd = tswap32(target_pfd[i].fd);
> -                    pfd[i].events = tswap16(target_pfd[i].events);
> -                }
> -            }
> -
> -            switch (num) {
> -# ifdef TARGET_NR_ppoll
> -            case TARGET_NR_ppoll:
> -            {
> -                struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
> -                target_sigset_t *target_set;
> -                sigset_t _set, *set = &_set;
> -
> -                if (arg3) {
> -                    if (target_to_host_timespec(timeout_ts, arg3)) {
> -                        unlock_user(target_pfd, arg1, 0);
> -                        return -TARGET_EFAULT;
> -                    }
> -                } else {
> -                    timeout_ts = NULL;
> -                }
> -
> -                if (arg4) {
> -                    if (arg5 != sizeof(target_sigset_t)) {
> -                        unlock_user(target_pfd, arg1, 0);
> -                        return -TARGET_EINVAL;
> -                    }
> -
> -                    target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
> -                    if (!target_set) {
> -                        unlock_user(target_pfd, arg1, 0);
> -                        return -TARGET_EFAULT;
> -                    }
> -                    target_to_host_sigset(set, target_set);
> -                } else {
> -                    set = NULL;
> -                }
> -
> -                ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
> -                                           set, SIGSET_T_SIZE));
> -
> -                if (!is_error(ret) && arg3) {
> -                    host_to_target_timespec(arg3, timeout_ts);
> -                }
> -                if (arg4) {
> -                    unlock_user(target_set, arg4, 0);
> -                }
> -                break;
> -            }
> -# endif
> -# ifdef TARGET_NR_poll
> -            case TARGET_NR_poll:
> -            {
> -                struct timespec ts, *pts;
> -
> -                if (arg3 >= 0) {
> -                    /* Convert ms to secs, ns */
> -                    ts.tv_sec = arg3 / 1000;
> -                    ts.tv_nsec = (arg3 % 1000) * 1000000LL;
> -                    pts = &ts;
> -                } else {
> -                    /* -ve poll() timeout means "infinite" */
> -                    pts = NULL;
> -                }
> -                ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
> -                break;
> -            }
> -# endif
> -            default:
> -                g_assert_not_reached();
> -            }
> -
> -            if (!is_error(ret)) {
> -                for(i = 0; i < nfds; i++) {
> -                    target_pfd[i].revents = tswap16(pfd[i].revents);
> -                }
> -            }
> -            unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
> -        }
> -        return ret;
> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, false);
> +#endif
> +#ifdef TARGET_NR_ppoll_time64
> +    case TARGET_NR_ppoll_time64:
> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, true);
>  #endif
>      case TARGET_NR_flock:
>          /* NOTE: the flock constant seems to be the same for every
> 

Applied to my linux-user-for-5.2 branch.

Thanks,
Laurent

Re: [PATCH v2 1/2] linux-user: Add support for ppoll_time64() and pselect6_time64()

[Laurent Vivier]

Le 25/08/2020 à 09:17, Laurent Vivier a écrit :
> Le 25/08/2020 à 00:30, Filip Bozuta a écrit :
>> This patch introduces functionality for following time64 syscalls:
>>
>> *ppoll_time64
>>
>>     This is a year 2038 safe variant of:
>>
>>     int poll(struct pollfd *fds, nfds_t nfds, int timeout)
>>     -- wait for some event on a file descriptor --
>>     man page: https://man7.org/linux/man-pages/man2/ppoll.2.html
>>
>> *pselect6_time64
>>
>>     This is a year 2038 safe variant of:
>>
>>     int pselect6(int nfds, fd_set *readfds, fd_set *writefds,
>>                  fd_set *exceptfds, const struct timespec *timeout,
>>                  const sigset_t *sigmask);
>>     -- synchronous I/O multiplexing --
>>     man page: https://man7.org/linux/man-pages/man2/pselect6.2.html
>>
>> Implementation notes:
>>
>>     Year 2038 safe syscalls in this patch were implemented
>>     with the same code as their regular variants (ppoll() and pselect()).
>>     This code was moved to new functions ('do_ppoll()' and 'do_pselect6()')
>>     that take a 'bool time64' from which a right 'struct timespec' converting
>>     function is called.
>>     (target_to_host/host_to_target_timespec() for regular and
>>      target_to_host/host_to_target_timespec64() for time64 variants)
>>
>> Signed-off-by: Filip Bozuta <Filip.Bozuta@syrmia.com>
>> ---
>>  linux-user/syscall.c | 462 +++++++++++++++++++++++--------------------
>>  1 file changed, 251 insertions(+), 211 deletions(-)
>>
>> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
>> index 1211e759c2..fc6a6e32e4 100644
>> --- a/linux-user/syscall.c
>> +++ b/linux-user/syscall.c
>> @@ -397,7 +397,7 @@ static int sys_getcwd1(char *buf, size_t size)
>>    return strlen(buf)+1;
>>  }
>>  
>> -#ifdef TARGET_NR_utimensat
>> +#if defined(TARGET_NR_utimensat)
>>  #if defined(__NR_utimensat)
>>  #define __NR_sys_utimensat __NR_utimensat
>>  _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
>> @@ -763,11 +763,11 @@ safe_syscall5(int, waitid, idtype_t, idtype, id_t, id, siginfo_t *, infop, \
>>                int, options, struct rusage *, rusage)
>>  safe_syscall3(int, execve, const char *, filename, char **, argv, char **, envp)
>>  #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
>> -    defined(TARGET_NR_pselect6)
>> +    defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
>>  safe_syscall6(int, pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds, \
>>                fd_set *, exceptfds, struct timespec *, timeout, void *, sig)
>>  #endif
>> -#if defined(TARGET_NR_ppoll) || defined(TARGET_NR_poll)
>> +#if defined(TARGET_NR_ppoll) || defined(TARGET_NR_ppoll_time64)
>>  safe_syscall5(int, ppoll, struct pollfd *, ufds, unsigned int, nfds,
>>                struct timespec *, tsp, const sigset_t *, sigmask,
>>                size_t, sigsetsize)
>> @@ -984,7 +984,7 @@ abi_long do_brk(abi_ulong new_brk)
>>  }
>>  
>>  #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
>> -    defined(TARGET_NR_pselect6)
>> +    defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
>>  static inline abi_long copy_from_user_fdset(fd_set *fds,
>>                                              abi_ulong target_fds_addr,
>>                                              int n)
>> @@ -1252,7 +1252,8 @@ static inline abi_long target_to_host_timespec(struct timespec *host_ts,
>>  }
>>  #endif
>>  
>> -#if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64)
>> +#if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
>> +    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
>>  static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
>>                                                   abi_ulong target_addr)
>>  {
>> @@ -1458,6 +1459,237 @@ static abi_long do_old_select(abi_ulong arg1)
>>  #endif
>>  #endif
>>  
>> +#if defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
>> +static abi_long do_pselect6(abi_long arg1, abi_long arg2, abi_long arg3,
>> +                            abi_long arg4, abi_long arg5, abi_long arg6,
>> +                            bool time64)
>> +{
>> +    abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
>> +    fd_set rfds, wfds, efds;
>> +    fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
>> +    struct timespec ts, *ts_ptr;
>> +    abi_long ret;
>> +
>> +    /*
>> +     * The 6th arg is actually two args smashed together,
>> +     * so we cannot use the C library.
>> +     */
>> +    sigset_t set;
>> +    struct {
>> +        sigset_t *set;
>> +        size_t size;
>> +    } sig, *sig_ptr;
>> +
>> +    abi_ulong arg_sigset, arg_sigsize, *arg7;
>> +    target_sigset_t *target_sigset;
>> +
>> +    n = arg1;
>> +    rfd_addr = arg2;
>> +    wfd_addr = arg3;
>> +    efd_addr = arg4;
>> +    ts_addr = arg5;
>> +
>> +    ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
>> +    if (ret) {
>> +        return ret;
>> +    }
>> +    ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
>> +    if (ret) {
>> +        return ret;
>> +    }
>> +    ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
>> +    if (ret) {
>> +        return ret;
>> +    }
>> +
>> +    /*
>> +     * This takes a timespec, and not a timeval, so we cannot
>> +     * use the do_select() helper ...
>> +     */
>> +    if (ts_addr) {
>> +        if (time64) {
>> +            if (target_to_host_timespec64(&ts, ts_addr)) {
>> +                return -TARGET_EFAULT;
>> +            }
>> +        } else {
>> +            if (target_to_host_timespec(&ts, ts_addr)) {
>> +                return -TARGET_EFAULT;
>> +            }
>> +        }
>> +            ts_ptr = &ts;
>> +    } else {
>> +        ts_ptr = NULL;
>> +    }
>> +
>> +    /* Extract the two packed args for the sigset */
>> +    if (arg6) {
>> +        sig_ptr = &sig;
>> +        sig.size = SIGSET_T_SIZE;
>> +
>> +        arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
>> +        if (!arg7) {
>> +            return -TARGET_EFAULT;
>> +        }
>> +        arg_sigset = tswapal(arg7[0]);
>> +        arg_sigsize = tswapal(arg7[1]);
>> +        unlock_user(arg7, arg6, 0);
>> +
>> +        if (arg_sigset) {
>> +            sig.set = &set;
>> +            if (arg_sigsize != sizeof(*target_sigset)) {
>> +                /* Like the kernel, we enforce correct size sigsets */
>> +                return -TARGET_EINVAL;
>> +            }
>> +            target_sigset = lock_user(VERIFY_READ, arg_sigset,
>> +                                      sizeof(*target_sigset), 1);
>> +            if (!target_sigset) {
>> +                return -TARGET_EFAULT;
>> +            }
>> +            target_to_host_sigset(&set, target_sigset);
>> +            unlock_user(target_sigset, arg_sigset, 0);
>> +        } else {
>> +            sig.set = NULL;
>> +        }
>> +    } else {
>> +        sig_ptr = NULL;
>> +    }
>> +
>> +    ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
>> +                                  ts_ptr, sig_ptr));
>> +
>> +    if (!is_error(ret)) {
>> +        if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n)) {
>> +            return -TARGET_EFAULT;
>> +        }
>> +        if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n)) {
>> +            return -TARGET_EFAULT;
>> +        }
>> +        if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n)) {
>> +            return -TARGET_EFAULT;
>> +        }
>> +        if (time64) {
>> +            if (ts_addr && host_to_target_timespec(ts_addr, &ts)) {
>> +                return -TARGET_EFAULT;
>> +            }
>> +        } else {
>> +            if (ts_addr && host_to_target_timespec64(ts_addr, &ts)) {
>> +                return -TARGET_EFAULT;
>> +            }
>> +        }
>> +    }
>> +    return ret;
>> +}
>> +#endif
>> +
>> +#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll) || \
>> +    defined(TARGET_NR_ppoll_time64)
>> +static abi_long do_ppoll(abi_long arg1, abi_long arg2, abi_long arg3,
>> +                         abi_long arg4, abi_long arg5, bool ppoll, bool time64)
>> +{
>> +    struct target_pollfd *target_pfd;
>> +    unsigned int nfds = arg2;
>> +    struct pollfd *pfd;
>> +    unsigned int i;
>> +    abi_long ret;
>> +
>> +    pfd = NULL;
>> +    target_pfd = NULL;
>> +    if (nfds) {
>> +        if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
>> +            return -TARGET_EINVAL;
>> +        }
>> +        target_pfd = lock_user(VERIFY_WRITE, arg1,
>> +                               sizeof(struct target_pollfd) * nfds, 1);
>> +        if (!target_pfd) {
>> +            return -TARGET_EFAULT;
>> +        }
>> +
>> +        pfd = alloca(sizeof(struct pollfd) * nfds);
>> +        for (i = 0; i < nfds; i++) {
>> +            pfd[i].fd = tswap32(target_pfd[i].fd);
>> +            pfd[i].events = tswap16(target_pfd[i].events);
>> +        }
>> +    }
>> +    if (ppoll) {
>> +        struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
>> +        target_sigset_t *target_set;
>> +        sigset_t _set, *set = &_set;
>> +
>> +        if (arg3) {
>> +            if (time64) {
>> +                if (target_to_host_timespec64(timeout_ts, arg3)) {
>> +                    unlock_user(target_pfd, arg1, 0);
>> +                    return -TARGET_EFAULT;
>> +                }
>> +            } else {
>> +                if (target_to_host_timespec(timeout_ts, arg3)) {
>> +                    unlock_user(target_pfd, arg1, 0);
>> +                    return -TARGET_EFAULT;
>> +                }
>> +            }
>> +        } else {
>> +            timeout_ts = NULL;
>> +        }
>> +
>> +        if (arg4) {
>> +            if (arg5 != sizeof(target_sigset_t)) {
>> +                unlock_user(target_pfd, arg1, 0);
>> +                return -TARGET_EINVAL;
>> +            }
>> +
>> +            target_set = lock_user(VERIFY_READ, arg4,
>> +                                   sizeof(target_sigset_t), 1);
>> +            if (!target_set) {
>> +                unlock_user(target_pfd, arg1, 0);
>> +                return -TARGET_EFAULT;
>> +            }
>> +            target_to_host_sigset(set, target_set);
>> +        } else {
>> +            set = NULL;
>> +        }
>> +
>> +        ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
>> +                                   set, SIGSET_T_SIZE));
>> +
>> +        if (!is_error(ret) && arg3) {
>> +            if (time64) {
>> +                if (host_to_target_timespec64(arg3, timeout_ts)) {
>> +                    return -TARGET_EFAULT;
>> +                }
>> +            } else {
>> +                if (host_to_target_timespec(arg3, timeout_ts)) {
>> +                    return -TARGET_EFAULT;
>> +                }
>> +            }
>> +        }
>> +        if (arg4) {
>> +            unlock_user(target_set, arg4, 0);
>> +        }
>> +    } else {
>> +          struct timespec ts, *pts;
>> +
>> +          if (arg3 >= 0) {
>> +              /* Convert ms to secs, ns */
>> +              ts.tv_sec = arg3 / 1000;
>> +              ts.tv_nsec = (arg3 % 1000) * 1000000LL;
>> +              pts = &ts;
>> +          } else {
>> +              /* -ve poll() timeout means "infinite" */
>> +              pts = NULL;
>> +          }
>> +          ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
>> +    }
>> +
>> +    if (!is_error(ret)) {
>> +        for (i = 0; i < nfds; i++) {
>> +            target_pfd[i].revents = tswap16(pfd[i].revents);
>> +        }
>> +    }
>> +    unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
>> +    return ret;
>> +}
>> +#endif
>> +
>>  static abi_long do_pipe2(int host_pipe[], int flags)
>>  {
>>  #ifdef CONFIG_PIPE2
>> @@ -9045,106 +9277,11 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>>  #endif
>>  #ifdef TARGET_NR_pselect6
>>      case TARGET_NR_pselect6:
>> -        {
>> -            abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
>> -            fd_set rfds, wfds, efds;
>> -            fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
>> -            struct timespec ts, *ts_ptr;
>> -
>> -            /*
>> -             * The 6th arg is actually two args smashed together,
>> -             * so we cannot use the C library.
>> -             */
>> -            sigset_t set;
>> -            struct {
>> -                sigset_t *set;
>> -                size_t size;
>> -            } sig, *sig_ptr;
>> -
>> -            abi_ulong arg_sigset, arg_sigsize, *arg7;
>> -            target_sigset_t *target_sigset;
>> -
>> -            n = arg1;
>> -            rfd_addr = arg2;
>> -            wfd_addr = arg3;
>> -            efd_addr = arg4;
>> -            ts_addr = arg5;
>> -
>> -            ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
>> -            if (ret) {
>> -                return ret;
>> -            }
>> -            ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
>> -            if (ret) {
>> -                return ret;
>> -            }
>> -            ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
>> -            if (ret) {
>> -                return ret;
>> -            }
>> -
>> -            /*
>> -             * This takes a timespec, and not a timeval, so we cannot
>> -             * use the do_select() helper ...
>> -             */
>> -            if (ts_addr) {
>> -                if (target_to_host_timespec(&ts, ts_addr)) {
>> -                    return -TARGET_EFAULT;
>> -                }
>> -                ts_ptr = &ts;
>> -            } else {
>> -                ts_ptr = NULL;
>> -            }
>> -
>> -            /* Extract the two packed args for the sigset */
>> -            if (arg6) {
>> -                sig_ptr = &sig;
>> -                sig.size = SIGSET_T_SIZE;
>> -
>> -                arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
>> -                if (!arg7) {
>> -                    return -TARGET_EFAULT;
>> -                }
>> -                arg_sigset = tswapal(arg7[0]);
>> -                arg_sigsize = tswapal(arg7[1]);
>> -                unlock_user(arg7, arg6, 0);
>> -
>> -                if (arg_sigset) {
>> -                    sig.set = &set;
>> -                    if (arg_sigsize != sizeof(*target_sigset)) {
>> -                        /* Like the kernel, we enforce correct size sigsets */
>> -                        return -TARGET_EINVAL;
>> -                    }
>> -                    target_sigset = lock_user(VERIFY_READ, arg_sigset,
>> -                                              sizeof(*target_sigset), 1);
>> -                    if (!target_sigset) {
>> -                        return -TARGET_EFAULT;
>> -                    }
>> -                    target_to_host_sigset(&set, target_sigset);
>> -                    unlock_user(target_sigset, arg_sigset, 0);
>> -                } else {
>> -                    sig.set = NULL;
>> -                }
>> -            } else {
>> -                sig_ptr = NULL;
>> -            }
>> -
>> -            ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
>> -                                          ts_ptr, sig_ptr));
>> -
>> -            if (!is_error(ret)) {
>> -                if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
>> -                    return -TARGET_EFAULT;
>> -                if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
>> -                    return -TARGET_EFAULT;
>> -                if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
>> -                    return -TARGET_EFAULT;
>> -
>> -                if (ts_addr && host_to_target_timespec(ts_addr, &ts))
>> -                    return -TARGET_EFAULT;
>> -            }
>> -        }
>> -        return ret;
>> +        return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, false);
>> +#endif
>> +#ifdef TARGET_NR_pselect6_time64
>> +    case TARGET_NR_pselect6_time64:
>> +        return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, true);
>>  #endif
>>  #ifdef TARGET_NR_symlink
>>      case TARGET_NR_symlink:
>> @@ -10076,114 +10213,17 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>>      case TARGET_NR__newselect:
>>          return do_select(arg1, arg2, arg3, arg4, arg5);
>>  #endif
>> -#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
>> -# ifdef TARGET_NR_poll
>> +#ifdef TARGET_NR_poll
>>      case TARGET_NR_poll:
>> -# endif
>> -# ifdef TARGET_NR_ppoll
>> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, false, false);
>> +#endif
>> +#ifdef TARGET_NR_ppoll
>>      case TARGET_NR_ppoll:
>> -# endif
>> -        {
>> -            struct target_pollfd *target_pfd;
>> -            unsigned int nfds = arg2;
>> -            struct pollfd *pfd;
>> -            unsigned int i;
>> -
>> -            pfd = NULL;
>> -            target_pfd = NULL;
>> -            if (nfds) {
>> -                if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
>> -                    return -TARGET_EINVAL;
>> -                }
>> -
>> -                target_pfd = lock_user(VERIFY_WRITE, arg1,
>> -                                       sizeof(struct target_pollfd) * nfds, 1);
>> -                if (!target_pfd) {
>> -                    return -TARGET_EFAULT;
>> -                }
>> -
>> -                pfd = alloca(sizeof(struct pollfd) * nfds);
>> -                for (i = 0; i < nfds; i++) {
>> -                    pfd[i].fd = tswap32(target_pfd[i].fd);
>> -                    pfd[i].events = tswap16(target_pfd[i].events);
>> -                }
>> -            }
>> -
>> -            switch (num) {
>> -# ifdef TARGET_NR_ppoll
>> -            case TARGET_NR_ppoll:
>> -            {
>> -                struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
>> -                target_sigset_t *target_set;
>> -                sigset_t _set, *set = &_set;
>> -
>> -                if (arg3) {
>> -                    if (target_to_host_timespec(timeout_ts, arg3)) {
>> -                        unlock_user(target_pfd, arg1, 0);
>> -                        return -TARGET_EFAULT;
>> -                    }
>> -                } else {
>> -                    timeout_ts = NULL;
>> -                }
>> -
>> -                if (arg4) {
>> -                    if (arg5 != sizeof(target_sigset_t)) {
>> -                        unlock_user(target_pfd, arg1, 0);
>> -                        return -TARGET_EINVAL;
>> -                    }
>> -
>> -                    target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
>> -                    if (!target_set) {
>> -                        unlock_user(target_pfd, arg1, 0);
>> -                        return -TARGET_EFAULT;
>> -                    }
>> -                    target_to_host_sigset(set, target_set);
>> -                } else {
>> -                    set = NULL;
>> -                }
>> -
>> -                ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
>> -                                           set, SIGSET_T_SIZE));
>> -
>> -                if (!is_error(ret) && arg3) {
>> -                    host_to_target_timespec(arg3, timeout_ts);
>> -                }
>> -                if (arg4) {
>> -                    unlock_user(target_set, arg4, 0);
>> -                }
>> -                break;
>> -            }
>> -# endif
>> -# ifdef TARGET_NR_poll
>> -            case TARGET_NR_poll:
>> -            {
>> -                struct timespec ts, *pts;
>> -
>> -                if (arg3 >= 0) {
>> -                    /* Convert ms to secs, ns */
>> -                    ts.tv_sec = arg3 / 1000;
>> -                    ts.tv_nsec = (arg3 % 1000) * 1000000LL;
>> -                    pts = &ts;
>> -                } else {
>> -                    /* -ve poll() timeout means "infinite" */
>> -                    pts = NULL;
>> -                }
>> -                ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
>> -                break;
>> -            }
>> -# endif
>> -            default:
>> -                g_assert_not_reached();
>> -            }
>> -
>> -            if (!is_error(ret)) {
>> -                for(i = 0; i < nfds; i++) {
>> -                    target_pfd[i].revents = tswap16(pfd[i].revents);
>> -                }
>> -            }
>> -            unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
>> -        }
>> -        return ret;
>> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, false);
>> +#endif
>> +#ifdef TARGET_NR_ppoll_time64
>> +    case TARGET_NR_ppoll_time64:
>> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, true);
>>  #endif
>>      case TARGET_NR_flock:
>>          /* NOTE: the flock constant seems to be the same for every
>>
> 
> Applied to my linux-user-for-5.2 branch.


I have removed it from my branch because this patch breaks "go run
hello.go" on armhf/bionic:

# cat /tmp/hello.go
package main

import "fmt"

func main() {
        fmt.Println("Hello World!")
}

# go run /tmp/hello.go
fatal error: unexpected signal during runtime execution
fatal error: unexpected signal during runtime execution
panic during panic
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x0]
...

Thanks,
Laurent

Re: [PATCH v2 1/2] linux-user: Add support for ppoll_time64() and pselect6_time64()

[Laurent Vivier]

Le 25/08/2020 à 17:23, Laurent Vivier a écrit :
> Le 25/08/2020 à 09:17, Laurent Vivier a écrit :
>> Le 25/08/2020 à 00:30, Filip Bozuta a écrit :
>>> This patch introduces functionality for following time64 syscalls:
>>>
>>> *ppoll_time64
>>>
>>>     This is a year 2038 safe variant of:
>>>
>>>     int poll(struct pollfd *fds, nfds_t nfds, int timeout)
>>>     -- wait for some event on a file descriptor --
>>>     man page: https://man7.org/linux/man-pages/man2/ppoll.2.html
>>>
>>> *pselect6_time64
>>>
>>>     This is a year 2038 safe variant of:
>>>
>>>     int pselect6(int nfds, fd_set *readfds, fd_set *writefds,
>>>                  fd_set *exceptfds, const struct timespec *timeout,
>>>                  const sigset_t *sigmask);
>>>     -- synchronous I/O multiplexing --
>>>     man page: https://man7.org/linux/man-pages/man2/pselect6.2.html
>>>
>>> Implementation notes:
>>>
>>>     Year 2038 safe syscalls in this patch were implemented
>>>     with the same code as their regular variants (ppoll() and pselect()).
>>>     This code was moved to new functions ('do_ppoll()' and 'do_pselect6()')
>>>     that take a 'bool time64' from which a right 'struct timespec' converting
>>>     function is called.
>>>     (target_to_host/host_to_target_timespec() for regular and
>>>      target_to_host/host_to_target_timespec64() for time64 variants)
>>>
>>> Signed-off-by: Filip Bozuta <Filip.Bozuta@syrmia.com>
>>> ---
>>>  linux-user/syscall.c | 462 +++++++++++++++++++++++--------------------
>>>  1 file changed, 251 insertions(+), 211 deletions(-)
>>>
>>> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
>>> index 1211e759c2..fc6a6e32e4 100644
>>> --- a/linux-user/syscall.c
>>> +++ b/linux-user/syscall.c
>>> @@ -397,7 +397,7 @@ static int sys_getcwd1(char *buf, size_t size)
>>>    return strlen(buf)+1;
>>>  }
>>>  
>>> -#ifdef TARGET_NR_utimensat
>>> +#if defined(TARGET_NR_utimensat)
>>>  #if defined(__NR_utimensat)
>>>  #define __NR_sys_utimensat __NR_utimensat
>>>  _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
>>> @@ -763,11 +763,11 @@ safe_syscall5(int, waitid, idtype_t, idtype, id_t, id, siginfo_t *, infop, \
>>>                int, options, struct rusage *, rusage)
>>>  safe_syscall3(int, execve, const char *, filename, char **, argv, char **, envp)
>>>  #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
>>> -    defined(TARGET_NR_pselect6)
>>> +    defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
>>>  safe_syscall6(int, pselect6, int, nfds, fd_set *, readfds, fd_set *, writefds, \
>>>                fd_set *, exceptfds, struct timespec *, timeout, void *, sig)
>>>  #endif
>>> -#if defined(TARGET_NR_ppoll) || defined(TARGET_NR_poll)
>>> +#if defined(TARGET_NR_ppoll) || defined(TARGET_NR_ppoll_time64)
>>>  safe_syscall5(int, ppoll, struct pollfd *, ufds, unsigned int, nfds,
>>>                struct timespec *, tsp, const sigset_t *, sigmask,
>>>                size_t, sigsetsize)
>>> @@ -984,7 +984,7 @@ abi_long do_brk(abi_ulong new_brk)
>>>  }
>>>  
>>>  #if defined(TARGET_NR_select) || defined(TARGET_NR__newselect) || \
>>> -    defined(TARGET_NR_pselect6)
>>> +    defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
>>>  static inline abi_long copy_from_user_fdset(fd_set *fds,
>>>                                              abi_ulong target_fds_addr,
>>>                                              int n)
>>> @@ -1252,7 +1252,8 @@ static inline abi_long target_to_host_timespec(struct timespec *host_ts,
>>>  }
>>>  #endif
>>>  
>>> -#if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64)
>>> +#if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
>>> +    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
>>>  static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
>>>                                                   abi_ulong target_addr)
>>>  {
>>> @@ -1458,6 +1459,237 @@ static abi_long do_old_select(abi_ulong arg1)
>>>  #endif
>>>  #endif
>>>  
>>> +#if defined(TARGET_NR_pselect6) || defined(TARGET_NR_pselect6_time64)
>>> +static abi_long do_pselect6(abi_long arg1, abi_long arg2, abi_long arg3,
>>> +                            abi_long arg4, abi_long arg5, abi_long arg6,
>>> +                            bool time64)
>>> +{
>>> +    abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
>>> +    fd_set rfds, wfds, efds;
>>> +    fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
>>> +    struct timespec ts, *ts_ptr;
>>> +    abi_long ret;
>>> +
>>> +    /*
>>> +     * The 6th arg is actually two args smashed together,
>>> +     * so we cannot use the C library.
>>> +     */
>>> +    sigset_t set;
>>> +    struct {
>>> +        sigset_t *set;
>>> +        size_t size;
>>> +    } sig, *sig_ptr;
>>> +
>>> +    abi_ulong arg_sigset, arg_sigsize, *arg7;
>>> +    target_sigset_t *target_sigset;
>>> +
>>> +    n = arg1;
>>> +    rfd_addr = arg2;
>>> +    wfd_addr = arg3;
>>> +    efd_addr = arg4;
>>> +    ts_addr = arg5;
>>> +
>>> +    ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
>>> +    if (ret) {
>>> +        return ret;
>>> +    }
>>> +    ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
>>> +    if (ret) {
>>> +        return ret;
>>> +    }
>>> +    ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
>>> +    if (ret) {
>>> +        return ret;
>>> +    }
>>> +
>>> +    /*
>>> +     * This takes a timespec, and not a timeval, so we cannot
>>> +     * use the do_select() helper ...
>>> +     */
>>> +    if (ts_addr) {
>>> +        if (time64) {
>>> +            if (target_to_host_timespec64(&ts, ts_addr)) {
>>> +                return -TARGET_EFAULT;
>>> +            }
>>> +        } else {
>>> +            if (target_to_host_timespec(&ts, ts_addr)) {
>>> +                return -TARGET_EFAULT;
>>> +            }
>>> +        }
>>> +            ts_ptr = &ts;
>>> +    } else {
>>> +        ts_ptr = NULL;
>>> +    }
>>> +
>>> +    /* Extract the two packed args for the sigset */
>>> +    if (arg6) {
>>> +        sig_ptr = &sig;
>>> +        sig.size = SIGSET_T_SIZE;
>>> +
>>> +        arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
>>> +        if (!arg7) {
>>> +            return -TARGET_EFAULT;
>>> +        }
>>> +        arg_sigset = tswapal(arg7[0]);
>>> +        arg_sigsize = tswapal(arg7[1]);
>>> +        unlock_user(arg7, arg6, 0);
>>> +
>>> +        if (arg_sigset) {
>>> +            sig.set = &set;
>>> +            if (arg_sigsize != sizeof(*target_sigset)) {
>>> +                /* Like the kernel, we enforce correct size sigsets */
>>> +                return -TARGET_EINVAL;
>>> +            }
>>> +            target_sigset = lock_user(VERIFY_READ, arg_sigset,
>>> +                                      sizeof(*target_sigset), 1);
>>> +            if (!target_sigset) {
>>> +                return -TARGET_EFAULT;
>>> +            }
>>> +            target_to_host_sigset(&set, target_sigset);
>>> +            unlock_user(target_sigset, arg_sigset, 0);
>>> +        } else {
>>> +            sig.set = NULL;
>>> +        }
>>> +    } else {
>>> +        sig_ptr = NULL;
>>> +    }
>>> +
>>> +    ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
>>> +                                  ts_ptr, sig_ptr));
>>> +
>>> +    if (!is_error(ret)) {
>>> +        if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n)) {
>>> +            return -TARGET_EFAULT;
>>> +        }
>>> +        if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n)) {
>>> +            return -TARGET_EFAULT;
>>> +        }
>>> +        if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n)) {
>>> +            return -TARGET_EFAULT;
>>> +        }
>>> +        if (time64) {
>>> +            if (ts_addr && host_to_target_timespec(ts_addr, &ts)) {
>>> +                return -TARGET_EFAULT;
>>> +            }
>>> +        } else {
>>> +            if (ts_addr && host_to_target_timespec64(ts_addr, &ts)) {
>>> +                return -TARGET_EFAULT;
>>> +            }
>>> +        }
>>> +    }
>>> +    return ret;
>>> +}
>>> +#endif
>>> +
>>> +#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll) || \
>>> +    defined(TARGET_NR_ppoll_time64)
>>> +static abi_long do_ppoll(abi_long arg1, abi_long arg2, abi_long arg3,
>>> +                         abi_long arg4, abi_long arg5, bool ppoll, bool time64)
>>> +{
>>> +    struct target_pollfd *target_pfd;
>>> +    unsigned int nfds = arg2;
>>> +    struct pollfd *pfd;
>>> +    unsigned int i;
>>> +    abi_long ret;
>>> +
>>> +    pfd = NULL;
>>> +    target_pfd = NULL;
>>> +    if (nfds) {
>>> +        if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
>>> +            return -TARGET_EINVAL;
>>> +        }
>>> +        target_pfd = lock_user(VERIFY_WRITE, arg1,
>>> +                               sizeof(struct target_pollfd) * nfds, 1);
>>> +        if (!target_pfd) {
>>> +            return -TARGET_EFAULT;
>>> +        }
>>> +
>>> +        pfd = alloca(sizeof(struct pollfd) * nfds);
>>> +        for (i = 0; i < nfds; i++) {
>>> +            pfd[i].fd = tswap32(target_pfd[i].fd);
>>> +            pfd[i].events = tswap16(target_pfd[i].events);
>>> +        }
>>> +    }
>>> +    if (ppoll) {
>>> +        struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
>>> +        target_sigset_t *target_set;
>>> +        sigset_t _set, *set = &_set;
>>> +
>>> +        if (arg3) {
>>> +            if (time64) {
>>> +                if (target_to_host_timespec64(timeout_ts, arg3)) {
>>> +                    unlock_user(target_pfd, arg1, 0);
>>> +                    return -TARGET_EFAULT;
>>> +                }
>>> +            } else {
>>> +                if (target_to_host_timespec(timeout_ts, arg3)) {
>>> +                    unlock_user(target_pfd, arg1, 0);
>>> +                    return -TARGET_EFAULT;
>>> +                }
>>> +            }
>>> +        } else {
>>> +            timeout_ts = NULL;
>>> +        }
>>> +
>>> +        if (arg4) {
>>> +            if (arg5 != sizeof(target_sigset_t)) {
>>> +                unlock_user(target_pfd, arg1, 0);
>>> +                return -TARGET_EINVAL;
>>> +            }
>>> +
>>> +            target_set = lock_user(VERIFY_READ, arg4,
>>> +                                   sizeof(target_sigset_t), 1);
>>> +            if (!target_set) {
>>> +                unlock_user(target_pfd, arg1, 0);
>>> +                return -TARGET_EFAULT;
>>> +            }
>>> +            target_to_host_sigset(set, target_set);
>>> +        } else {
>>> +            set = NULL;
>>> +        }
>>> +
>>> +        ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
>>> +                                   set, SIGSET_T_SIZE));
>>> +
>>> +        if (!is_error(ret) && arg3) {
>>> +            if (time64) {
>>> +                if (host_to_target_timespec64(arg3, timeout_ts)) {
>>> +                    return -TARGET_EFAULT;
>>> +                }
>>> +            } else {
>>> +                if (host_to_target_timespec(arg3, timeout_ts)) {
>>> +                    return -TARGET_EFAULT;
>>> +                }
>>> +            }
>>> +        }
>>> +        if (arg4) {
>>> +            unlock_user(target_set, arg4, 0);
>>> +        }
>>> +    } else {
>>> +          struct timespec ts, *pts;
>>> +
>>> +          if (arg3 >= 0) {
>>> +              /* Convert ms to secs, ns */
>>> +              ts.tv_sec = arg3 / 1000;
>>> +              ts.tv_nsec = (arg3 % 1000) * 1000000LL;
>>> +              pts = &ts;
>>> +          } else {
>>> +              /* -ve poll() timeout means "infinite" */
>>> +              pts = NULL;
>>> +          }
>>> +          ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
>>> +    }
>>> +
>>> +    if (!is_error(ret)) {
>>> +        for (i = 0; i < nfds; i++) {
>>> +            target_pfd[i].revents = tswap16(pfd[i].revents);
>>> +        }
>>> +    }
>>> +    unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
>>> +    return ret;
>>> +}
>>> +#endif
>>> +
>>>  static abi_long do_pipe2(int host_pipe[], int flags)
>>>  {
>>>  #ifdef CONFIG_PIPE2
>>> @@ -9045,106 +9277,11 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>>>  #endif
>>>  #ifdef TARGET_NR_pselect6
>>>      case TARGET_NR_pselect6:
>>> -        {
>>> -            abi_long rfd_addr, wfd_addr, efd_addr, n, ts_addr;
>>> -            fd_set rfds, wfds, efds;
>>> -            fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
>>> -            struct timespec ts, *ts_ptr;
>>> -
>>> -            /*
>>> -             * The 6th arg is actually two args smashed together,
>>> -             * so we cannot use the C library.
>>> -             */
>>> -            sigset_t set;
>>> -            struct {
>>> -                sigset_t *set;
>>> -                size_t size;
>>> -            } sig, *sig_ptr;
>>> -
>>> -            abi_ulong arg_sigset, arg_sigsize, *arg7;
>>> -            target_sigset_t *target_sigset;
>>> -
>>> -            n = arg1;
>>> -            rfd_addr = arg2;
>>> -            wfd_addr = arg3;
>>> -            efd_addr = arg4;
>>> -            ts_addr = arg5;
>>> -
>>> -            ret = copy_from_user_fdset_ptr(&rfds, &rfds_ptr, rfd_addr, n);
>>> -            if (ret) {
>>> -                return ret;
>>> -            }
>>> -            ret = copy_from_user_fdset_ptr(&wfds, &wfds_ptr, wfd_addr, n);
>>> -            if (ret) {
>>> -                return ret;
>>> -            }
>>> -            ret = copy_from_user_fdset_ptr(&efds, &efds_ptr, efd_addr, n);
>>> -            if (ret) {
>>> -                return ret;
>>> -            }
>>> -
>>> -            /*
>>> -             * This takes a timespec, and not a timeval, so we cannot
>>> -             * use the do_select() helper ...
>>> -             */
>>> -            if (ts_addr) {
>>> -                if (target_to_host_timespec(&ts, ts_addr)) {
>>> -                    return -TARGET_EFAULT;
>>> -                }
>>> -                ts_ptr = &ts;
>>> -            } else {
>>> -                ts_ptr = NULL;
>>> -            }
>>> -
>>> -            /* Extract the two packed args for the sigset */
>>> -            if (arg6) {
>>> -                sig_ptr = &sig;
>>> -                sig.size = SIGSET_T_SIZE;
>>> -
>>> -                arg7 = lock_user(VERIFY_READ, arg6, sizeof(*arg7) * 2, 1);
>>> -                if (!arg7) {
>>> -                    return -TARGET_EFAULT;
>>> -                }
>>> -                arg_sigset = tswapal(arg7[0]);
>>> -                arg_sigsize = tswapal(arg7[1]);
>>> -                unlock_user(arg7, arg6, 0);
>>> -
>>> -                if (arg_sigset) {
>>> -                    sig.set = &set;
>>> -                    if (arg_sigsize != sizeof(*target_sigset)) {
>>> -                        /* Like the kernel, we enforce correct size sigsets */
>>> -                        return -TARGET_EINVAL;
>>> -                    }
>>> -                    target_sigset = lock_user(VERIFY_READ, arg_sigset,
>>> -                                              sizeof(*target_sigset), 1);
>>> -                    if (!target_sigset) {
>>> -                        return -TARGET_EFAULT;
>>> -                    }
>>> -                    target_to_host_sigset(&set, target_sigset);
>>> -                    unlock_user(target_sigset, arg_sigset, 0);
>>> -                } else {
>>> -                    sig.set = NULL;
>>> -                }
>>> -            } else {
>>> -                sig_ptr = NULL;
>>> -            }
>>> -
>>> -            ret = get_errno(safe_pselect6(n, rfds_ptr, wfds_ptr, efds_ptr,
>>> -                                          ts_ptr, sig_ptr));
>>> -
>>> -            if (!is_error(ret)) {
>>> -                if (rfd_addr && copy_to_user_fdset(rfd_addr, &rfds, n))
>>> -                    return -TARGET_EFAULT;
>>> -                if (wfd_addr && copy_to_user_fdset(wfd_addr, &wfds, n))
>>> -                    return -TARGET_EFAULT;
>>> -                if (efd_addr && copy_to_user_fdset(efd_addr, &efds, n))
>>> -                    return -TARGET_EFAULT;
>>> -
>>> -                if (ts_addr && host_to_target_timespec(ts_addr, &ts))
>>> -                    return -TARGET_EFAULT;
>>> -            }
>>> -        }
>>> -        return ret;
>>> +        return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, false);
>>> +#endif
>>> +#ifdef TARGET_NR_pselect6_time64
>>> +    case TARGET_NR_pselect6_time64:
>>> +        return do_pselect6(arg1, arg2, arg3, arg4, arg5, arg6, true);
>>>  #endif
>>>  #ifdef TARGET_NR_symlink
>>>      case TARGET_NR_symlink:
>>> @@ -10076,114 +10213,17 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>>>      case TARGET_NR__newselect:
>>>          return do_select(arg1, arg2, arg3, arg4, arg5);
>>>  #endif
>>> -#if defined(TARGET_NR_poll) || defined(TARGET_NR_ppoll)
>>> -# ifdef TARGET_NR_poll
>>> +#ifdef TARGET_NR_poll
>>>      case TARGET_NR_poll:
>>> -# endif
>>> -# ifdef TARGET_NR_ppoll
>>> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, false, false);
>>> +#endif
>>> +#ifdef TARGET_NR_ppoll
>>>      case TARGET_NR_ppoll:
>>> -# endif
>>> -        {
>>> -            struct target_pollfd *target_pfd;
>>> -            unsigned int nfds = arg2;
>>> -            struct pollfd *pfd;
>>> -            unsigned int i;
>>> -
>>> -            pfd = NULL;
>>> -            target_pfd = NULL;
>>> -            if (nfds) {
>>> -                if (nfds > (INT_MAX / sizeof(struct target_pollfd))) {
>>> -                    return -TARGET_EINVAL;
>>> -                }
>>> -
>>> -                target_pfd = lock_user(VERIFY_WRITE, arg1,
>>> -                                       sizeof(struct target_pollfd) * nfds, 1);
>>> -                if (!target_pfd) {
>>> -                    return -TARGET_EFAULT;
>>> -                }
>>> -
>>> -                pfd = alloca(sizeof(struct pollfd) * nfds);
>>> -                for (i = 0; i < nfds; i++) {
>>> -                    pfd[i].fd = tswap32(target_pfd[i].fd);
>>> -                    pfd[i].events = tswap16(target_pfd[i].events);
>>> -                }
>>> -            }
>>> -
>>> -            switch (num) {
>>> -# ifdef TARGET_NR_ppoll
>>> -            case TARGET_NR_ppoll:
>>> -            {
>>> -                struct timespec _timeout_ts, *timeout_ts = &_timeout_ts;
>>> -                target_sigset_t *target_set;
>>> -                sigset_t _set, *set = &_set;
>>> -
>>> -                if (arg3) {
>>> -                    if (target_to_host_timespec(timeout_ts, arg3)) {
>>> -                        unlock_user(target_pfd, arg1, 0);
>>> -                        return -TARGET_EFAULT;
>>> -                    }
>>> -                } else {
>>> -                    timeout_ts = NULL;
>>> -                }
>>> -
>>> -                if (arg4) {
>>> -                    if (arg5 != sizeof(target_sigset_t)) {
>>> -                        unlock_user(target_pfd, arg1, 0);
>>> -                        return -TARGET_EINVAL;
>>> -                    }
>>> -
>>> -                    target_set = lock_user(VERIFY_READ, arg4, sizeof(target_sigset_t), 1);
>>> -                    if (!target_set) {
>>> -                        unlock_user(target_pfd, arg1, 0);
>>> -                        return -TARGET_EFAULT;
>>> -                    }
>>> -                    target_to_host_sigset(set, target_set);
>>> -                } else {
>>> -                    set = NULL;
>>> -                }
>>> -
>>> -                ret = get_errno(safe_ppoll(pfd, nfds, timeout_ts,
>>> -                                           set, SIGSET_T_SIZE));
>>> -
>>> -                if (!is_error(ret) && arg3) {
>>> -                    host_to_target_timespec(arg3, timeout_ts);
>>> -                }
>>> -                if (arg4) {
>>> -                    unlock_user(target_set, arg4, 0);
>>> -                }
>>> -                break;
>>> -            }
>>> -# endif
>>> -# ifdef TARGET_NR_poll
>>> -            case TARGET_NR_poll:
>>> -            {
>>> -                struct timespec ts, *pts;
>>> -
>>> -                if (arg3 >= 0) {
>>> -                    /* Convert ms to secs, ns */
>>> -                    ts.tv_sec = arg3 / 1000;
>>> -                    ts.tv_nsec = (arg3 % 1000) * 1000000LL;
>>> -                    pts = &ts;
>>> -                } else {
>>> -                    /* -ve poll() timeout means "infinite" */
>>> -                    pts = NULL;
>>> -                }
>>> -                ret = get_errno(safe_ppoll(pfd, nfds, pts, NULL, 0));
>>> -                break;
>>> -            }
>>> -# endif
>>> -            default:
>>> -                g_assert_not_reached();
>>> -            }
>>> -
>>> -            if (!is_error(ret)) {
>>> -                for(i = 0; i < nfds; i++) {
>>> -                    target_pfd[i].revents = tswap16(pfd[i].revents);
>>> -                }
>>> -            }
>>> -            unlock_user(target_pfd, arg1, sizeof(struct target_pollfd) * nfds);
>>> -        }
>>> -        return ret;
>>> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, false);
>>> +#endif
>>> +#ifdef TARGET_NR_ppoll_time64
>>> +    case TARGET_NR_ppoll_time64:
>>> +        return do_ppoll(arg1, arg2, arg3, arg4, arg5, true, true);
>>>  #endif
>>>      case TARGET_NR_flock:
>>>          /* NOTE: the flock constant seems to be the same for every
>>>
>>
>> Applied to my linux-user-for-5.2 branch.
> 
> 
> I have removed it from my branch because this patch breaks "go run
> hello.go" on armhf/bionic:
> 
> # cat /tmp/hello.go
> package main
> 
> import "fmt"
> 
> func main() {
>         fmt.Println("Hello World!")
> }
> 
> # go run /tmp/hello.go
> fatal error: unexpected signal during runtime execution
> fatal error: unexpected signal during runtime execution
> panic during panic
> [signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x0]
> ...
> 

I've re-applied this patch to linux-user-for-5.2 with this change that
fixes the problem above:

--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -1568,11 +1568,11 @@ static abi_long do_pselect6(abi_long arg1,
abi_long arg2, abi_long arg3,
             return -TARGET_EFAULT;
         }
         if (time64) {
-            if (ts_addr && host_to_target_timespec(ts_addr, &ts)) {
+            if (ts_addr && host_to_target_timespec64(ts_addr, &ts)) {
                 return -TARGET_EFAULT;
             }
         } else {
-            if (ts_addr && host_to_target_timespec64(ts_addr, &ts)) {
+            if (ts_addr && host_to_target_timespec(ts_addr, &ts)) {
                 return -TARGET_EFAULT;
             }
         }

Thanks,
Laurent

[PATCH v2 2/2] linux-user: Add support for utimensat_time64() and semtimedop_time64()

[Filip Bozuta]

This patch introduces functionality for following time64 syscalls:

*utimensat_time64()

    int utimensat(int dirfd, const char *pathname,
                  const struct timespec times[2], int flags);
    -- change file timestamps with nanosecond precision --
    man page: https://man7.org/linux/man-pages/man2/utimensat.2.html

*semtimedop_time64()

    int semtimedop(int semid, struct sembuf *sops, size_t nsops,
                   const struct timespec *timeout);
    -- System V semaphore operations --
    man page: https://www.man7.org/linux/man-pages/man2/semtimedop.2.html

Implementation notes:

   Syscall 'utimensat_time64()' is implemented in similar way as its
   regular variants only difference being that time64 converting function
   is used to convert values of 'struct timespec' between host and target
   ('target_to_host_timespec64()').

   For syscall 'semtimedop_time64()' and additional argument is added
   in function 'do_semtimedop()' through which the aproppriate 'struct timespec'
   converting function is called (false for regular target_to_host_timespec()
   and true for target_to_host_timespec64()). For 'do_ipc()' a
   check was added as that additional argument: 'TARGET_ABI_BITS == 64'.

Signed-off-by: Filip Bozuta <Filip.Bozuta@syrmia.com>
Reviewed-by: Laurent Vivier <laurent@vivier.eu>
---
 linux-user/syscall.c | 60 ++++++++++++++++++++++++++++++++++++--------
 1 file changed, 50 insertions(+), 10 deletions(-)

diff --git a/linux-user/syscall.c b/linux-user/syscall.c
index fc6a6e32e4..4d460af744 100644
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -1253,7 +1253,8 @@ static inline abi_long target_to_host_timespec(struct timespec *host_ts,
 #endif
 
 #if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
-    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
+    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64) || \
+    defined(TARGET_NR_utimensat_time64) || defined(TARGET_NR_semtimedop_time64)
 static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
                                                  abi_ulong target_addr)
 {
@@ -4117,7 +4118,7 @@ static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
 }
 
 #if defined(TARGET_NR_ipc) || defined(TARGET_NR_semop) || \
-    defined(TARGET_NR_semtimedop)
+    defined(TARGET_NR_semtimedop) || defined(TARGET_NR_semtimedop_time64)
 
 /*
  * This macro is required to handle the s390 variants, which passes the
@@ -4134,7 +4135,7 @@ static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
 static inline abi_long do_semtimedop(int semid,
                                      abi_long ptr,
                                      unsigned nsops,
-                                     abi_long timeout)
+                                     abi_long timeout, bool time64)
 {
     struct sembuf sops[nsops];
     struct timespec ts, *pts = NULL;
@@ -4142,8 +4143,14 @@ static inline abi_long do_semtimedop(int semid,
 
     if (timeout) {
         pts = &ts;
-        if (target_to_host_timespec(pts, timeout)) {
-            return -TARGET_EFAULT;
+        if (time64) {
+            if (target_to_host_timespec64(pts, timeout)) {
+                return -TARGET_EFAULT;
+            }
+        } else {
+            if (target_to_host_timespec(pts, timeout)) {
+                return -TARGET_EFAULT;
+            }
         }
     }
 
@@ -4657,7 +4664,7 @@ static abi_long do_ipc(CPUArchState *cpu_env,
 
     switch (call) {
     case IPCOP_semop:
-        ret = do_semtimedop(first, ptr, second, 0);
+        ret = do_semtimedop(first, ptr, second, 0, false);
         break;
     case IPCOP_semtimedop:
     /*
@@ -4667,9 +4674,9 @@ static abi_long do_ipc(CPUArchState *cpu_env,
      * to a struct timespec where the generic variant uses fifth parameter.
      */
 #if defined(TARGET_S390X)
-        ret = do_semtimedop(first, ptr, second, third);
+        ret = do_semtimedop(first, ptr, second, third, TARGET_ABI_BITS == 64);
 #else
-        ret = do_semtimedop(first, ptr, second, fifth);
+        ret = do_semtimedop(first, ptr, second, fifth, TARGET_ABI_BITS == 64);
 #endif
         break;
 
@@ -9887,11 +9894,15 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
 #endif
 #ifdef TARGET_NR_semop
     case TARGET_NR_semop:
-        return do_semtimedop(arg1, arg2, arg3, 0);
+        return do_semtimedop(arg1, arg2, arg3, 0, false);
 #endif
 #ifdef TARGET_NR_semtimedop
     case TARGET_NR_semtimedop:
-        return do_semtimedop(arg1, arg2, arg3, arg4);
+        return do_semtimedop(arg1, arg2, arg3, arg4, false);
+#endif
+#ifdef TARGET_NR_semtimedop_time64
+    case TARGET_NR_semtimedop_time64:
+        return do_semtimedop(arg1, arg2, arg3, arg4, true);
 #endif
 #ifdef TARGET_NR_semctl
     case TARGET_NR_semctl:
@@ -11938,6 +11949,35 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
         }
         return ret;
 #endif
+#ifdef TARGET_NR_utimensat_time64
+    case TARGET_NR_utimensat_time64:
+        {
+            struct timespec *tsp, ts[2];
+            if (!arg3) {
+                tsp = NULL;
+            } else {
+                if (target_to_host_timespec64(ts, arg3)) {
+                    return -TARGET_EFAULT;
+                }
+                if (target_to_host_timespec64(ts + 1, arg3 +
+                                     sizeof(struct target__kernel_timespec))) {
+                    return -TARGET_EFAULT;
+                }
+                tsp = ts;
+            }
+            if (!arg2)
+                ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
+            else {
+                p = lock_user_string(arg2);
+                if (!p) {
+                    return -TARGET_EFAULT;
+                }
+                ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
+                unlock_user(p, arg2, 0);
+            }
+        }
+        return ret;
+#endif
 #ifdef TARGET_NR_futex
     case TARGET_NR_futex:
         return do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
-- 
2.25.1

Re: [PATCH v2 2/2] linux-user: Add support for utimensat_time64() and semtimedop_time64()

[Laurent Vivier]

Le 25/08/2020 à 00:30, Filip Bozuta a écrit :
> This patch introduces functionality for following time64 syscalls:
> 
> *utimensat_time64()
> 
>     int utimensat(int dirfd, const char *pathname,
>                   const struct timespec times[2], int flags);
>     -- change file timestamps with nanosecond precision --
>     man page: https://man7.org/linux/man-pages/man2/utimensat.2.html
> 
> *semtimedop_time64()
> 
>     int semtimedop(int semid, struct sembuf *sops, size_t nsops,
>                    const struct timespec *timeout);
>     -- System V semaphore operations --
>     man page: https://www.man7.org/linux/man-pages/man2/semtimedop.2.html
> 
> Implementation notes:
> 
>    Syscall 'utimensat_time64()' is implemented in similar way as its
>    regular variants only difference being that time64 converting function
>    is used to convert values of 'struct timespec' between host and target
>    ('target_to_host_timespec64()').
> 
>    For syscall 'semtimedop_time64()' and additional argument is added
>    in function 'do_semtimedop()' through which the aproppriate 'struct timespec'
>    converting function is called (false for regular target_to_host_timespec()
>    and true for target_to_host_timespec64()). For 'do_ipc()' a
>    check was added as that additional argument: 'TARGET_ABI_BITS == 64'.
> 
> Signed-off-by: Filip Bozuta <Filip.Bozuta@syrmia.com>
> Reviewed-by: Laurent Vivier <laurent@vivier.eu>
> ---
>  linux-user/syscall.c | 60 ++++++++++++++++++++++++++++++++++++--------
>  1 file changed, 50 insertions(+), 10 deletions(-)
> 
> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> index fc6a6e32e4..4d460af744 100644
> --- a/linux-user/syscall.c
> +++ b/linux-user/syscall.c
> @@ -1253,7 +1253,8 @@ static inline abi_long target_to_host_timespec(struct timespec *host_ts,
>  #endif
>  
>  #if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
> -    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
> +    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64) || \
> +    defined(TARGET_NR_utimensat_time64) || defined(TARGET_NR_semtimedop_time64)
>  static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
>                                                   abi_ulong target_addr)
>  {
> @@ -4117,7 +4118,7 @@ static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
>  }
>  
>  #if defined(TARGET_NR_ipc) || defined(TARGET_NR_semop) || \
> -    defined(TARGET_NR_semtimedop)
> +    defined(TARGET_NR_semtimedop) || defined(TARGET_NR_semtimedop_time64)
>  
>  /*
>   * This macro is required to handle the s390 variants, which passes the
> @@ -4134,7 +4135,7 @@ static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
>  static inline abi_long do_semtimedop(int semid,
>                                       abi_long ptr,
>                                       unsigned nsops,
> -                                     abi_long timeout)
> +                                     abi_long timeout, bool time64)
>  {
>      struct sembuf sops[nsops];
>      struct timespec ts, *pts = NULL;
> @@ -4142,8 +4143,14 @@ static inline abi_long do_semtimedop(int semid,
>  
>      if (timeout) {
>          pts = &ts;
> -        if (target_to_host_timespec(pts, timeout)) {
> -            return -TARGET_EFAULT;
> +        if (time64) {
> +            if (target_to_host_timespec64(pts, timeout)) {
> +                return -TARGET_EFAULT;
> +            }
> +        } else {
> +            if (target_to_host_timespec(pts, timeout)) {
> +                return -TARGET_EFAULT;
> +            }
>          }
>      }
>  
> @@ -4657,7 +4664,7 @@ static abi_long do_ipc(CPUArchState *cpu_env,
>  
>      switch (call) {
>      case IPCOP_semop:
> -        ret = do_semtimedop(first, ptr, second, 0);
> +        ret = do_semtimedop(first, ptr, second, 0, false);
>          break;
>      case IPCOP_semtimedop:
>      /*
> @@ -4667,9 +4674,9 @@ static abi_long do_ipc(CPUArchState *cpu_env,
>       * to a struct timespec where the generic variant uses fifth parameter.
>       */
>  #if defined(TARGET_S390X)
> -        ret = do_semtimedop(first, ptr, second, third);
> +        ret = do_semtimedop(first, ptr, second, third, TARGET_ABI_BITS == 64);
>  #else
> -        ret = do_semtimedop(first, ptr, second, fifth);
> +        ret = do_semtimedop(first, ptr, second, fifth, TARGET_ABI_BITS == 64);
>  #endif
>          break;
>  
> @@ -9887,11 +9894,15 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>  #endif
>  #ifdef TARGET_NR_semop
>      case TARGET_NR_semop:
> -        return do_semtimedop(arg1, arg2, arg3, 0);
> +        return do_semtimedop(arg1, arg2, arg3, 0, false);
>  #endif
>  #ifdef TARGET_NR_semtimedop
>      case TARGET_NR_semtimedop:
> -        return do_semtimedop(arg1, arg2, arg3, arg4);
> +        return do_semtimedop(arg1, arg2, arg3, arg4, false);
> +#endif
> +#ifdef TARGET_NR_semtimedop_time64
> +    case TARGET_NR_semtimedop_time64:
> +        return do_semtimedop(arg1, arg2, arg3, arg4, true);
>  #endif
>  #ifdef TARGET_NR_semctl
>      case TARGET_NR_semctl:
> @@ -11938,6 +11949,35 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>          }
>          return ret;
>  #endif
> +#ifdef TARGET_NR_utimensat_time64
> +    case TARGET_NR_utimensat_time64:
> +        {
> +            struct timespec *tsp, ts[2];
> +            if (!arg3) {
> +                tsp = NULL;
> +            } else {
> +                if (target_to_host_timespec64(ts, arg3)) {
> +                    return -TARGET_EFAULT;
> +                }
> +                if (target_to_host_timespec64(ts + 1, arg3 +
> +                                     sizeof(struct target__kernel_timespec))) {
> +                    return -TARGET_EFAULT;
> +                }
> +                tsp = ts;
> +            }
> +            if (!arg2)
> +                ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
> +            else {
> +                p = lock_user_string(arg2);
> +                if (!p) {
> +                    return -TARGET_EFAULT;
> +                }
> +                ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
> +                unlock_user(p, arg2, 0);
> +            }
> +        }
> +        return ret;
> +#endif
>  #ifdef TARGET_NR_futex
>      case TARGET_NR_futex:
>          return do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
> 

Applied to my linux-user-for-5.2 branch.

Thanks,
Laurent

Re: [PATCH v2 2/2] linux-user: Add support for utimensat_time64() and semtimedop_time64()

[Laurent Vivier]

Le 25/08/2020 à 09:18, Laurent Vivier a écrit :
> Le 25/08/2020 à 00:30, Filip Bozuta a écrit :
>> This patch introduces functionality for following time64 syscalls:
>>
>> *utimensat_time64()
>>
>>     int utimensat(int dirfd, const char *pathname,
>>                   const struct timespec times[2], int flags);
>>     -- change file timestamps with nanosecond precision --
>>     man page: https://man7.org/linux/man-pages/man2/utimensat.2.html
>>
>> *semtimedop_time64()
>>
>>     int semtimedop(int semid, struct sembuf *sops, size_t nsops,
>>                    const struct timespec *timeout);
>>     -- System V semaphore operations --
>>     man page: https://www.man7.org/linux/man-pages/man2/semtimedop.2.html
>>
>> Implementation notes:
>>
>>    Syscall 'utimensat_time64()' is implemented in similar way as its
>>    regular variants only difference being that time64 converting function
>>    is used to convert values of 'struct timespec' between host and target
>>    ('target_to_host_timespec64()').
>>
>>    For syscall 'semtimedop_time64()' and additional argument is added
>>    in function 'do_semtimedop()' through which the aproppriate 'struct timespec'
>>    converting function is called (false for regular target_to_host_timespec()
>>    and true for target_to_host_timespec64()). For 'do_ipc()' a
>>    check was added as that additional argument: 'TARGET_ABI_BITS == 64'.
>>
>> Signed-off-by: Filip Bozuta <Filip.Bozuta@syrmia.com>
>> Reviewed-by: Laurent Vivier <laurent@vivier.eu>
>> ---
>>  linux-user/syscall.c | 60 ++++++++++++++++++++++++++++++++++++--------
>>  1 file changed, 50 insertions(+), 10 deletions(-)
>>
>> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
>> index fc6a6e32e4..4d460af744 100644
>> --- a/linux-user/syscall.c
>> +++ b/linux-user/syscall.c
>> @@ -1253,7 +1253,8 @@ static inline abi_long target_to_host_timespec(struct timespec *host_ts,
>>  #endif
>>  
>>  #if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
>> -    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
>> +    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64) || \
>> +    defined(TARGET_NR_utimensat_time64) || defined(TARGET_NR_semtimedop_time64)
>>  static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
>>                                                   abi_ulong target_addr)
>>  {
>> @@ -4117,7 +4118,7 @@ static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
>>  }
>>  
>>  #if defined(TARGET_NR_ipc) || defined(TARGET_NR_semop) || \
>> -    defined(TARGET_NR_semtimedop)
>> +    defined(TARGET_NR_semtimedop) || defined(TARGET_NR_semtimedop_time64)
>>  
>>  /*
>>   * This macro is required to handle the s390 variants, which passes the
>> @@ -4134,7 +4135,7 @@ static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
>>  static inline abi_long do_semtimedop(int semid,
>>                                       abi_long ptr,
>>                                       unsigned nsops,
>> -                                     abi_long timeout)
>> +                                     abi_long timeout, bool time64)
>>  {
>>      struct sembuf sops[nsops];
>>      struct timespec ts, *pts = NULL;
>> @@ -4142,8 +4143,14 @@ static inline abi_long do_semtimedop(int semid,
>>  
>>      if (timeout) {
>>          pts = &ts;
>> -        if (target_to_host_timespec(pts, timeout)) {
>> -            return -TARGET_EFAULT;
>> +        if (time64) {
>> +            if (target_to_host_timespec64(pts, timeout)) {
>> +                return -TARGET_EFAULT;
>> +            }
>> +        } else {
>> +            if (target_to_host_timespec(pts, timeout)) {
>> +                return -TARGET_EFAULT;
>> +            }
>>          }
>>      }
>>  
>> @@ -4657,7 +4664,7 @@ static abi_long do_ipc(CPUArchState *cpu_env,
>>  
>>      switch (call) {
>>      case IPCOP_semop:
>> -        ret = do_semtimedop(first, ptr, second, 0);
>> +        ret = do_semtimedop(first, ptr, second, 0, false);
>>          break;
>>      case IPCOP_semtimedop:
>>      /*
>> @@ -4667,9 +4674,9 @@ static abi_long do_ipc(CPUArchState *cpu_env,
>>       * to a struct timespec where the generic variant uses fifth parameter.
>>       */
>>  #if defined(TARGET_S390X)
>> -        ret = do_semtimedop(first, ptr, second, third);
>> +        ret = do_semtimedop(first, ptr, second, third, TARGET_ABI_BITS == 64);
>>  #else
>> -        ret = do_semtimedop(first, ptr, second, fifth);
>> +        ret = do_semtimedop(first, ptr, second, fifth, TARGET_ABI_BITS == 64);
>>  #endif
>>          break;
>>  
>> @@ -9887,11 +9894,15 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>>  #endif
>>  #ifdef TARGET_NR_semop
>>      case TARGET_NR_semop:
>> -        return do_semtimedop(arg1, arg2, arg3, 0);
>> +        return do_semtimedop(arg1, arg2, arg3, 0, false);
>>  #endif
>>  #ifdef TARGET_NR_semtimedop
>>      case TARGET_NR_semtimedop:
>> -        return do_semtimedop(arg1, arg2, arg3, arg4);
>> +        return do_semtimedop(arg1, arg2, arg3, arg4, false);
>> +#endif
>> +#ifdef TARGET_NR_semtimedop_time64
>> +    case TARGET_NR_semtimedop_time64:
>> +        return do_semtimedop(arg1, arg2, arg3, arg4, true);
>>  #endif
>>  #ifdef TARGET_NR_semctl
>>      case TARGET_NR_semctl:
>> @@ -11938,6 +11949,35 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>>          }
>>          return ret;
>>  #endif
>> +#ifdef TARGET_NR_utimensat_time64
>> +    case TARGET_NR_utimensat_time64:
>> +        {
>> +            struct timespec *tsp, ts[2];
>> +            if (!arg3) {
>> +                tsp = NULL;
>> +            } else {
>> +                if (target_to_host_timespec64(ts, arg3)) {
>> +                    return -TARGET_EFAULT;
>> +                }
>> +                if (target_to_host_timespec64(ts + 1, arg3 +
>> +                                     sizeof(struct target__kernel_timespec))) {
>> +                    return -TARGET_EFAULT;
>> +                }
>> +                tsp = ts;
>> +            }
>> +            if (!arg2)
>> +                ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
>> +            else {
>> +                p = lock_user_string(arg2);
>> +                if (!p) {
>> +                    return -TARGET_EFAULT;
>> +                }
>> +                ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
>> +                unlock_user(p, arg2, 0);
>> +            }
>> +        }
>> +        return ret;
>> +#endif
>>  #ifdef TARGET_NR_futex
>>      case TARGET_NR_futex:
>>          return do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
>>
> 
> Applied to my linux-user-for-5.2 branch.

I have removed it from my queue because the "TARGET_NR_utimensat_time64"
part breaks something (at least with sh4/sid on x86_64):

$ touch a
$ cp -p a b
/usr/bin/cp: preserving times for 'b': Invalid argument

Thanks,
Laurent

Re: [PATCH v2 2/2] linux-user: Add support for utimensat_time64() and semtimedop_time64()

[Laurent Vivier]

Le 25/08/2020 à 16:23, Laurent Vivier a écrit :
> Le 25/08/2020 à 09:18, Laurent Vivier a écrit :
>> Le 25/08/2020 à 00:30, Filip Bozuta a écrit :
>>> This patch introduces functionality for following time64 syscalls:
>>>
>>> *utimensat_time64()
>>>
>>>     int utimensat(int dirfd, const char *pathname,
>>>                   const struct timespec times[2], int flags);
>>>     -- change file timestamps with nanosecond precision --
>>>     man page: https://man7.org/linux/man-pages/man2/utimensat.2.html
>>>
>>> *semtimedop_time64()
>>>
>>>     int semtimedop(int semid, struct sembuf *sops, size_t nsops,
>>>                    const struct timespec *timeout);
>>>     -- System V semaphore operations --
>>>     man page: https://www.man7.org/linux/man-pages/man2/semtimedop.2.html
>>>
>>> Implementation notes:
>>>
>>>    Syscall 'utimensat_time64()' is implemented in similar way as its
>>>    regular variants only difference being that time64 converting function
>>>    is used to convert values of 'struct timespec' between host and target
>>>    ('target_to_host_timespec64()').
>>>
>>>    For syscall 'semtimedop_time64()' and additional argument is added
>>>    in function 'do_semtimedop()' through which the aproppriate 'struct timespec'
>>>    converting function is called (false for regular target_to_host_timespec()
>>>    and true for target_to_host_timespec64()). For 'do_ipc()' a
>>>    check was added as that additional argument: 'TARGET_ABI_BITS == 64'.
>>>
>>> Signed-off-by: Filip Bozuta <Filip.Bozuta@syrmia.com>
>>> Reviewed-by: Laurent Vivier <laurent@vivier.eu>
>>> ---
>>>  linux-user/syscall.c | 60 ++++++++++++++++++++++++++++++++++++--------
>>>  1 file changed, 50 insertions(+), 10 deletions(-)
>>>
>>> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
>>> index fc6a6e32e4..4d460af744 100644
>>> --- a/linux-user/syscall.c
>>> +++ b/linux-user/syscall.c
>>> @@ -1253,7 +1253,8 @@ static inline abi_long target_to_host_timespec(struct timespec *host_ts,
>>>  #endif
>>>  
>>>  #if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
>>> -    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
>>> +    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64) || \
>>> +    defined(TARGET_NR_utimensat_time64) || defined(TARGET_NR_semtimedop_time64)
>>>  static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
>>>                                                   abi_ulong target_addr)
>>>  {
>>> @@ -4117,7 +4118,7 @@ static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
>>>  }
>>>  
>>>  #if defined(TARGET_NR_ipc) || defined(TARGET_NR_semop) || \
>>> -    defined(TARGET_NR_semtimedop)
>>> +    defined(TARGET_NR_semtimedop) || defined(TARGET_NR_semtimedop_time64)
>>>  
>>>  /*
>>>   * This macro is required to handle the s390 variants, which passes the
>>> @@ -4134,7 +4135,7 @@ static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
>>>  static inline abi_long do_semtimedop(int semid,
>>>                                       abi_long ptr,
>>>                                       unsigned nsops,
>>> -                                     abi_long timeout)
>>> +                                     abi_long timeout, bool time64)
>>>  {
>>>      struct sembuf sops[nsops];
>>>      struct timespec ts, *pts = NULL;
>>> @@ -4142,8 +4143,14 @@ static inline abi_long do_semtimedop(int semid,
>>>  
>>>      if (timeout) {
>>>          pts = &ts;
>>> -        if (target_to_host_timespec(pts, timeout)) {
>>> -            return -TARGET_EFAULT;
>>> +        if (time64) {
>>> +            if (target_to_host_timespec64(pts, timeout)) {
>>> +                return -TARGET_EFAULT;
>>> +            }
>>> +        } else {
>>> +            if (target_to_host_timespec(pts, timeout)) {
>>> +                return -TARGET_EFAULT;
>>> +            }
>>>          }
>>>      }
>>>  
>>> @@ -4657,7 +4664,7 @@ static abi_long do_ipc(CPUArchState *cpu_env,
>>>  
>>>      switch (call) {
>>>      case IPCOP_semop:
>>> -        ret = do_semtimedop(first, ptr, second, 0);
>>> +        ret = do_semtimedop(first, ptr, second, 0, false);
>>>          break;
>>>      case IPCOP_semtimedop:
>>>      /*
>>> @@ -4667,9 +4674,9 @@ static abi_long do_ipc(CPUArchState *cpu_env,
>>>       * to a struct timespec where the generic variant uses fifth parameter.
>>>       */
>>>  #if defined(TARGET_S390X)
>>> -        ret = do_semtimedop(first, ptr, second, third);
>>> +        ret = do_semtimedop(first, ptr, second, third, TARGET_ABI_BITS == 64);
>>>  #else
>>> -        ret = do_semtimedop(first, ptr, second, fifth);
>>> +        ret = do_semtimedop(first, ptr, second, fifth, TARGET_ABI_BITS == 64);
>>>  #endif
>>>          break;
>>>  
>>> @@ -9887,11 +9894,15 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>>>  #endif
>>>  #ifdef TARGET_NR_semop
>>>      case TARGET_NR_semop:
>>> -        return do_semtimedop(arg1, arg2, arg3, 0);
>>> +        return do_semtimedop(arg1, arg2, arg3, 0, false);
>>>  #endif
>>>  #ifdef TARGET_NR_semtimedop
>>>      case TARGET_NR_semtimedop:
>>> -        return do_semtimedop(arg1, arg2, arg3, arg4);
>>> +        return do_semtimedop(arg1, arg2, arg3, arg4, false);
>>> +#endif
>>> +#ifdef TARGET_NR_semtimedop_time64
>>> +    case TARGET_NR_semtimedop_time64:
>>> +        return do_semtimedop(arg1, arg2, arg3, arg4, true);
>>>  #endif
>>>  #ifdef TARGET_NR_semctl
>>>      case TARGET_NR_semctl:
>>> @@ -11938,6 +11949,35 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>>>          }
>>>          return ret;
>>>  #endif
>>> +#ifdef TARGET_NR_utimensat_time64
>>> +    case TARGET_NR_utimensat_time64:
>>> +        {
>>> +            struct timespec *tsp, ts[2];
>>> +            if (!arg3) {
>>> +                tsp = NULL;
>>> +            } else {
>>> +                if (target_to_host_timespec64(ts, arg3)) {
>>> +                    return -TARGET_EFAULT;
>>> +                }
>>> +                if (target_to_host_timespec64(ts + 1, arg3 +
>>> +                                     sizeof(struct target__kernel_timespec))) {
>>> +                    return -TARGET_EFAULT;
>>> +                }
>>> +                tsp = ts;
>>> +            }
>>> +            if (!arg2)
>>> +                ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
>>> +            else {
>>> +                p = lock_user_string(arg2);
>>> +                if (!p) {
>>> +                    return -TARGET_EFAULT;
>>> +                }
>>> +                ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
>>> +                unlock_user(p, arg2, 0);
>>> +            }
>>> +        }
>>> +        return ret;
>>> +#endif
>>>  #ifdef TARGET_NR_futex
>>>      case TARGET_NR_futex:
>>>          return do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
>>>
>>
>> Applied to my linux-user-for-5.2 branch.
> 
> I have removed it from my queue because the "TARGET_NR_utimensat_time64"
> part breaks something (at least with sh4/sid on x86_64):
> 
> $ touch a
> $ cp -p a b
> /usr/bin/cp: preserving times for 'b': Invalid argument

In fact, on sh4, he timespec64 conversion is broken for all syscalls.
tv_sec is ok but tv_nsec is totally corrupted (as it would be only a
32bit value).

Thanks,
Laurent

Re: [PATCH v2 2/2] linux-user: Add support for utimensat_time64() and semtimedop_time64()

[Laurent Vivier]

Le 26/08/2020 à 15:58, Laurent Vivier a écrit :
> Le 25/08/2020 à 16:23, Laurent Vivier a écrit :
>> Le 25/08/2020 à 09:18, Laurent Vivier a écrit :
>>> Le 25/08/2020 à 00:30, Filip Bozuta a écrit :
>>>> This patch introduces functionality for following time64 syscalls:
>>>>
>>>> *utimensat_time64()
>>>>
>>>>     int utimensat(int dirfd, const char *pathname,
>>>>                   const struct timespec times[2], int flags);
>>>>     -- change file timestamps with nanosecond precision --
>>>>     man page: https://man7.org/linux/man-pages/man2/utimensat.2.html
>>>>
>>>> *semtimedop_time64()
>>>>
>>>>     int semtimedop(int semid, struct sembuf *sops, size_t nsops,
>>>>                    const struct timespec *timeout);
>>>>     -- System V semaphore operations --
>>>>     man page: https://www.man7.org/linux/man-pages/man2/semtimedop.2.html
>>>>
>>>> Implementation notes:
>>>>
>>>>    Syscall 'utimensat_time64()' is implemented in similar way as its
>>>>    regular variants only difference being that time64 converting function
>>>>    is used to convert values of 'struct timespec' between host and target
>>>>    ('target_to_host_timespec64()').
>>>>
>>>>    For syscall 'semtimedop_time64()' and additional argument is added
>>>>    in function 'do_semtimedop()' through which the aproppriate 'struct timespec'
>>>>    converting function is called (false for regular target_to_host_timespec()
>>>>    and true for target_to_host_timespec64()). For 'do_ipc()' a
>>>>    check was added as that additional argument: 'TARGET_ABI_BITS == 64'.
>>>>
>>>> Signed-off-by: Filip Bozuta <Filip.Bozuta@syrmia.com>
>>>> Reviewed-by: Laurent Vivier <laurent@vivier.eu>
>>>> ---
>>>>  linux-user/syscall.c | 60 ++++++++++++++++++++++++++++++++++++--------
>>>>  1 file changed, 50 insertions(+), 10 deletions(-)
>>>>
>>>> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
>>>> index fc6a6e32e4..4d460af744 100644
>>>> --- a/linux-user/syscall.c
>>>> +++ b/linux-user/syscall.c
>>>> @@ -1253,7 +1253,8 @@ static inline abi_long target_to_host_timespec(struct timespec *host_ts,
>>>>  #endif
>>>>  
>>>>  #if defined(TARGET_NR_clock_settime64) || defined(TARGET_NR_futex_time64) || \
>>>> -    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64)
>>>> +    defined(TARGET_NR_pselect6_time64) || defined(TARGET_NR_ppoll_time64) || \
>>>> +    defined(TARGET_NR_utimensat_time64) || defined(TARGET_NR_semtimedop_time64)
>>>>  static inline abi_long target_to_host_timespec64(struct timespec *host_ts,
>>>>                                                   abi_ulong target_addr)
>>>>  {
>>>> @@ -4117,7 +4118,7 @@ static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
>>>>  }
>>>>  
>>>>  #if defined(TARGET_NR_ipc) || defined(TARGET_NR_semop) || \
>>>> -    defined(TARGET_NR_semtimedop)
>>>> +    defined(TARGET_NR_semtimedop) || defined(TARGET_NR_semtimedop_time64)
>>>>  
>>>>  /*
>>>>   * This macro is required to handle the s390 variants, which passes the
>>>> @@ -4134,7 +4135,7 @@ static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf,
>>>>  static inline abi_long do_semtimedop(int semid,
>>>>                                       abi_long ptr,
>>>>                                       unsigned nsops,
>>>> -                                     abi_long timeout)
>>>> +                                     abi_long timeout, bool time64)
>>>>  {
>>>>      struct sembuf sops[nsops];
>>>>      struct timespec ts, *pts = NULL;
>>>> @@ -4142,8 +4143,14 @@ static inline abi_long do_semtimedop(int semid,
>>>>  
>>>>      if (timeout) {
>>>>          pts = &ts;
>>>> -        if (target_to_host_timespec(pts, timeout)) {
>>>> -            return -TARGET_EFAULT;
>>>> +        if (time64) {
>>>> +            if (target_to_host_timespec64(pts, timeout)) {
>>>> +                return -TARGET_EFAULT;
>>>> +            }
>>>> +        } else {
>>>> +            if (target_to_host_timespec(pts, timeout)) {
>>>> +                return -TARGET_EFAULT;
>>>> +            }
>>>>          }
>>>>      }
>>>>  
>>>> @@ -4657,7 +4664,7 @@ static abi_long do_ipc(CPUArchState *cpu_env,
>>>>  
>>>>      switch (call) {
>>>>      case IPCOP_semop:
>>>> -        ret = do_semtimedop(first, ptr, second, 0);
>>>> +        ret = do_semtimedop(first, ptr, second, 0, false);
>>>>          break;
>>>>      case IPCOP_semtimedop:
>>>>      /*
>>>> @@ -4667,9 +4674,9 @@ static abi_long do_ipc(CPUArchState *cpu_env,
>>>>       * to a struct timespec where the generic variant uses fifth parameter.
>>>>       */
>>>>  #if defined(TARGET_S390X)
>>>> -        ret = do_semtimedop(first, ptr, second, third);
>>>> +        ret = do_semtimedop(first, ptr, second, third, TARGET_ABI_BITS == 64);
>>>>  #else
>>>> -        ret = do_semtimedop(first, ptr, second, fifth);
>>>> +        ret = do_semtimedop(first, ptr, second, fifth, TARGET_ABI_BITS == 64);
>>>>  #endif
>>>>          break;
>>>>  
>>>> @@ -9887,11 +9894,15 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>>>>  #endif
>>>>  #ifdef TARGET_NR_semop
>>>>      case TARGET_NR_semop:
>>>> -        return do_semtimedop(arg1, arg2, arg3, 0);
>>>> +        return do_semtimedop(arg1, arg2, arg3, 0, false);
>>>>  #endif
>>>>  #ifdef TARGET_NR_semtimedop
>>>>      case TARGET_NR_semtimedop:
>>>> -        return do_semtimedop(arg1, arg2, arg3, arg4);
>>>> +        return do_semtimedop(arg1, arg2, arg3, arg4, false);
>>>> +#endif
>>>> +#ifdef TARGET_NR_semtimedop_time64
>>>> +    case TARGET_NR_semtimedop_time64:
>>>> +        return do_semtimedop(arg1, arg2, arg3, arg4, true);
>>>>  #endif
>>>>  #ifdef TARGET_NR_semctl
>>>>      case TARGET_NR_semctl:
>>>> @@ -11938,6 +11949,35 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
>>>>          }
>>>>          return ret;
>>>>  #endif
>>>> +#ifdef TARGET_NR_utimensat_time64
>>>> +    case TARGET_NR_utimensat_time64:
>>>> +        {
>>>> +            struct timespec *tsp, ts[2];
>>>> +            if (!arg3) {
>>>> +                tsp = NULL;
>>>> +            } else {
>>>> +                if (target_to_host_timespec64(ts, arg3)) {
>>>> +                    return -TARGET_EFAULT;
>>>> +                }
>>>> +                if (target_to_host_timespec64(ts + 1, arg3 +
>>>> +                                     sizeof(struct target__kernel_timespec))) {
>>>> +                    return -TARGET_EFAULT;
>>>> +                }
>>>> +                tsp = ts;
>>>> +            }
>>>> +            if (!arg2)
>>>> +                ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));
>>>> +            else {
>>>> +                p = lock_user_string(arg2);
>>>> +                if (!p) {
>>>> +                    return -TARGET_EFAULT;
>>>> +                }
>>>> +                ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));
>>>> +                unlock_user(p, arg2, 0);
>>>> +            }
>>>> +        }
>>>> +        return ret;
>>>> +#endif
>>>>  #ifdef TARGET_NR_futex
>>>>      case TARGET_NR_futex:
>>>>          return do_futex(arg1, arg2, arg3, arg4, arg5, arg6);
>>>>
>>>
>>> Applied to my linux-user-for-5.2 branch.
>>
>> I have removed it from my queue because the "TARGET_NR_utimensat_time64"
>> part breaks something (at least with sh4/sid on x86_64):
>>
>> $ touch a
>> $ cp -p a b
>> /usr/bin/cp: preserving times for 'b': Invalid argument
> 
> In fact, on sh4, he timespec64 conversion is broken for all syscalls.
> tv_sec is ok but tv_nsec is totally corrupted (as it would be only a
> 32bit value).

In kernel, in get_timespec64(), we have:

            /* In 32-bit mode, this drops the padding */
            ts->tv_nsec = kts.tv_nsec;

and ts is "struct timespec64" (kts is __kernel_timespec):

    struct timespec64 {
            time64_t        tv_sec;                 /* seconds */
            long            tv_nsec;                /* nanoseconds */
    };

So I think we need something like:

diff --git a/linux-user/syscall.c b/linux-user/syscall.c
index c82b73e03234..5f53d5d65eb6 100644
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -1253,6 +1253,8 @@ static inline abi_long
target_to_host_timespec64(struct timespec *host_ts,
     }
     __get_user(host_ts->tv_sec, &target_ts->tv_sec);
     __get_user(host_ts->tv_nsec, &target_ts->tv_nsec);
+    /* in 32bit mode this drops the padding */
+    host_ts->tv_nsec = (abi_long)host_ts->tv_nsec;
     unlock_user_struct(target_ts, target_addr, 0);
     return 0;
 }

Thanks,
Laurent