clock: refactor clock_gettime clock_settime

Signed-off-by: ligd <liguiding1@xiaomi.com>

Author: GUIDINGLI

include/nuttx/clock.h

@@ -732,6 +732,29 @@ void perf_convert(clock_t elapsed, FAR struct timespec *ts);
 
 unsigned long perf_getfreq(void);
 
+/****************************************************************************
+ * Name: nxclock_settime
+ *
+ * Description:
+ *   Clock Functions based on POSIX APIs
+ *
+ *   CLOCK_REALTIME - POSIX demands this to be present. This is the wall
+ *   time clock.
+ *
+ ****************************************************************************/
+
+void nxclock_settime(clockid_t clock_id, FAR const struct timespec *tp);
+
+/****************************************************************************
+ * Name: nxclock_gettime
+ *
+ * Description:
+ *   Get the current value of the specified time clock.
+ *
+ ****************************************************************************/
+
+void nxclock_gettime(clockid_t clock_id, FAR struct timespec *tp);
+
 #undef EXTERN
 #ifdef __cplusplus
 }

sched/clock/clock_gettime.c

@@ -36,180 +36,149 @@
 #include <nuttx/arch.h>
 #include <nuttx/sched.h>
 #include <nuttx/spinlock.h>
-#include <nuttx/queue.h>
 
 #include "clock/clock.h"
 #include "sched/sched.h"
 #ifdef CONFIG_CLOCK_TIMEKEEPING
 #  include "clock/clock_timekeeping.h"
 #endif
 
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+#ifdef CONFIG_SCHED_CRITMONITOR
+static clock_t clock_process_runtime(FAR struct tcb_s *tcb)
+{
+# ifdef HAVE_GROUP_MEMBERS
+  FAR struct task_group_s *group;
+  FAR sq_entry_t *curr;
+  clock_t runtime = 0;
+  irqstate_t flags;
+
+  group = tcb->group;
+
+  flags = spin_lock_irqsave(NULL);
+  sq_for_every(&group->tg_members, curr)
+    {
+      tcb = container_of(curr, struct tcb_s, member);
+
+      runtime += tcb->run_time;
+    }
+
+  spin_unlock_irqrestore(NULL, flags);
+  return runtime;
+# else  /* HAVE_GROUP_MEMBERS */
+  return tcb->run_time;
+# endif /* HAVE_GROUP_MEMBERS */
+}
+#endif
+
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
 
 /****************************************************************************
- * Name: clock_gettime
+ * Name: nxclock_gettime
  *
  * Description:
- *   Clock Functions based on POSIX APIs
+ *   Get the current value of the specified time clock.
  *
  ****************************************************************************/
 
