diff --git a/tools/testing/selftests/vDSO/vdso_test_abi.c b/tools/testing/selftests/vDSO/vdso_test_abi.c
index a54424e2336f..e85c50dca06b 100644
--- a/tools/testing/selftests/vDSO/vdso_test_abi.c
+++ b/tools/testing/selftests/vDSO/vdso_test_abi.c
@@ -22,14 +22,16 @@
 #include "vdso_config.h"
 #include "vdso_call.h"
 #include "parse_vdso.h"
+#include <linux/time_types.h>
 
 static const char *version;
 static const char **name;
 
-typedef long (*vdso_gettimeofday_t)(struct timeval *tv, struct timezone *tz);
-typedef long (*vdso_clock_gettime_t)(clockid_t clk_id, struct timespec *ts);
-typedef long (*vdso_clock_getres_t)(clockid_t clk_id, struct timespec *ts);
-typedef time_t (*vdso_time_t)(time_t *t);
+typedef long (*vdso_gettimeofday_t)(struct __kernel_old_timeval *tv, struct timezone *tz);
+typedef long (*vdso_clock_gettime_t)(clockid_t clk_id, struct __kernel_old_timespec *ts);
+typedef long (*vdso_clock_getres_t)(clockid_t clk_id, struct __kernel_old_timespec *ts);
+typedef long (*vdso_clock_gettime_t)(clockid_t clk_id, struct __kernel_old_timespec *ts);
+typedef __kernel_old_time_t (*vdso_time_t)(__kernel_old_time_t *t);
 
 const char *vdso_clock_name[12] = {
 	"CLOCK_REALTIME",
@@ -83,12 +85,39 @@ static void vdso_test_clock_gettime(clockid_t clk_id)
 		return;
 	}
 
-	struct timespec ts;
+	struct __kernel_old_timespec ts;
+	long ret = VDSO_CALL(vdso_clock_gettime, 2, clk_id, &ts);
+
+	if (ret == 0) {
+		ksft_print_msg("The time is %ld.%06ld\n",
+			       ts.tv_sec, ts.tv_nsec);
+		ksft_test_result_pass("%s %s\n", name[1],
+				      vdso_clock_name[clk_id]);
+	} else {
+		ksft_test_result_fail("%s %s\n", name[1],
+				      vdso_clock_name[clk_id]);
+	}
+}
+
+static void vdso_test_clock_gettime64(clockid_t clk_id)
+{
+	/* Find clock_gettime. */
+	vdso_clock_gettime_t vdso_clock_gettime =
+		(vdso_clock_gettime_t)vdso_sym(version, name[1]);
+
+	if (!vdso_clock_gettime) {
+		ksft_print_msg("Couldn't find %s\n", name[1]);
+		ksft_test_result_skip("%s %s\n", name[1],
+				      vdso_clock_name[clk_id]);
+		return;
+	}
+
+	struct __kernel_timespec ts;
 	long ret = VDSO_CALL(vdso_clock_gettime, 2, clk_id, &ts);
 
 	if (ret == 0) {
 		ksft_print_msg("The time is %lld.%06lld\n",
-			       (long long)ts.tv_sec, (long long)ts.tv_nsec);
+			       ts.tv_sec, ts.tv_nsec);
 		ksft_test_result_pass("%s %s\n", name[1],
 				      vdso_clock_name[clk_id]);
 	} else {
@@ -109,11 +138,11 @@ static void vdso_test_time(void)
 		return;
 	}
 
-	long ret = VDSO_CALL(vdso_time, 1, NULL);
+	__kernel_old_time_t ret = VDSO_CALL(vdso_time, 1, NULL);
 
 	if (ret > 0) {
-		ksft_print_msg("The time in hours since January 1, 1970 is %lld\n",
-				(long long)(ret / 3600));
+		ksft_print_msg("The time in hours since January 1, 1970 is %ld\n",
+				(ret / 3600));
 		ksft_test_result_pass("%s\n", name[2]);
 	} else {
 		ksft_test_result_fail("%s\n", name[2]);
@@ -135,23 +164,44 @@ static void vdso_test_clock_getres(clockid_t clk_id)
 		return;
 	}
 
-	struct timespec ts, sys_ts;
+	struct __kernel_old_timespec ts, sys_ts;
+	struct __kernel_old_timespec ts;
 	long ret = VDSO_CALL(vdso_clock_getres, 2, clk_id, &ts);
 
 	if (ret == 0) {
-		ksft_print_msg("The vdso resolution is %lld %lld\n",
-			       (long long)ts.tv_sec, (long long)ts.tv_nsec);
+		ksft_print_msg("The vdso resolution is %ld %ld\n",
+			       (long)ts.tv_sec, (long)ts.tv_nsec);
 	} else {
 		clock_getres_fail++;
 	}
 
+#ifdef SYS_clock_getres
+	/* most architectures still provide the old clock_getres */
+	struct __kernel_old_timespec sys_ts;
 	ret = syscall(SYS_clock_getres, clk_id, &sys_ts);
 
-	ksft_print_msg("The syscall resolution is %lld %lld\n",
-			(long long)sys_ts.tv_sec, (long long)sys_ts.tv_nsec);
+	ksft_print_msg("The clock_getres resolution is %ld %l	d\n",
+			sys_ts.tv_sec, sys_ts.tv_nsec);
 
 	if ((sys_ts.tv_sec != ts.tv_sec) || (sys_ts.tv_nsec != ts.tv_nsec))
 		clock_getres_fail++;
