Merge pull request #92 from Lind-Project/clock_gettime

implement clock_gettime

Author: rennergade

src/RawPOSIX/src/safeposix/dispatcher.rs

@@ -118,6 +118,7 @@ const WAIT_SYSCALL: i32 = 172;
 const WAITPID_SYSCALL: i32 = 173;
 
 const NANOSLEEP_TIME64_SYSCALL : i32 = 181;
+const CLOCK_GETTIME_SYSCALL : i32 = 191;
 
 use std::ffi::CString;
 use std::ffi::CStr;
@@ -1034,6 +1035,14 @@ pub fn lind_syscall_api(
                 .nanosleep_time64_syscall(clockid, flags, req, rem)
         }
 
+        CLOCK_GETTIME_SYSCALL => {
+            let clockid = arg1 as u32;
+            let tp = (start_address + arg2) as usize;
+            
+            interface::cagetable_getref(cageid)
+                .clock_gettime_syscall(clockid, tp)
+        }
+
         WAIT_SYSCALL => {
             let mut status = interface::get_i32_ref(start_address + arg1).unwrap();
 

src/RawPOSIX/src/safeposix/syscalls/fs_calls.rs

@@ -1901,6 +1901,15 @@ impl Cage {
         }
         ret
     }
+
+    pub fn clock_gettime_syscall(&self, clockid: u32, tp: usize) -> i32 {
+        let ret = unsafe { syscall(SYS_clock_gettime, clockid, tp) as i32 };
+        if ret < 0 {
+            let errno = get_errno();
+            return handle_errno(errno, "clock_gettime");
+        }
+        ret
+    }
 }
 
 /// Lind-WASM is running as same Linux-Process from host kernel perspective, so standard fds shouldn't 

src/glibc/sysdeps/unix/sysv/linux/clock_gettime.c

@@ -23,66 +23,17 @@
 #include "kernel-posix-cpu-timers.h"
 #include <sysdep-vdso.h>
 #include <shlib-compat.h>
+#include <syscall-template.h>
 
 /* Get current value of CLOCK and store it in TP.  */
+
+// Now after clang compile it will call gettime64 first(but in real case we have only 32 bit)
+// In this case, we need “#if __TIMESIZE != 64” and this is always true. And always call __clock_gettime at last.
+
 int
 __clock_gettime64 (clockid_t clock_id, struct __timespec64 *tp)
 {
-  int r;
-
-#ifndef __NR_clock_gettime64
-# define __NR_clock_gettime64 __NR_clock_gettime
-#endif
-
-#ifdef HAVE_CLOCK_GETTIME64_VSYSCALL
-  int (*vdso_time64) (clockid_t clock_id, struct __timespec64 *tp)
-    = GLRO(dl_vdso_clock_gettime64);
-  if (vdso_time64 != NULL)
-    {
-      r = INTERNAL_VSYSCALL_CALL (vdso_time64, 2, clock_id, tp);
-      if (r == 0)
-	return 0;
-      return INLINE_SYSCALL_ERROR_RETURN_VALUE (-r);
-    }
-#endif
-
-#ifdef HAVE_CLOCK_GETTIME_VSYSCALL
-  int (*vdso_time) (clockid_t clock_id, struct timespec *tp)
-    = GLRO(dl_vdso_clock_gettime);
-  if (vdso_time != NULL)
-    {
-      struct timespec tp32;
-      r = INTERNAL_VSYSCALL_CALL (vdso_time, 2, clock_id, &tp32);
-      if (r == 0 && tp32.tv_sec >= 0)
-	{
-	  *tp = valid_timespec_to_timespec64 (tp32);
-	  return 0;
-	}
-      else if (r != 0)
-	return INLINE_SYSCALL_ERROR_RETURN_VALUE (-r);
-
-      /* Fallback to syscall if the 32-bit time_t vDSO returns overflows.  */
-    }
-#endif
-
-  r = INTERNAL_SYSCALL_CALL (clock_gettime64, clock_id, tp);
-  if (r == 0)
-    return 0;
-  if (r != -ENOSYS)
-    return INLINE_SYSCALL_ERROR_RETURN_VALUE (-r);
-
-#ifndef __ASSUME_TIME64_SYSCALLS
-  /* Fallback code that uses 32-bit support.  */
-  struct timespec tp32;
-  r = INTERNAL_SYSCALL_CALL (clock_gettime, clock_id, &tp32);
-  if (r == 0)
-    {
-      *tp = valid_timespec_to_timespec64 (tp32);
-      return 0;
-    }
-#endif
-
-  return INLINE_SYSCALL_ERROR_RETURN_VALUE (-r);
+  return MAKE_SYSCALL(191, "syscall|clock_gettime", (uint64_t) clock_id, (uint64_t) tp, NOTUSED, NOTUSED, NOTUSED, NOTUSED);
 }
 
 #if __TIMESIZE != 64
