diff --git a/extra/Configs/Config.in b/extra/Configs/Config.in
index 9351dffc8..f11a63b79 100644
--- a/extra/Configs/Config.in
+++ b/extra/Configs/Config.in
@@ -1026,7 +1026,7 @@ config UCLIBC_FALLBACK_TO_ETC_LOCALTIME
 
 config UCLIBC_USE_TIME64
 	bool "Use *time64 syscalls instead of 32bit ones (if possible)"
-	depends on TARGET_arm || TARGET_xtensa
+	depends on TARGET_arm || TARGET_powerpc || TARGET_xtensa
 	# TODO: add support for other architectures
 	default n
 
diff --git a/libc/inet/socketcalls.c b/libc/inet/socketcalls.c
index eb0983698..7ec439887 100644
--- a/libc/inet/socketcalls.c
+++ b/libc/inet/socketcalls.c
@@ -268,12 +268,26 @@ lt_libc_hidden(recvmsg)
 #endif
 
 #ifdef L_recvmmsg
+
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+    __S64_TYPE tv_sec;
+    __S64_TYPE tv_nsec;
+};
+
+#endif
+
 #ifdef __ASSUME_RECVMMSG_SYSCALL
 static ssize_t __NC(recvmmsg)(int sockfd, struct mmsghdr *msg, size_t vlen,
 			      int flags, struct timespec *tmo)
 {
 # if defined(__UCLIBC_USE_TIME64__) && defined(__NR_recvmmsg_time64)
-	return (ssize_t)INLINE_SYSCALL(recvmmsg_time64, 5, sockfd, msg, vlen, flags, tmo);
+	struct ts64_struct __ts64 = {
+		.tv_sec = tmo ? tmo->tv_sec : 0,
+		.tv_nsec = tmo ? tmo->tv_nsec : 0
+	};
+	return (ssize_t)INLINE_SYSCALL(recvmmsg_time64, 5, sockfd, msg, vlen, flags, tmo ? &__ts64 : 0);
 # elif defined(__NR_recvmmsg)
 	return (ssize_t)INLINE_SYSCALL(recvmmsg, 5, sockfd, msg, vlen, flags, tmo);
 # elif __NR_socketcall
diff --git a/libc/misc/sysvipc/sem.c b/libc/misc/sysvipc/sem.c
index cd541761c..d0bd0ba28 100644
--- a/libc/misc/sysvipc/sem.c
+++ b/libc/misc/sysvipc/sem.c
@@ -96,7 +96,21 @@ int semop (int semid, struct sembuf *sops, size_t nsops)
 #ifdef L_semtimedop
 
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_semtimedop_time64)
-_syscall4_time64(int, semtimedop, int, semid, struct sembuf *, sops, size_t, nsops, const struct timespec *, timeout)
+
+struct ts64_struct {
+    __S64_TYPE tv_sec;
+    __S64_TYPE tv_nsec;
+};
+
+int semtimedop(int semid, struct sembuf *sops, size_t nsops, const struct timespec *timeout) {
+    struct ts64_struct __ts64 = {
+        .tv_sec = timeout ? timeout->tv_sec : 0,
+        .tv_nsec = timeout ? timeout->tv_nsec : 0
+    };
+
+    return INLINE_SYSCALL(semtimedop_time64, 4, semid, sops, nsops, timeout ? &__ts64 : 0);
+}
+
 #elif defined(__NR_semtimedop)
 _syscall4(int, semtimedop, int, semid, struct sembuf *, sops, size_t, nsops, const struct timespec *, timeout)
 
diff --git a/libc/signal/sigwait.c b/libc/signal/sigwait.c
index 3557a039e..b237534cd 100644
--- a/libc/signal/sigwait.c
+++ b/libc/signal/sigwait.c
@@ -24,7 +24,8 @@
 #include <signal.h>
 #include <cancel.h>
 
-#if defined __NR_rt_sigtimedwait && defined __UCLIBC_HAS_REALTIME__
+#if (defined(__NR_rt_sigtimedwait) || (defined(__UCLIBC_USE_TIME64__) && defined(__NR_rt_sigtimedwait_time64))) && \
+    defined(__UCLIBC_HAS_REALTIME__)
 
 #include <string.h>
 
diff --git a/libc/sysdeps/linux/common/__rt_sigtimedwait.c b/libc/sysdeps/linux/common/__rt_sigtimedwait.c
index bd82ca6d5..cd25fe177 100644
--- a/libc/sysdeps/linux/common/__rt_sigtimedwait.c
+++ b/libc/sysdeps/linux/common/__rt_sigtimedwait.c
@@ -9,7 +9,7 @@
 
 #include <sys/syscall.h>
 
-#ifdef __NR_rt_sigtimedwait
+#if defined(__NR_rt_sigtimedwait) || (defined(__NR_rt_sigtimedwait_time64) && defined(__UCLIBC_USE_TIME64__))
 # include <signal.h>
 # include <cancel.h>
 # ifdef __UCLIBC_HAS_THREADS_NATIVE__