+#endif
+
+#ifdef SYS_clock_getres_time64
+	struct __kernel_timespec sys_ts64;
+	ret = syscall(SYS_clock_getres, clk_id, &sys_ts);
+	ksft_print_msg("The clock_getres resolution is %lld %lld\n",
+			sys_ts.tv_sec, sys_ts.tv_nsec);
+
+	if ((sys_ts.tv_sec != ts.tv_sec) || (sys_ts.tv_nsec != ts.tv_nsec))
+		clock_getres_fail++;
+
+#ifdef SYS_clock_getres
+	if ((sys_ts64.tv_sec != ts.tv_sec) || (sys_ts64.tv_nsec != ts.tv_nsec))
+		clock_getres_fail++;
+#endif
+
+#endif
 
 	if (clock_getres_fail > 0) {
 		ksft_test_result_fail("%s %s\n", name[3],
@@ -172,6 +222,9 @@ static inline void vdso_test_clock(clockid_t clock_id)
 
 	vdso_test_clock_gettime(clock_id);
 
+	if (sizeof(long) == 4)
+		vdso_test_clock_gettime64(clock_id);
+
 	vdso_test_clock_getres(clock_id);
 }
 
diff --git a/tools/testing/selftests/vDSO/vdso_test_clock_getres.c b/tools/testing/selftests/vDSO/vdso_test_clock_getres.c
index 38d46a8bf7cb..c95b81d57e91 100644
--- a/tools/testing/selftests/vDSO/vdso_test_clock_getres.c
+++ b/tools/testing/selftests/vDSO/vdso_test_clock_getres.c
@@ -26,11 +26,16 @@
 #include <sys/syscall.h>
 
 #include "../kselftest.h"
+#include <linux/time_types.h>
+
+typedef long (*vdso_clock_gettime_t)(clockid_t clk_id, struct __kernel_old_timespec *ts);
+typedef long (*vdso_clock_getres_t)(clockid_t clk_id, struct __kernel_old_timespec *ts);
 
 static long syscall_clock_getres(clockid_t _clkid, struct timespec *_ts)
 {
 	long ret;
 
+	struct __kernel_old_timespec ts;
 	ret = syscall(SYS_clock_getres, _clkid, _ts);
 
 	return ret;
diff --git a/tools/testing/selftests/vDSO/vdso_test_correctness.c b/tools/testing/selftests/vDSO/vdso_test_correctness.c
index 5fb97ad67eea..3d171cdf9f1d 100644
--- a/tools/testing/selftests/vDSO/vdso_test_correctness.c
+++ b/tools/testing/selftests/vDSO/vdso_test_correctness.c
@@ -49,7 +49,7 @@ struct __kernel_timespec {
 
 int nerrs = 0;
 
-typedef int (*vgettime_t)(clockid_t, struct timespec *);
+typedef int (*vgettime_t)(clockid_t, struct __kernel_old_timespec *);
 
 vgettime_t vdso_clock_gettime;
 
@@ -57,7 +57,7 @@ typedef int (*vgettime64_t)(clockid_t, struct __kernel_timespec *);
 
 vgettime64_t vdso_clock_gettime64;
 
-typedef long (*vgtod_t)(struct timeval *tv, struct timezone *tz);
+typedef long (*vgtod_t)(struct __kernel_old_timeval *tv, struct timezone *tz);
 
 vgtod_t vdso_gettimeofday;
 
@@ -154,7 +154,7 @@ static long sys_getcpu(unsigned * cpu, unsigned * node,
 	return syscall(__NR_getcpu, cpu, node, cache);
 }
 
-static inline int sys_clock_gettime(clockid_t id, struct timespec *ts)
+static inline int sys_clock_gettime(clockid_t id, struct __kernel_old_timespec *ts)
 {
 	return syscall(__NR_clock_gettime, id, ts);
 }
@@ -164,7 +164,7 @@ static inline int sys_clock_gettime64(clockid_t id, struct __kernel_timespec *ts
 	return syscall(__NR_clock_gettime64, id, ts);
 }
 
-static inline int sys_gettimeofday(struct timeval *tv, struct timezone *tz)
+static inline int sys_gettimeofday(struct __kernel_old_timeval *tv, struct timezone *tz)
 {
 	return syscall(__NR_gettimeofday, tv, tz);
 }
@@ -221,7 +221,8 @@ static void test_getcpu(void)
 	}
 }
 
-static bool ts_leq(const struct timespec *a, const struct timespec *b)
+static bool ts_leq(const struct __kernel_old_timespec *a,
+		   const struct __kernel_old_timespec *b)
 {
 	if (a->tv_sec != b->tv_sec)
 		return a->tv_sec < b->tv_sec;
@@ -238,7 +239,7 @@ static bool ts64_leq(const struct __kernel_timespec *a,
 		return a->tv_nsec <= b->tv_nsec;
 }
 
-static bool tv_leq(const struct timeval *a, const struct timeval *b)
+static bool tv_leq(const struct __kernel_old_timeval *a, const struct __kernel_old_timeval *b)
 {
 	if (a->tv_sec != b->tv_sec)
 		return a->tv_sec < b->tv_sec;
@@ -263,7 +264,7 @@ static char const * const clocknames[] = {
 
 static void test_one_clock_gettime(int clock, const char *name)
 {
-	struct timespec start, vdso, end;
+	struct __kernel_old_timespec start, vdso, end;
 	int vdso_ret, end_ret;
 
 	printf("[RUN]\tTesting clock_gettime for clock %s (%d)...\n", name, clock);
@@ -387,7 +388,7 @@ static void test_clock_gettime64(void)
 
 static void test_gettimeofday(void)
 {
-	struct timeval start, vdso, end;
+	struct __kernel_old_timeval start, vdso, end;
 	struct timezone sys_tz, vdso_tz;
 	int vdso_ret, end_ret;
 