-int clock_gettime(clockid_t clock_id, struct timespec *tp)
+void nxclock_gettime(clockid_t clock_id, FAR struct timespec *tp)
 {
-#ifndef CONFIG_CLOCK_TIMEKEEPING
-  struct timespec ts;
-#endif
-  int ret = OK;
-
-  clockid_t clock_type = clock_id & CLOCK_MASK;
-#ifdef CONFIG_SCHED_CRITMONITOR
-  pid_t pid = clock_id >> CLOCK_SHIFT;
-#endif
-
-  DEBUGASSERT(tp != NULL);
-
-  /* CLOCK_MONOTONIC is an optional under POSIX: "If the Monotonic Clock
-   * option is supported, all implementations shall support a clock_id
-   * of CLOCK_MONOTONIC defined in <time.h>. This clock represents the
-   * monotonic clock for the system. For this clock, the value returned
-   * by clock_gettime() represents the amount of time (in seconds and
-   * nanoseconds) since an unspecified point in the past (for example,
-   * system start-up time, or the Epoch). This point does not change
-   * after system start-up time. The value of the CLOCK_MONOTONIC clock
-   * cannot be set via clock_settime(). This function shall fail if it
-   * is invoked with a clock_id argument of CLOCK_MONOTONIC."
-   */
-
-  if (clock_type == CLOCK_MONOTONIC || clock_type == CLOCK_BOOTTIME)
+  if (clock_id == CLOCK_MONOTONIC || clock_id == CLOCK_BOOTTIME)
     {
       /* The the time elapsed since the timer was initialized at power on
        * reset.
        */
 
-      ret = clock_systime_timespec(tp);
+      clock_systime_timespec(tp);
     }
+  else if (clock_id == CLOCK_REALTIME)
+    {
+#ifndef CONFIG_CLOCK_TIMEKEEPING
+      struct timespec ts;
+      irqstate_t flags;
 
-  /* CLOCK_REALTIME - POSIX demands this to be present.  CLOCK_REALTIME
-   * represents the machine's best-guess as to the current wall-clock,
-   * time-of-day time. This means that CLOCK_REALTIME can jump forward and
-   * backward as the system time-of-day clock is changed.
-   */
+      clock_systime_timespec(&ts);
 
-  else if (clock_type == CLOCK_REALTIME)
-    {
-      /* Get the elapsed time since the time-of-day was last set.
-       * clock_systime_timespec() provides the time since power was applied;
-       * the bias value corresponds to the time when the time-of-day was
-       * last set.
+      /* Add the base time to this.  The base time is the time-of-day
+       * setting.  When added to the elapsed time since the time-of-day
+       * was last set, this gives us the current time.
        */
 
-#if defined(CONFIG_CLOCK_TIMEKEEPING)
-      ret = clock_timekeeping_get_wall_time(tp);
+      flags = spin_lock_irqsave(NULL);
+      clock_timespec_add(&g_basetime, &ts, tp);
+      spin_unlock_irqrestore(NULL, flags);
 #else
-      ret = clock_systime_timespec(&ts);
-      if (ret == OK)
-        {
-          irqstate_t flags;
-
-          /* Add the base time to this.  The base time is the time-of-day
-           * setting.  When added to the elapsed time since the time-of-day
-           * was last set, this gives us the current time.
-           */
-
-          flags = spin_lock_irqsave(NULL);
-          clock_timespec_add(&g_basetime, &ts, tp);
-          spin_unlock_irqrestore(NULL, flags);
-        }
-#endif /* CONFIG_CLOCK_TIMEKEEPING */
-    }
-#ifdef CONFIG_SCHED_CRITMONITOR
-  else if (clock_type == CLOCK_THREAD_CPUTIME_ID)
-    {
-      FAR struct tcb_s *tcb;
-
-      if (pid == 0)
-        {
-          /* Fetch the THREAD_CPUTIME for current thread */
-
-          tcb = this_task();
-        }
-      else
-        {
-          tcb = nxsched_get_tcb(pid);
-        }
-
-      if (tcb != NULL)
-        {
-          perf_convert(tcb->run_time, tp);
-        }
-      else
-        {
-          ret = -EFAULT;
-        }
+      clock_timekeeping_get_wall_time(tp);
+#endif
     }
-  else if (clock_type == CLOCK_PROCESS_CPUTIME_ID)
+  else
     {
-      unsigned long runtime;
+#ifdef CONFIG_SCHED_CRITMONITOR
+      clockid_t clock_type = clock_id & CLOCK_MASK;
+      pid_t pid = clock_id >> CLOCK_SHIFT;
       FAR struct tcb_s *tcb;
-# ifdef HAVE_GROUP_MEMBERS
-      FAR struct task_group_s *group;
-      FAR sq_entry_t *curr;
-      FAR sq_entry_t *next;
-      irqstate_t flags;
-# endif
 
       if (pid == 0)
         {
-          /* Fetch the PROCESS_CPUTIME for current process */
-
           tcb = this_task();
         }
       else
         {
           tcb = nxsched_get_tcb(pid);
         }
 
-      if (tcb != NULL)
+      if (tcb)
         {
-# ifdef HAVE_GROUP_MEMBERS
-          group = tcb->group;
-          runtime = 0;
-
-          flags = spin_lock_irqsave(NULL);
-          sq_for_every_safe(&group->tg_members, curr, next)
+          if (clock_type == CLOCK_PROCESS_CPUTIME_ID)
             {
-              tcb = container_of(curr, struct tcb_s, member);
-
-              runtime += tcb->run_time;
+              up_perf_convert(clock_process_runtime(tcb), tp);
+            }
+          else if (clock_type == CLOCK_THREAD_CPUTIME_ID)
+            {
+              up_perf_convert(tcb->run_time, tp);
             }
-
-          spin_unlock_irqrestore(NULL, flags);
-# else  /* HAVE_GROUP_MEMBERS */
-          runtime = tcb->run_time;
-# endif /* HAVE_GROUP_MEMBERS */
-
-          perf_convert(runtime, tp);
-        }
-      else
-        {
-          ret = -EFAULT;
         }
-    }
 #endif
-  else
-    {
-      ret = -EINVAL;
     }
+}
 
-  /* Check for errors and set the errno value if necessary */
+/****************************************************************************
+ * Name: clock_gettime
+ *
+ * Description:
+ *   Clock Functions based on POSIX APIs
+ *
+ *   CLOCK_MONOTONIC is an optional under POSIX: "If the Monotonic Clock
+ *   option is supported, all implementations shall support a clock_id
+ *   of CLOCK_MONOTONIC defined in <time.h>. This clock represents the
+ *   monotonic clock for the system. For this clock, the value returned
+ *   by clock_gettime() represents the amount of time (in seconds and
+ *   nanoseconds) since an unspecified point in the past (for example,
+ *   system start-up time, or the Epoch). This point does not change
+ *   after system start-up time. The value of the CLOCK_MONOTONIC clock
+ *   cannot be set via clock_settime(). This function shall fail if it
+ *   is invoked with a clock_id argument of CLOCK_MONOTONIC."
+ *
+ *   CLOCK_REALTIME - POSIX demands this to be present.  CLOCK_REALTIME
+ *   represents the machine's best-guess as to the current wall-clock,
+ *   time-of-day time. This means that CLOCK_REALTIME can jump forward and
+ *   backward as the system time-of-day clock is changed.
+ *
+ ****************************************************************************/
 
-  if (ret < 0)
+int clock_gettime(clockid_t clock_id, FAR struct timespec *tp)
+{
+  if (tp == NULL || clock_id < 0 || clock_id > CLOCK_BOOTTIME)
     {
-      set_errno(-ret);
-      ret = ERROR;
+      set_errno(EINVAL);
+      return ERROR;
     }
 
-  return ret;
+  nxclock_gettime(clock_id, tp);
+  return OK;
 }