@@ -21,6 +21,15 @@
 #  include <string.h>
 # endif
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+	__S64_TYPE tv_sec;
+	__S64_TYPE tv_nsec;
+};
+
+#endif
+
 int __NC(sigtimedwait)(const sigset_t *set, siginfo_t *info,
 		       const struct timespec *timeout)
 {
@@ -53,8 +62,12 @@ int __NC(sigtimedwait)(const sigset_t *set, siginfo_t *info,
 	   real size of the user-level sigset_t.  */
 	/* on uClibc we use the kernel sigset_t size */
 # if defined(__UCLIBC_USE_TIME64__) && defined(__NR_rt_sigtimedwait_time64)
+	struct ts64_struct __ts64 = {
+		.tv_sec = timeout ? timeout->tv_sec : 0,
+		.tv_nsec = timeout ? timeout->tv_nsec : 0
+	};
 	result = INLINE_SYSCALL(rt_sigtimedwait_time64, 4, set, info,
-				    timeout, __SYSCALL_SIGSET_T_SIZE);
+				    timeout ? &__ts64 : 0, __SYSCALL_SIGSET_T_SIZE);
 # else
 	result = INLINE_SYSCALL(rt_sigtimedwait, 4, set, info,
 				    timeout, __SYSCALL_SIGSET_T_SIZE);
@@ -71,8 +84,12 @@ int __NC(sigtimedwait)(const sigset_t *set, siginfo_t *info,
 # else
 	/* on uClibc we use the kernel sigset_t size */
 # if defined(__UCLIBC_USE_TIME64__) && defined(__NR_rt_sigtimedwait_time64)
+	struct ts64_struct __ts64 = {
+		.tv_sec = timeout ? timeout->tv_sec : 0,
+		.tv_nsec = timeout ? timeout->tv_nsec : 0
+	};
 	return INLINE_SYSCALL(rt_sigtimedwait_time64, 4, set, info,
-			      timeout, __SYSCALL_SIGSET_T_SIZE);
+			      timeout ? &__ts64 : 0, __SYSCALL_SIGSET_T_SIZE);
 # else
 	return INLINE_SYSCALL(rt_sigtimedwait, 4, set, info,
 			      timeout, __SYSCALL_SIGSET_T_SIZE);
diff --git a/libc/sysdeps/linux/common/__rt_sigwaitinfo.c b/libc/sysdeps/linux/common/__rt_sigwaitinfo.c
index d2d176a64..7830b2e2c 100644
--- a/libc/sysdeps/linux/common/__rt_sigwaitinfo.c
+++ b/libc/sysdeps/linux/common/__rt_sigwaitinfo.c
@@ -9,7 +9,7 @@
 
 #include <sys/syscall.h>
 
-#ifdef __NR_rt_sigtimedwait
+#if defined(__NR_rt_sigtimedwait) || (defined(__UCLIBC_USE_TIME64__) && defined(__NR_rt_sigtimedwait_time64))
 # define __need_NULL
 # include <stddef.h>
 # include <signal.h>
diff --git a/libc/sysdeps/linux/common/alarm.c b/libc/sysdeps/linux/common/alarm.c
index 4e6e2215b..861f6ad8e 100644
--- a/libc/sysdeps/linux/common/alarm.c
+++ b/libc/sysdeps/linux/common/alarm.c
@@ -9,7 +9,7 @@
 #include <sys/syscall.h>
 #include <unistd.h>
 
-#ifdef __NR_alarm && !defined(__UCLIBC_USE_TIME64__)
+#if defined(__NR_alarm) && !defined(__UCLIBC_USE_TIME64__)
 _syscall1(unsigned int, alarm, unsigned int, seconds)
 #else
 # include <sys/time.h>
diff --git a/libc/sysdeps/linux/common/clock_getres.c b/libc/sysdeps/linux/common/clock_getres.c
index d4b989958..c72b0a21c 100644
--- a/libc/sysdeps/linux/common/clock_getres.c
+++ b/libc/sysdeps/linux/common/clock_getres.c
@@ -10,9 +10,27 @@
 #include <sys/syscall.h>
 #include <time.h>
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+	__S64_TYPE tv_sec;
+	__S64_TYPE tv_nsec;
+};
+
+#endif
 
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_clock_getres_time64)
-_syscall2_time64(int, clock_getres, clockid_t, clock_id, struct timespec*, res)
+int clock_getres(clockid_t clock_id, struct timespec *res)
+{
+	struct ts64_struct __ts64;
+	int __ret = INLINE_SYSCALL(clock_getres_time64, 2, clock_id, &__ts64);
+	if (__ret == 0 && res) {
+		res->tv_sec = __ts64.tv_sec;
+		res->tv_nsec = __ts64.tv_nsec;
+	};
+
+	return __ret;
+}
 #elif defined(__NR_clock_getres)
 _syscall2(int, clock_getres, clockid_t, clock_id, struct timespec*, res)
 #else
diff --git a/libc/sysdeps/linux/common/clock_gettime.c b/libc/sysdeps/linux/common/clock_gettime.c
index a595bd691..dbb767c94 100644
--- a/libc/sysdeps/linux/common/clock_gettime.c
+++ b/libc/sysdeps/linux/common/clock_gettime.c
@@ -11,8 +11,27 @@
 #include <sys/syscall.h>
 #include <time.h>
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+	__S64_TYPE tv_sec;
+	__S64_TYPE tv_nsec;
+};
+
+#endif
+
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_clock_gettime64)
-_syscall2_64(int, clock_gettime, clockid_t, clock_id, struct timespec*, tp)
+int clock_gettime(clockid_t clock_id, struct timespec *tp)
+{
+	struct ts64_struct __ts64;
+	int __ret = INLINE_SYSCALL(clock_gettime64, 2, clock_id, &__ts64);
+	if (tp) {
+		tp->tv_sec = __ts64.tv_sec;
+		tp->tv_nsec = __ts64.tv_nsec;
+	}
+
+	return __ret;
+}
 #elif defined(__NR_clock_gettime)
 _syscall2(int, clock_gettime, clockid_t, clock_id, struct timespec*, tp)
 #else
diff --git a/libc/sysdeps/linux/common/clock_settime.c b/libc/sysdeps/linux/common/clock_settime.c
index 89550af5a..54bfa20e8 100644
--- a/libc/sysdeps/linux/common/clock_settime.c
+++ b/libc/sysdeps/linux/common/clock_settime.c
@@ -12,7 +12,22 @@
 
 
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_clock_settime64)
-_syscall2_64(int, clock_settime, clockid_t, clock_id, const struct timespec*, tp)
+
+struct ts64_struct {
+	__S64_TYPE tv_sec;
+	__S64_TYPE tv_nsec;
+};
+
+int clock_settime(clockid_t clock_id, const struct timespec *tp)
+{
+	struct ts64_struct __ts64 = {
+		.tv_sec = tp->tv_sec,
+		.tv_nsec = tp->tv_nsec
+	};
+
+	return INLINE_SYSCALL(clock_settime64, 2, clock_id, &__ts64);
+}
+
 #elif defined(__NR_clock_settime)
 _syscall2(int, clock_settime, clockid_t, clock_id, const struct timespec*, tp)
 #else