@@ -91,26 +42,11 @@ libc_hidden_def (__clock_gettime64)
 int
 __clock_gettime (clockid_t clock_id, struct timespec *tp)
 {
-  int ret;
-  struct __timespec64 tp64;
-
-  ret = __clock_gettime64 (clock_id, &tp64);
-
-  if (ret == 0)
-    {
-      if (! in_time_t_range (tp64.tv_sec))
-        {
-          __set_errno (EOVERFLOW);
-          return -1;
-        }
-
-      *tp = valid_timespec64_to_timespec (tp64);
-    }
-
-  return ret;
+  return MAKE_SYSCALL(191, "syscall|clock_gettime", (uint64_t) clock_id, (uint64_t) tp, NOTUSED, NOTUSED, NOTUSED, NOTUSED);
 }
+
 #endif
-libc_hidden_def (__clock_gettime)
+libc_hidden_def (__clock_gettime);
 
 versioned_symbol (libc, __clock_gettime, clock_gettime, GLIBC_2_17);
 /* clock_gettime moved to libc in version 2.17;

tests/unit-tests/file_tests/non-deterministic/clock_gettime_highlevel.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <time.h>
+
+/*
+    This test indirectly calls the clock_gettime syscall through the clock() function.
+    The clock() function in glibc internally uses clock_gettime to measure CPU time 
+    consumed by the process.
+
+    The program measures the CPU time taken to run 1,000,000 iterations of a simple loop.
+    It records the start time using clock(), performs the computation, then records the
+    end time and calculates the elapsed CPU time.
+*/
+
+int main() {
+    // Get the start time using clock()
+    clock_t begin = clock();
+
+    printf("Running 1,000,000 iterations...\n");
+
+    volatile long long sum = 0;
+    for (long long i = 0; i < 1000000; i++) {
+        sum += i;
+    }
+
+    // Get the end time using clock()
+    clock_t end = clock();
+
+    // Calculate elapsed time in seconds
+    double elapsed_time = (double)(end - begin) / CLOCKS_PER_SEC;
+
+    // Display results
+    printf("\nStart time: %lld clock ticks\n", begin);
+    printf("End time: %lld clock ticks\n", end);
+    printf("Elapsed CPU time: %.9f seconds\n", elapsed_time);
+
+    return 0;
+}
+

tests/unit-tests/file_tests/non-deterministic/clock_gettime_simple.c

@@ -0,0 +1,20 @@
+#include <time.h>
+#include <stdio.h>
+
+int main() {
+    struct timespec tp;
+
+    // get CLOCK_REALTIME's time
+    if (clock_gettime(CLOCK_REALTIME, &tp) == -1) {
+        perror("clock_gettime failed");
+        return 1;
+    }
+
+    //print the result
+    printf("Current time: %lld seconds and %ld nanoseconds\n", tp.tv_sec, tp.tv_nsec);
+
+    return 0;
+}
+
+
+