diff --git a/libc/sysdeps/linux/common/ppoll.c b/libc/sysdeps/linux/common/ppoll.c
index cb36149c5..16d836b6f 100644
--- a/libc/sysdeps/linux/common/ppoll.c
+++ b/libc/sysdeps/linux/common/ppoll.c
@@ -26,6 +26,15 @@
 #include <sys/poll.h>
 #include <cancel.h>
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+   __S64_TYPE tv_sec;
+   __S64_TYPE tv_nsec;
+};
+
+#endif
+
 static int
 __NC(ppoll)(struct pollfd *fds, nfds_t nfds, const struct timespec *timeout,
 	    const sigset_t *sigmask)
@@ -38,7 +47,11 @@ __NC(ppoll)(struct pollfd *fds, nfds_t nfds, const struct timespec *timeout,
 		timeout = &tval;
 	}
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_ppoll_time64)
-	return INLINE_SYSCALL(ppoll_time64, 5, fds, nfds, timeout, sigmask, __SYSCALL_SIGSET_T_SIZE);
+   struct ts64_struct __ts64 = {
+      .tv_sec = timeout ? timeout->tv_sec : 0,
+      .tv_nsec = timeout ? timeout->tv_nsec : 0
+   };
+	return INLINE_SYSCALL(ppoll_time64, 5, fds, nfds, timeout ? &__ts64 : 0, sigmask, __SYSCALL_SIGSET_T_SIZE);
 #else
 	return INLINE_SYSCALL(ppoll, 5, fds, nfds, timeout, sigmask, __SYSCALL_SIGSET_T_SIZE);
 #endif
diff --git a/libc/sysdeps/linux/common/pselect.c b/libc/sysdeps/linux/common/pselect.c
index 23bdab5cf..a189624ec 100644
--- a/libc/sysdeps/linux/common/pselect.c
+++ b/libc/sysdeps/linux/common/pselect.c
@@ -26,6 +26,15 @@
 #include <signal.h>
 #include <cancel.h>
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+    __S64_TYPE tv_sec;
+    __S64_TYPE tv_nsec;
+};
+
+#endif
+
 static int __NC(pselect)(int nfds, fd_set *readfds, fd_set *writefds,
 			 fd_set *exceptfds, const struct timespec *timeout,
 			 const sigset_t *sigmask)
@@ -57,7 +66,11 @@ static int __NC(pselect)(int nfds, fd_set *readfds, fd_set *writefds,
 		sigmask = (void *)&data;
 	}
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_pselect6_time64)
-	return INLINE_SYSCALL(pselect6_time64, 6, nfds, readfds, writefds, exceptfds, timeout, sigmask);
+	struct ts64_struct __ts64 = {
+		.tv_sec = timeout ? timeout->tv_sec : 0,
+		.tv_nsec = timeout ? timeout->tv_nsec : 0
+	};
+	return INLINE_SYSCALL(pselect6_time64, 6, nfds, readfds, writefds, exceptfds, timeout ? &__ts64 : 0, sigmask);
 #else
 	return INLINE_SYSCALL(pselect6, 6, nfds, readfds, writefds, exceptfds, timeout, sigmask);
 #endif
diff --git a/libc/sysdeps/linux/common/select.c b/libc/sysdeps/linux/common/select.c
index 3132a109c..a55a61df1 100644
--- a/libc/sysdeps/linux/common/select.c
+++ b/libc/sysdeps/linux/common/select.c
@@ -15,17 +15,22 @@
 # define __NR_select __NR__newselect
 #endif
 
-#if !defined __NR_select && defined __NR_pselect6
+#if defined(__NR_pselect6) || defined(__NR_pselect6_time64)
 # include <stdint.h>
 # define USEC_PER_SEC 1000000L
 #endif
 
+#if defined(__UCLIBC_USE_TIME64__)
+struct ts64_struct {
+    __S64_TYPE tv_sec;
+    __S64_TYPE tv_nsec;
+};
+#endif
+
 int __NC(select)(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 		 struct timeval *timeout)
 {
-#ifdef __NR_select
-	return INLINE_SYSCALL(select, 5, n, readfds, writefds, exceptfds, timeout);
-#elif defined __NR_pselect6
+#if defined(__NR_pselect6) || defined(__NR_pselect6_time64)
 	struct timespec _ts, *ts = 0;
 	if (timeout) {
 		uint32_t usec;
@@ -47,8 +52,18 @@ int __NC(select)(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 
 		ts = &_ts;
 	}
+#if defined(__UCLIBC_USE_TIME64__) && defined(__NR_pselect6_time64)
+	struct ts64_struct __ts64 = {
+		.tv_sec = ts ? ts->tv_sec : 0,
+		.tv_nsec = ts ? ts->tv_nsec : 0
+	};
+	return INLINE_SYSCALL(pselect6_time64, 6, n, readfds, writefds, exceptfds, timeout ? &__ts64 : 0, 0);
+#else
 	return INLINE_SYSCALL(pselect6, 6, n, readfds, writefds, exceptfds, ts, 0);
 #endif
+#elif defined(__NR_select)
+	return INLINE_SYSCALL(select, 5, n, readfds, writefds, exceptfds, timeout);
+#endif
 }
 /* we should guard it, but we need it in other files, so let it fail
  * if we miss any of the syscalls */
diff --git a/libc/sysdeps/linux/common/time.c b/libc/sysdeps/linux/common/time.c
index 22403f174..d084ffaad 100644
--- a/libc/sysdeps/linux/common/time.c
+++ b/libc/sysdeps/linux/common/time.c
@@ -9,7 +9,7 @@
 #include <sys/syscall.h>
 #include <time.h>
 
-#ifdef __NR_time
+#if defined(__NR_time) && !defined(__UCLIBC_USE_TIME64__)
 _syscall_noerr1(time_t, time, time_t *, t)
 #else
 # include <sys/time.h>
diff --git a/libc/sysdeps/linux/common/timerfd.c b/libc/sysdeps/linux/common/timerfd.c
index 0f19b44ed..04db6ed00 100644
--- a/libc/sysdeps/linux/common/timerfd.c
+++ b/libc/sysdeps/linux/common/timerfd.c
@@ -16,12 +16,33 @@
 _syscall2(int, timerfd_create, int, clockid, int, flags)
 #endif
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct its64_struct {
+    __S64_TYPE interval_tv_sec;
+    __S64_TYPE interval_tv_nsec;
+    __S64_TYPE value_tv_sec;
+    __S64_TYPE value_tv_nsec;
+};
+
+#endif
+
 /*
  * timerfd_settime()
  */
 #if defined(__NR_timerfd_settime) || defined(__NR_timerfd_settime64)
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_timerfd_settime64)
-_syscall4_64(int, timerfd_settime, int, ufd, int, flags, const struct itimerspec *, utmr, struct itimerspec *, otmr)
+int timerfd_settime(int ufd, int flags, const struct itimerspec *utmr, struct itimerspec *otmr)
+{
+    struct its64_struct __its64 = {
+        .interval_tv_sec = utmr->it_interval.tv_sec,
+        .interval_tv_nsec = utmr->it_interval.tv_nsec,
+        .value_tv_sec = utmr->it_value.tv_sec,
+        .value_tv_nsec = utmr->it_value.tv_nsec,
+    };
+
+    return INLINE_SYSCALL(timerfd_settime64, 4, ufd, flags, &__its64, otmr);
+}
 #else
 _syscall4(int, timerfd_settime, int, ufd, int, flags, const struct itimerspec *, utmr, struct itimerspec *, otmr)
 #endif
diff --git a/libc/sysdeps/linux/common/utimensat.c b/libc/sysdeps/linux/common/utimensat.c
index 6a78ebb4f..0c87b5c45 100644
--- a/libc/sysdeps/linux/common/utimensat.c
+++ b/libc/sysdeps/linux/common/utimensat.c
@@ -9,9 +9,30 @@
 #include <sys/syscall.h>
 #include <sys/stat.h>
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct uts64_struct {
+    __S64_TYPE tv_sec1;
+    __S64_TYPE tv_nsec1;
+    __S64_TYPE tv_sec2;
+    __S64_TYPE tv_nsec2;
+};
+
+#endif
+
 #if defined(__NR_utimensat) || defined(__NR_utimensat_time64)
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_utimensat_time64)
-_syscall4_time64(int, utimensat, int, fd, const char *, path, const struct timespec *, times, int, flags)
+int utimensat(int fd, const char *path, const struct timespec times[2], int flags)
+{
+    struct uts64_struct __uts64 = {
+        .tv_sec1 = times ? times[0].tv_sec : 0,
+        .tv_nsec1 = times ? times[0].tv_nsec : 0,
+        .tv_sec2 = times ? times[1].tv_sec : 0,
+        .tv_nsec2 = times ? times[1].tv_nsec : 0
+    };
+
+    return INLINE_SYSCALL(utimensat_time64, 4, fd, path, times ? &__uts64 : 0, flags);
+}
 #else
 _syscall4(int, utimensat, int, fd, const char *, path, const struct timespec *, times, int, flags)
 #endif
diff --git a/libc/sysdeps/linux/powerpc/bits/kernel_stat.h b/libc/sysdeps/linux/powerpc/bits/kernel_stat.h
index ce62b2ba2..0e76120ab 100644
--- a/libc/sysdeps/linux/powerpc/bits/kernel_stat.h
+++ b/libc/sysdeps/linux/powerpc/bits/kernel_stat.h
@@ -5,6 +5,16 @@
  * struct kernel_stat should look like...  It turns out each arch has a
  * different opinion on the subject... */
 
+#if defined(__UCLIBC_USE_TIME64__)
+#include <bits/types.h>
+
+struct ts32_struct {
+	__S32_TYPE tv_sec;
+	__S32_TYPE tv_nsec;
+};
+
+#endif
+
 #if __WORDSIZE == 64
 #define kernel_stat kernel_stat64
 #else
@@ -19,9 +29,15 @@ struct kernel_stat {
 	__kernel_off_t	st_size;
 	unsigned long  	st_blksize;
 	unsigned long  	st_blocks;
+#if defined(__UCLIBC_USE_TIME64__)
+	struct ts32_struct __st_atim32;
+	struct ts32_struct __st_mtim32;
+	struct ts32_struct __st_ctim32;
+#else
 	struct timespec	st_atim;
 	struct timespec	st_mtim;
 	struct timespec	st_ctim;
+#endif
 	unsigned long  	__unused4;
 	unsigned long  	__unused5;
 };
@@ -39,9 +55,15 @@ struct kernel_stat64 {
 	long long st_size;		/* Size of file, in bytes.  */
 	long st_blksize;		/* Optimal block size for I/O.  */
 	long long st_blocks;		/* Number 512-byte blocks allocated. */
-	struct timespec st_atim;	/* Time of last access.  */
-	struct timespec st_mtim;	/* Time of last modification.  */
-	struct timespec st_ctim;	/* Time of last status change.  */
+#if defined(__UCLIBC_USE_TIME64__)
+	struct ts32_struct __st_atim32;
+	struct ts32_struct __st_mtim32;
+	struct ts32_struct __st_ctim32;
+#else
+	struct timespec	st_atim;
+	struct timespec	st_mtim;
+	struct timespec	st_ctim;
+#endif
 	unsigned long int __uclibc_unused4;
 	unsigned long int __uclibc_unused5;
 };
diff --git a/libc/sysdeps/linux/powerpc/bits/sem.h b/libc/sysdeps/linux/powerpc/bits/sem.h
index a9d895374..8d338eac0 100644
--- a/libc/sysdeps/linux/powerpc/bits/sem.h
+++ b/libc/sysdeps/linux/powerpc/bits/sem.h
@@ -35,6 +35,7 @@
 #define SETALL         17              /* set all semval's */
 
 
+
 /* Data structure describing a set of semaphores.  */
 struct semid_ds
 {
@@ -42,16 +43,31 @@ struct semid_ds
 #if __WORDSIZE == 32
   unsigned int __uclibc_unused1;
 #endif
+#if defined(__UCLIBC_USE_TIME64__)
+  unsigned long int __sem_otime_internal_1; /* last semop() time */
+  unsigned long int __sem_otime_internal_2;
+#else
   __time_t sem_otime;                  /* last semop() time */
+#endif
 #if __WORDSIZE == 32
   unsigned int __uclibc_unused2;
 #endif
+#if defined(__UCLIBC_USE_TIME64__)
+  unsigned long int __sem_ctime_internal_1; /* last time changed by semctl() */
+  unsigned long int __sem_ctime_internal_2;
+#else
   __time_t sem_ctime;                  /* last time changed by semctl() */
+#endif
   unsigned long int sem_nsems;         /* number of semaphores in set */
+#if defined(__UCLIBC_USE_TIME64__)
+  __time_t sem_otime;
+  __time_t sem_ctime;
+#endif
   unsigned long __uclibc_unused3;
   unsigned long __uclibc_unused4;
 };
 
+
 /* The user should define a union like the following to use it for arguments
    for `semctl'.
 
diff --git a/libpthread/nptl/pthread_mutex_timedlock.c b/libpthread/nptl/pthread_mutex_timedlock.c
index 25f9ec3b2..d55495683 100644
--- a/libpthread/nptl/pthread_mutex_timedlock.c
+++ b/libpthread/nptl/pthread_mutex_timedlock.c
@@ -23,6 +23,15 @@
 #include <lowlevellock.h>
 #include <not-cancel.h>
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+    __S64_TYPE tv_sec;
+    __S64_TYPE tv_nsec;
+};
+
+#endif
+
 /* We need to build this function with optimization to avoid
  * lll_timedlock erroring out with
  * error: can't find a register in class ‘GENERAL_REGS’ while reloading ‘asm’
@@ -265,10 +274,14 @@ pthread_mutex_timedlock (
 	    INTERNAL_SYSCALL_DECL (__err);
 
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_futex_time64)
+	    struct ts64_struct __ts64 = {
+	        .tv_sec = abstime ? abstime->tv_sec : 0,
+	        .tv_nsec = abstime ? abstime->tv_nsec : 0
+	    };
 	    int e = INTERNAL_SYSCALL (futex_time64, __err, 4, &mutex->__data.__lock,
 				      __lll_private_flag (FUTEX_LOCK_PI,
 							  private), 1,
-				      abstime);
+				      &__ts64);
 #else
 	    int e = INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,
 				      __lll_private_flag (FUTEX_LOCK_PI,
@@ -454,7 +467,7 @@ pthread_mutex_timedlock (
 		      }
 
 		    struct timeval tv;
-		    struct timespec rt;
+		    struct timespec rt, *rtp;
 
 		    /* Get the current time.  */
 		    (void) gettimeofday (&tv, NULL);
@@ -475,8 +488,9 @@ pthread_mutex_timedlock (
 			goto failpp;
 		      }
 
+		    rtp = &rt;
 		    lll_futex_timed_wait (&mutex->__data.__lock,
-					  ceilval | 2, &rt,
+					  ceilval | 2, rtp,
 					  PTHREAD_MUTEX_PSHARED (mutex));
 		  }
 	      }
diff --git a/libpthread/nptl/sysdeps/pthread/pthread_cond_timedwait.c b/libpthread/nptl/sysdeps/pthread/pthread_cond_timedwait.c
index 49aab0293..1ea2a888a 100644
--- a/libpthread/nptl/sysdeps/pthread/pthread_cond_timedwait.c
+++ b/libpthread/nptl/sysdeps/pthread/pthread_cond_timedwait.c
@@ -95,7 +95,7 @@ __pthread_cond_timedwait (
 
   while (1)
     {
-      struct timespec rt;
+      struct timespec rt, *rtp;
       {
 #ifdef __NR_clock_gettime
 	INTERNAL_SYSCALL_DECL (err);
@@ -164,8 +164,9 @@ __pthread_cond_timedwait (
       cbuffer.oldtype = __pthread_enable_asynccancel ();
 
       /* Wait until woken by signal or broadcast.  */
+      rtp = &rt;
       err = lll_futex_timed_wait (&cond->__data.__futex,
-				  futex_val, &rt, pshared);
+				  futex_val, rtp, pshared);
 
       /* Disable asynchronous cancellation.  */
       __pthread_disable_asynccancel (cbuffer.oldtype);
diff --git a/libpthread/nptl/sysdeps/pthread/pthread_rwlock_timedrdlock.c b/libpthread/nptl/sysdeps/pthread/pthread_rwlock_timedrdlock.c
index 596f5df51..379e92b43 100644
--- a/libpthread/nptl/sysdeps/pthread/pthread_rwlock_timedrdlock.c
+++ b/libpthread/nptl/sysdeps/pthread/pthread_rwlock_timedrdlock.c
@@ -81,7 +81,7 @@ pthread_rwlock_timedrdlock (
       (void) gettimeofday (&tv, NULL);
 
       /* Convert the absolute timeout value to a relative timeout.  */
-      struct timespec rt;
+      struct timespec rt, *rtp;
       rt.tv_sec = abstime->tv_sec - tv.tv_sec;
       rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
       if (rt.tv_nsec < 0)
@@ -112,8 +112,9 @@ pthread_rwlock_timedrdlock (
       lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
       /* Wait for the writer to finish.  */
+      rtp = &rt;
       err = lll_futex_timed_wait (&rwlock->__data.__readers_wakeup,
-				  waitval, &rt, rwlock->__data.__shared);
+				  waitval, rtp, rwlock->__data.__shared);
 
       /* Get the lock.  */
       lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
diff --git a/libpthread/nptl/sysdeps/pthread/pthread_rwlock_timedwrlock.c b/libpthread/nptl/sysdeps/pthread/pthread_rwlock_timedwrlock.c
index 0b04b357a..3ce9f9b13 100644
--- a/libpthread/nptl/sysdeps/pthread/pthread_rwlock_timedwrlock.c
+++ b/libpthread/nptl/sysdeps/pthread/pthread_rwlock_timedwrlock.c
@@ -72,7 +72,7 @@ pthread_rwlock_timedwrlock (
       (void) gettimeofday (&tv, NULL);
 
       /* Convert the absolute timeout value to a relative timeout.  */
-      struct timespec rt;
+      struct timespec rt, *rtp;
       rt.tv_sec = abstime->tv_sec - tv.tv_sec;
       rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
       if (rt.tv_nsec < 0)
@@ -102,8 +102,9 @@ pthread_rwlock_timedwrlock (
       lll_unlock (rwlock->__data.__lock, rwlock->__data.__shared);
 
       /* Wait for the writer or reader(s) to finish.  */
+      rtp = &rt;
       err = lll_futex_timed_wait (&rwlock->__data.__writer_wakeup,
-				  waitval, &rt, rwlock->__data.__shared);
+				  waitval, rtp, rwlock->__data.__shared);
 
       /* Get the lock.  */
       lll_lock (rwlock->__data.__lock, rwlock->__data.__shared);
diff --git a/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevellock.c b/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevellock.c
index 4294a20b0..5f7301976 100644
--- a/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevellock.c
+++ b/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevellock.c
@@ -63,7 +63,7 @@ __lll_timedlock_wait (int *futex, const struct timespec *abstime, int private)
       (void) gettimeofday (&tv, NULL);
 
       /* Compute relative timeout.  */
-      struct timespec rt;
+      struct timespec rt, *rtp;
       rt.tv_sec = abstime->tv_sec - tv.tv_sec;
       rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
       if (rt.tv_nsec < 0)
@@ -76,7 +76,8 @@ __lll_timedlock_wait (int *futex, const struct timespec *abstime, int private)
 	return ETIMEDOUT;
 
       /* Wait.  */
-      lll_futex_timed_wait (futex, 2, &rt, private);
+      rtp = &rt;
+      lll_futex_timed_wait (futex, 2, rtp, private);
     }
 
   return 0;
@@ -95,7 +96,7 @@ __lll_timedwait_tid (int *tidp, const struct timespec *abstime)
   while ((tid = *tidp) != 0)
     {
       struct timeval tv;
-      struct timespec rt;
+      struct timespec rt, *rtp;
 
       /* Get the current time.  */
       (void) __gettimeofday (&tv, NULL);
@@ -115,7 +116,8 @@ __lll_timedwait_tid (int *tidp, const struct timespec *abstime)
 
       /* Wait until thread terminates.  The kernel so far does not use
 	 the private futex operations for this.  */
-      if (lll_futex_timed_wait (tidp, tid, &rt, LLL_SHARED) == -ETIMEDOUT)
+      rtp = &rt;
+      if (lll_futex_timed_wait (tidp, tid, rtp, LLL_SHARED) == -ETIMEDOUT)
 	return ETIMEDOUT;
     }
 
diff --git a/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevellock.h b/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevellock.h
index e72fe5234..4209a21d3 100644
--- a/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevellock.h
+++ b/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevellock.h
@@ -71,18 +71,49 @@
 # endif	      
 #endif
 
+#if defined(__UCLIBC_USE_TIME64__) && defined(__NR_futex_time64)
+
 #define lll_futex_wait(futexp, val, private) \
-  lll_futex_timed_wait(futexp, val, NULL, private)
+  ({									      \
+    INTERNAL_SYSCALL_DECL (__err);					      \
+    long int __ret;							      \
+    __ret = INTERNAL_SYSCALL (futex_time64, __err, 4, (futexp),		      \
+			      __lll_private_flag (FUTEX_WAIT, private),	      \
+			      (val), NULL);			      \
+    __ret;								      \
+  })
+
+#else
+
+#define lll_futex_wait(futexp, val, private) \
+  ({									      \
+    INTERNAL_SYSCALL_DECL (__err);					      \
+    long int __ret;							      \
+    __ret = INTERNAL_SYSCALL (futex, __err, 4, (futexp),		      \
+			      __lll_private_flag (FUTEX_WAIT, private),	      \
+			      (val), NULL);			      \
+    __ret;								      \
+  })
+
+#endif
 
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_futex_time64)
 
+struct __ts64_struct {
+    __S64_TYPE tv_sec;
+    __S64_TYPE tv_nsec;
+};
+
+#define ptr_timespec_to_ts64(ts) \
+  (&(struct __ts64_struct) {.tv_sec = ts->tv_sec, .tv_nsec = ts->tv_nsec})
+
 #define lll_futex_timed_wait(futexp, val, timespec, private) \
   ({									      \
     INTERNAL_SYSCALL_DECL (__err);					      \
     long int __ret;							      \
     __ret = INTERNAL_SYSCALL (futex_time64, __err, 4, (futexp),		      \
 			      __lll_private_flag (FUTEX_WAIT, private),	      \
-			      (val), (timespec));			      \
+			      (val), (ptr_timespec_to_ts64(timespec)));			      \
     __ret;								      \
   })
 
diff --git a/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevelrobustlock.c b/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevelrobustlock.c
index 7b4e84343..5781359fb 100644
--- a/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevelrobustlock.c
+++ b/libpthread/nptl/sysdeps/unix/sysv/linux/lowlevelrobustlock.c
@@ -73,7 +73,7 @@ __lll_robust_timedlock_wait (int *futex, const struct timespec *abstime,
   do
     {
       struct timeval tv;
-      struct timespec rt;
+      struct timespec rt, *rtp;
 
       /* Get the current time.  */
       (void) __gettimeofday (&tv, NULL);
@@ -99,8 +99,8 @@ __lll_robust_timedlock_wait (int *futex, const struct timespec *abstime,
       if (oldval != newval
 	  && atomic_compare_and_exchange_bool_acq (futex, newval, oldval))
 	continue;
-
-      lll_futex_timed_wait (futex, newval, &rt, private);
+      rtp = &rt;
+      lll_futex_timed_wait (futex, newval, rtp, private);
 
     try:
       ;
diff --git a/libpthread/nptl/sysdeps/unix/sysv/linux/sem_timedwait.c b/libpthread/nptl/sysdeps/unix/sysv/linux/sem_timedwait.c
index 8c3ef47c5..05ba5bc13 100644
--- a/libpthread/nptl/sysdeps/unix/sysv/linux/sem_timedwait.c
+++ b/libpthread/nptl/sysdeps/unix/sysv/linux/sem_timedwait.c
@@ -51,7 +51,7 @@ sem_timedwait (sem_t *sem, const struct timespec *abstime)
   while (1)
     {
       struct timeval tv;
-      struct timespec rt;
+      struct timespec rt, *rtp;
       int sec, nsec;
 
       /* Get the current time.  */
@@ -79,10 +79,12 @@ sem_timedwait (sem_t *sem, const struct timespec *abstime)
       rt.tv_sec = sec;
       rt.tv_nsec = nsec;
 
+      rtp = &rt;
+
       /* Enable asynchronous cancellation.  Required by the standard.  */
       int oldtype = __pthread_enable_asynccancel ();
 
-      err = lll_futex_timed_wait (&isem->value, 0, &rt,
+      err = lll_futex_timed_wait (&isem->value, 0, rtp,
 				  isem->private ^ FUTEX_PRIVATE_FLAG);
 
       /* Disable asynchronous cancellation.  */
diff --git a/libpthread/nptl/sysdeps/unix/sysv/linux/timer_settime.c b/libpthread/nptl/sysdeps/unix/sysv/linux/timer_settime.c
index 80d242f21..d7c2aa804 100644
--- a/libpthread/nptl/sysdeps/unix/sysv/linux/timer_settime.c
+++ b/libpthread/nptl/sysdeps/unix/sysv/linux/timer_settime.c
@@ -38,6 +38,17 @@ static int compat_timer_settime (timer_t timerid, int flags,
 #  define timer_settime timer_settime_alias
 # endif
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct its64_struct {
+    __S64_TYPE interval_tv_sec;
+    __S64_TYPE interval_tv_nsec;
+    __S64_TYPE value_tv_sec;
+    __S64_TYPE value_tv_nsec;
+};
+
+#endif
+
 
 int
 timer_settime (
@@ -55,8 +66,14 @@ timer_settime (
 
       /* Delete the kernel timer object.  */
 # if defined(__UCLIBC_USE_TIME64__) && defined(__NR_timer_settime64)
+      struct its64_struct __its64 = {
+            .interval_tv_sec = value->it_interval.tv_sec,
+            .interval_tv_nsec = value->it_interval.tv_nsec,
+            .value_tv_sec = value->it_value.tv_sec,
+            .value_tv_nsec = value->it_value.tv_nsec,
+      };
       int res = INLINE_SYSCALL (timer_settime64, 4, kt->ktimerid, flags,
-				value, ovalue);
+				value ? &__its64 : 0, ovalue);
 # else
       int res = INLINE_SYSCALL (timer_settime, 4, kt->ktimerid, flags,
 				value, ovalue);
diff --git a/librt/clock_gettime.c b/librt/clock_gettime.c
index b66b60231..eff40d68f 100644
--- a/librt/clock_gettime.c
+++ b/librt/clock_gettime.c
@@ -22,10 +22,26 @@
 #include <sys/time.h>
 #include "kernel-posix-cpu-timers.h"
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+  __S64_TYPE tv_sec;
+  __S64_TYPE tv_nsec;
+};
+
+#endif
+
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_clock_gettime64)
 #define SYSCALL_GETTIME \
-  retval = INLINE_SYSCALL (clock_gettime64, 2, clock_id, tp); \
-  break
+  { \
+  struct ts64_struct __ts64; \
+  retval = INLINE_SYSCALL (clock_gettime64, 2, clock_id, &__ts64); \
+  if (tp) { \
+    tp->tv_sec = __ts64.tv_sec; \
+    tp->tv_nsec = __ts64.tv_nsec; \
+  } \
+  break; \
+  }
 #else
 #define SYSCALL_GETTIME \
   retval = INLINE_SYSCALL (clock_gettime, 2, clock_id, tp); \
diff --git a/librt/clock_nanosleep.c b/librt/clock_nanosleep.c
index eaae75720..786f7eede 100644
--- a/librt/clock_nanosleep.c
+++ b/librt/clock_nanosleep.c
@@ -21,6 +21,14 @@
 
 #include "kernel-posix-cpu-timers.h"
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+    __S64_TYPE tv_sec;
+    __S64_TYPE tv_nsec;
+};
+
+#endif
 
 /* We can simply use the syscall.  The CPU clocks are not supported
    with this function.  */
@@ -36,18 +44,27 @@ clock_nanosleep (clockid_t clock_id, int flags, const struct timespec *req,
   if (clock_id == CLOCK_PROCESS_CPUTIME_ID)
     clock_id = MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED);
 
-  if (SINGLE_THREAD_P)
+  if (SINGLE_THREAD_P) {
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_clock_nanosleep_time64)
-    r = INTERNAL_SYSCALL (clock_nanosleep_time64, err, 4, clock_id, flags, req, rem);
+    struct ts64_struct __ts64 = {
+      .tv_sec = req ? req->tv_sec : 0,
+      .tv_nsec = req ? req->tv_nsec : 0
+    };
+    r = INTERNAL_SYSCALL (clock_nanosleep_time64, err, 4, clock_id, flags, req ? &__ts64 : 0, rem);
 #else
     r = INTERNAL_SYSCALL (clock_nanosleep, err, 4, clock_id, flags, req, rem);
 #endif
+  }
   else
     {
 #ifdef __NEW_THREADS
       int oldstate = LIBC_CANCEL_ASYNC ();
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_clock_nanosleep_time64)
-      r = INTERNAL_SYSCALL (clock_nanosleep_time64, err, 4, clock_id, flags, req, rem);
+      struct ts64_struct __ts64_2 = {
+        .tv_sec = req ? req->tv_sec : 0,
+        .tv_nsec = req ? req->tv_nsec : 0
+      };
+      r = INTERNAL_SYSCALL (clock_nanosleep_time64, err, 4, clock_id, flags, req ? &__ts64_2 : 0, rem);
 #else
       r = INTERNAL_SYSCALL (clock_nanosleep, err, 4, clock_id, flags, req,
 			    rem);
diff --git a/librt/mq_timedreceive.c b/librt/mq_timedreceive.c
index db1ae1aa8..818f54faa 100644
--- a/librt/mq_timedreceive.c
+++ b/librt/mq_timedreceive.c
@@ -8,13 +8,29 @@
 #include <unistd.h>
 #include <cancel.h>
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+	__S64_TYPE tv_sec;
+	__S64_TYPE tv_nsec;
+};
+
+#endif
+
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_mq_timedreceive_time64)
-#define __NR___mq_timedreceive_nocancel __NR_mq_timedreceive_time64
+int _NC(mq_timedreceive)(mqd_t mqdes, char *restrict msg_ptr, size_t msg_len, unsigned int *restrict msq_prio, const struct timespec *restrict abs_timeout)
+{
+	struct ts64_struct __ts64 = {
+		.tv_sec = abs_timeout ? abs_timeout->tv_sec : 0,
+		.tv_nsec = abs_timeout ? abs_timeout->tv_nsec : 0,
+	};
+
+	return INLINE_SYSCALL(mq_timedreceive_time64, 5, mqdes, msg_ptr, msg_len, msq_prio, abs_timeout ? &__ts64 : 0);
+}
 #else
 #define __NR___mq_timedreceive_nocancel __NR_mq_timedreceive
-#endif
-
 _syscall5(ssize_t, __NC(mq_timedreceive), mqd_t, mqdes, char *__restrict, msg_ptr, size_t, msg_len, unsigned int *__restrict, msq_prio, const struct timespec *__restrict, abs_timeout)
+#endif
 
 CANCELLABLE_SYSCALL(ssize_t, mq_timedreceive, (mqd_t mqdes, char *__restrict msg_ptr, size_t msq_len, unsigned int *__restrict msq_prio, const struct timespec *__restrict abs_timeout),
 		    (mqdes, msg_ptr, msq_len, msq_prio, abs_timeout))
diff --git a/librt/mq_timedsend.c b/librt/mq_timedsend.c
index 6afaf5157..e8deea9cb 100644
--- a/librt/mq_timedsend.c
+++ b/librt/mq_timedsend.c
@@ -8,13 +8,31 @@
 #include <unistd.h>
 #include <cancel.h>
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct ts64_struct {
+	__S64_TYPE tv_sec;
+	__S64_TYPE tv_nsec;
+};
+
+#endif
+
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_mq_timedsend_time64)
 #define __NR___mq_timedsend_nocancel __NR_mq_timedsend_time64
+int _NC(mq_timedsend)(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msq_prio, const struct timespec *abs_timeout)
+{
+	struct ts64_struct __ts64 = {
+		.tv_sec = abs_timeout ? abs_timeout->tv_sec : 0,
+		.tv_nsec = abs_timeout ? abs_timeout->tv_nsec : 0,
+	};
+
+	return INLINE_SYSCALL(mq_timedsend_time64, 5, mqdes, msg_ptr, msg_len, msq_prio, abs_timeout ? &__ts64 : 0);
+}
 #else
 #define __NR___mq_timedsend_nocancel __NR_mq_timedsend
+_syscall5(int, __NC(mq_timedsend), mqd_t, mqdes, const char *, msg_ptr, size_t, msg_len, unsigned int, msq_prio, const struct timespec *, abs_timeout)
 #endif
 
-_syscall5(int, __NC(mq_timedsend), mqd_t, mqdes, const char *, msg_ptr, size_t, msg_len, unsigned int, msq_prio, const struct timespec *, abs_timeout)
 CANCELLABLE_SYSCALL(int, mq_timedsend, (mqd_t mqdes, const char *msg_ptr, size_t msq_len, unsigned int msq_prio, const struct timespec *abs_timeout),
 		    (mqdes, msg_ptr, msq_len, msq_prio, abs_timeout))
 lt_libc_hidden(mq_timedsend)
diff --git a/librt/timer_settime.c b/librt/timer_settime.c
index 022880297..31202b07a 100644
--- a/librt/timer_settime.c
+++ b/librt/timer_settime.c
@@ -9,13 +9,36 @@
 
 #include "kernel-posix-timers.h"
 
+#if defined(__UCLIBC_USE_TIME64__)
+
+struct its64_struct {
+    __S64_TYPE interval_tv_sec;
+    __S64_TYPE interval_tv_nsec;
+    __S64_TYPE value_tv_sec;
+    __S64_TYPE value_tv_nsec;
+};
+
+#endif
+
 #if defined(__NR_timer_settime) || defined(__NR_timer_settime64)
 
 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_timer_settime64)
-#define __NR___syscall_timer_settime __NR_timer_settime64
+int timer_settime(timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue)
+{
+	struct timer *kt = (struct timer *)timerid;
+
+    struct its64_struct __its64 = {
+        .interval_tv_sec = value->it_interval.tv_sec,
+        .interval_tv_nsec = value->it_interval.tv_nsec,
+        .value_tv_sec = value->it_value.tv_sec,
+        .value_tv_nsec = value->it_value.tv_nsec,
+    };
+
+	return INLINE_SYSCALL(timer_settime64, 4, kt->ktimerid, flags, value ? &__its64: 0, ovalue);
+}
 #else
+
 #define __NR___syscall_timer_settime __NR_timer_settime
-#endif
 
 static __inline__ _syscall4(int, __syscall_timer_settime, kernel_timer_t, ktimerid,
 			int, flags, const void *, value, void *, ovalue);
@@ -31,3 +54,4 @@ int timer_settime(timer_t timerid, int flags, const struct itimerspec *value,
 }
 
 #endif
+#endif
