[rtems commit] rtems: Add new clock manager directives

Wed Nov 17 08:11:50 UTC 2021

Module:    rtems
Branch:    master
Commit:    ccbcfb679da0a6c07878d3ae4ff0f91cb1c3caee
Changeset: http://git.rtems.org/rtems/commit/?id=ccbcfb679da0a6c07878d3ae4ff0f91cb1c3caee

Author:    Sebastian Huber <sebastian.huber at embedded-brains.de>
Date:      Mon Oct 11 17:07:50 2021 +0200

rtems: Add new clock manager directives

Update #4527.

---

 cpukit/include/rtems/rtems/clock.h | 592 +++++++++++++++++++++++++++++++++++++
 cpukit/score/src/kern_tc.c         |  56 ++++
 2 files changed, 648 insertions(+)

diff --git a/cpukit/include/rtems/rtems/clock.h b/cpukit/include/rtems/rtems/clock.h
index e158b18..cd0bccb 100644
--- a/cpukit/include/rtems/rtems/clock.h
+++ b/cpukit/include/rtems/rtems/clock.h
@@ -81,6 +81,11 @@ extern "C" {
  *   related capabilities.
  */
 
+/* Generated from spec:/rtems/clock/if/bintime */
+
+/* Forward declaration */
+struct bintime;
+
 /* Generated from spec:/rtems/clock/if/set */
 
 /**
@@ -213,6 +218,593 @@ rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_of_day );
  */
 rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time_of_day );
 
+/* Generated from spec:/rtems/clock/if/get-realtime */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since the Unix epoch measured using
+ *   CLOCK_REALTIME in seconds and nanoseconds format.
+ *
+ * @param[out] time_snapshot is the pointer to a struct timespec object.  The
+ *   time elapsed since the Unix epoch measured using the CLOCK_REALTIME at
+ *   some time point during the directive call will be stored in this object.
+ *   Calling the directive with a pointer equal to NULL is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive accesses a device provided by the Clock Driver to get the time
+ * in the highest precision available to the system.  Alternatively, the
+ * rtems_clock_get_realtime_coarse() directive may be used to get the time with
+ * less precision and less runtime overhead.
+ *
+ * See rtems_clock_get_realtime_bintime() and
+ * rtems_clock_get_realtime_timeval() to get the time in alternative formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_realtime( struct timespec *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-realtime-bintime */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since the Unix epoch measured using
+ *   CLOCK_REALTIME in binary time format.
+ *
+ * @param[out] time_snapshot is the pointer to a bintime object.  The time
+ *   elapsed since the Unix epoch measured using the CLOCK_REALTIME at some
+ *   time point during the directive call will be stored in this object.
+ *   Calling the directive with a pointer equal to NULL is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive accesses a device provided by the Clock Driver to get the time
+ * in the highest precision available to the system.  Alternatively, the
+ * rtems_clock_get_realtime_coarse_bintime() directive may be used to get the
+ * time with less precision and less runtime overhead.
+ *
+ * See rtems_clock_get_realtime() and rtems_clock_get_realtime_timeval() to get
+ * the time in alternative formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_realtime_bintime( struct bintime *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-realtime-timeval */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since the Unix epoch measured using
+ *   CLOCK_REALTIME in seconds and microseconds format.
+ *
+ * @param[out] time_snapshot is the pointer to a struct timeval object.  The
+ *   time elapsed since the Unix epoch measured using the CLOCK_REALTIME at
+ *   some time point during the directive call will be stored in this object.
+ *   Calling the directive with a pointer equal to NULL is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive accesses a device provided by the Clock Driver to get the time
+ * in the highest precision available to the system.  Alternatively, the
+ * rtems_clock_get_realtime_coarse_timeval() directive may be used to get the
+ * time with less precision and less runtime overhead.
+ *
+ * See rtems_clock_get_realtime() and rtems_clock_get_realtime_bintime() to get
+ * the time in alternative formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_realtime_timeval( struct timeval *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-realtime-coarse */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since the Unix epoch measured using
+ *   CLOCK_REALTIME in coarse precision in seconds and nanoseconds format.
+ *
+ * @param[out] time_snapshot is the pointer to a struct timespec object.  The
+ *   time elapsed since the Unix epoch measured using the CLOCK_REALTIME at
+ *   some time point close to the directive call will be stored in this object.
+ *   Calling the directive with a pointer equal to NULL is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive does not access a device to get the time.  It uses a recent
+ * snapshot provided by the Clock Driver.  Alternatively, the
+ * rtems_clock_get_realtime() directive may be used to get the time with higher
+ * precision and higher runtime overhead.
+ *
+ * See rtems_clock_get_realtime_coarse_bintime() and
+ * rtems_clock_get_realtime_coarse_timeval() to get the time in alternative
+ * formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_realtime_coarse( struct timespec *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-realtime-coarse-bintime */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since the Unix epoch measured using
+ *   CLOCK_REALTIME in coarse precision in binary time format.
+ *
+ * @param[out] time_snapshot is the pointer to a bintime object.  The time
+ *   elapsed since the Unix epoch measured using the CLOCK_REALTIME at some
+ *   time point close to the directive call will be stored in this object.
+ *   Calling the directive with a pointer equal to NULL is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive does not access a device to get the time.  It uses a recent
+ * snapshot provided by the Clock Driver.  Alternatively, the
+ * rtems_clock_get_realtime_bintime() directive may be used to get the time
+ * with higher precision and higher runtime overhead.
+ *
+ * See rtems_clock_get_realtime_coarse() and
+ * rtems_clock_get_realtime_coarse_timeval() to get the time in alternative
+ * formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_realtime_coarse_bintime( struct bintime *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-realtime-coarse-timeval */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since the Unix epoch measured using
+ *   CLOCK_REALTIME in coarse precision in seconds and microseconds format.
+ *
+ * @param[out] time_snapshot is the pointer to a struct timeval object.  The
+ *   time elapsed since the Unix epoch measured using the CLOCK_REALTIME at
+ *   some time point close to the directive call will be stored in this object.
+ *   Calling the directive with a pointer equal to NULL is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive does not access a device to get the time.  It uses a recent
+ * snapshot provided by the Clock Driver.  Alternatively, the
+ * rtems_clock_get_realtime_timeval() directive may be used to get the time
+ * with higher precision and higher runtime overhead.
+ *
+ * See rtems_clock_get_realtime_coarse() and
+ * rtems_clock_get_realtime_coarse_timeval() to get the time in alternative
+ * formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_realtime_coarse_timeval( struct timeval *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-monotonic */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since some fixed time point in the past
+ *   measured using the CLOCK_MONOTONIC in seconds and nanoseconds format.
+ *
+ * @param[out] time_snapshot is the pointer to a bintime object.  The time
+ *   elapsed since some fixed time point in the past measured using the
+ *   CLOCK_MONOTONIC at some time point during the directive call will be
+ *   stored in this object.  Calling the directive with a pointer equal to NULL
+ *   is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive accesses a device provided by the Clock Driver to get the time
+ * in the highest precision available to the system.  Alternatively, the
+ * rtems_clock_get_monotonic_coarse() directive may be used to get the time
+ * with less precision and less runtime overhead.
+ *
+ * See rtems_clock_get_monotonic_bintime(),
+ * rtems_clock_get_monotonic_sbintime(), and
+ * rtems_clock_get_monotonic_timeval() to get the time in alternative formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_monotonic( struct timespec *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-monotonic-bintime */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since some fixed time point in the past
+ *   measured using the CLOCK_MONOTONIC in binary time format.
+ *
+ * @param[out] time_snapshot is the pointer to a bintime object.  The time
+ *   elapsed since some fixed time point in the past measured using the
+ *   CLOCK_MONOTONIC at some time point during the directive call will be
+ *   stored in this object.  Calling the directive with a pointer equal to NULL
+ *   is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive accesses a device provided by the Clock Driver to get the time
+ * in the highest precision available to the system.  Alternatively, the
+ * rtems_clock_get_monotonic_coarse_bintime() directive may be used to get the
+ * time with less precision and less runtime overhead.
+ *
+ * See rtems_clock_get_monotonic(), rtems_clock_get_monotonic_sbintime(), and
+ * rtems_clock_get_monotonic_timeval() to get the time in alternative formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_monotonic_bintime( struct bintime *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-monotonic-sbintime */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since some fixed time point in the past
+ *   measured using the CLOCK_MONOTONIC in signed binary time format.
+ *
+ * @return Returns the time elapsed since some fixed time point in the past
+ *   measured using the CLOCK_MONOTONIC at some time point during the directive
+ *   call.
+ *
+ * @par Notes
+ * @parblock
+ * The directive accesses a device provided by the Clock Driver to get the time
+ * in the highest precision available to the system.
+ *
+ * See rtems_clock_get_monotonic(), rtems_clock_get_monotonic_bintime(), and
+ * rtems_clock_get_monotonic_timeval() to get the time in alternative formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+int64_t rtems_clock_get_monotonic_sbintime( void );
+
+/* Generated from spec:/rtems/clock/if/get-monotonic-timeval */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since some fixed time point in the past
+ *   measured using the CLOCK_MONOTONIC in seconds and microseconds format.
+ *
+ * @param[out] time_snapshot is the pointer to a bintime object.  The time
+ *   elapsed since some fixed time point in the past measured using the
+ *   CLOCK_MONOTONIC at some time point during the directive call will be
+ *   stored in this object.  Calling the directive with a pointer equal to NULL
+ *   is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive accesses a device provided by the Clock Driver to get the time
+ * in the highest precision available to the system.  Alternatively, the
+ * rtems_clock_get_monotonic_coarse_timeval() directive may be used to get the
+ * time with less precision and less runtime overhead.
+ *
+ * See rtems_clock_get_monotonic(), rtems_clock_get_monotonic_bintime(), and
+ * rtems_clock_get_monotonic_sbintime() to get the time in alternative formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_monotonic_timeval( struct timeval *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-monotonic-coarse */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since some fixed time point in the past
+ *   measured using the CLOCK_MONOTONIC in coarse precision in seconds and
+ *   nanoseconds format.
+ *
+ * @param[out] time_snapshot is the pointer to a bintime object.  The time
+ *   elapsed since some fixed time point in the past measured using the
+ *   CLOCK_MONOTONIC at some time point close to the directive call will be
+ *   stored in this object.  Calling the directive with a pointer equal to NULL
+ *   is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive does not access a device to get the time.  It uses a recent
+ * snapshot provided by the Clock Driver.  Alternatively, the
+ * rtems_clock_get_monotonic() directive may be used to get the time with
+ * higher precision and higher runtime overhead.
+ *
+ * See rtems_clock_get_monotonic_coarse_bintime() and
+ * rtems_clock_get_monotonic_coarse_timeval() to get the time in alternative
+ * formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_monotonic_coarse( struct timespec *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-monotonic-coarse-bintime */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since some fixed time point in the past
+ *   measured using the CLOCK_MONOTONIC in coarse precision in binary time
+ *   format.
+ *
+ * @param[out] time_snapshot is the pointer to a bintime object.  The time
+ *   elapsed since some fixed time point in the past measured using the
+ *   CLOCK_MONOTONIC at some time point close to the directive call will be
+ *   stored in this object.  Calling the directive with a pointer equal to NULL
+ *   is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive does not access a device to get the time.  It uses a recent
+ * snapshot provided by the Clock Driver.  Alternatively, the
+ * rtems_clock_get_monotonic_bintime() directive may be used to get the time
+ * with higher precision and higher runtime overhead.
+ *
+ * See rtems_clock_get_monotonic_coarse() and
+ * rtems_clock_get_monotonic_coarse_timeval() to get the time in alternative
+ * formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_monotonic_coarse_bintime( struct bintime *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-monotonic-coarse-timeval */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since some fixed time point in the past
+ *   measured using the CLOCK_MONOTONIC in coarse precision in seconds and
+ *   microseconds format.
+ *
+ * @param[out] time_snapshot is the pointer to a bintime object.  The time
+ *   elapsed since some fixed time point in the past measured using the
+ *   CLOCK_MONOTONIC at some time point close to the directive call will be
+ *   stored in this object.  Calling the directive with a pointer equal to NULL
+ *   is undefined behaviour.
+ *
+ * @par Notes
+ * @parblock
+ * The directive does not access a device to get the time.  It uses a recent
+ * snapshot provided by the Clock Driver.  Alternatively, the
+ * rtems_clock_get_monotonic_timeval() directive may be used to get the time
+ * with higher precision and higher runtime overhead.
+ *
+ * See rtems_clock_get_monotonic_coarse() and
+ * rtems_clock_get_monotonic_coarse_bintime() to get the time in alternative
+ * formats.
+ * @endparblock
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_monotonic_coarse_timeval( struct timeval *time_snapshot );
+
+/* Generated from spec:/rtems/clock/if/get-boot-time */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since the Unix epoch at some time point during
+ *   system initialization in seconds and nanoseconds format.
+ *
+ * @param[out] boot_time is the pointer to a struct timespec object.  The time
+ *   elapsed since the Unix epoch at some time point during system
+ *   initialization call will be stored in this object.  Calling the directive
+ *   with a pointer equal to NULL is undefined behaviour.
+ *
+ * @par Notes
+ * See rtems_clock_get_boot_time_bintime() and
+ * rtems_clock_get_boot_time_timeval() to get the boot time in alternative
+ * formats.  Setting the CLOCK_REALTIME will also set the boot time.
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_boot_time( struct timespec *boot_time );
+
+/* Generated from spec:/rtems/clock/if/get-boot-time-bintime */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since the Unix epoch at some time point during
+ *   system initialization in binary time format.
+ *
+ * @param[out] boot_time is the pointer to a bintime object.  The time elapsed
+ *   since the Unix epoch at some time point during system initialization call
+ *   will be stored in this object.  Calling the directive with a pointer equal
+ *   to NULL is undefined behaviour.
+ *
+ * @par Notes
+ * See rtems_clock_get_boot_time() and rtems_clock_get_boot_time_timeval() to
+ * get the boot time in alternative formats.  Setting the CLOCK_REALTIME will
+ * also set the boot time.
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_boot_time_bintime( struct bintime *boot_time );
+
+/* Generated from spec:/rtems/clock/if/get-boot-time-timeval */
+
+/**
+ * @ingroup RTEMSAPIClassicClock
+ *
+ * @brief Gets the time elapsed since the Unix epoch at some time point during
+ *   system initialization in seconds and microseconds format.
+ *
+ * @param[out] boot_time is the pointer to a struct timeval object.  The time
+ *   elapsed since the Unix epoch at some time point during system
+ *   initialization call will be stored in this object.  Calling the directive
+ *   with a pointer equal to NULL is undefined behaviour.
+ *
+ * @par Notes
+ * See rtems_clock_get_boot_time() and rtems_clock_get_boot_time_bintime() to
+ * get the boot time in alternative formats.  Setting the CLOCK_REALTIME will
+ * also set the boot time.
+ *
+ * @par Constraints
+ * @parblock
+ * The following constraints apply to this directive:
+ *
+ * * The directive may be called from within any runtime context.
+ *
+ * * The directive will not cause the calling task to be preempted.
+ *
+ * * The directive requires a Clock Driver.
+ * @endparblock
+ */
+void rtems_clock_get_boot_time_timeval( struct timeval *boot_time );
+
 /* Generated from spec:/rtems/clock/if/get-seconds-since-epoch */
 
 /**
diff --git a/cpukit/score/src/kern_tc.c b/cpukit/score/src/kern_tc.c
index e999172..ea7d9ec 100644
--- a/cpukit/score/src/kern_tc.c
+++ b/cpukit/score/src/kern_tc.c
@@ -61,6 +61,7 @@
 #include <rtems/score/smp.h>
 #include <rtems/score/todimpl.h>
 #include <rtems/score/watchdogimpl.h>
+#include <rtems/rtems/clock.h>
 #endif /* __rtems__ */
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
@@ -699,6 +700,16 @@ getmicrotime(struct timeval *tvp)
 }
 #endif /* FFCLOCK */
 
+#ifdef __rtems__
+void
+rtems_clock_get_boot_time(struct timespec *boottime)
+{
+	struct bintime boottimebin;
+
+	getboottimebin(&boottimebin);
+	bintime2timespec(&boottimebin, boottime);
+}
+#endif /* __rtems__ */
 void
 getboottime(struct timeval *boottime)
 {
@@ -2646,4 +2657,49 @@ DB_SHOW_COMMAND(timecounter, db_show_timecounter)
 	    (intmax_t)th->th_boottime.sec, (uintmax_t)th->th_boottime.frac);
 }
 #endif
+#else /* __rtems__ */
+RTEMS_ALIAS(_Timecounter_Nanotime)
+void rtems_clock_get_realtime(struct timespec *);
+
+RTEMS_ALIAS(_Timecounter_Bintime)
+void rtems_clock_get_realtime_bintime(struct bintime *);
+
+RTEMS_ALIAS(_Timecounter_Microtime)
+void rtems_clock_get_realtime_timeval(struct timeval *);
+
+RTEMS_ALIAS(_Timecounter_Getnanotime)
+void rtems_clock_get_realtime_coarse(struct timespec *);
+
+RTEMS_ALIAS(_Timecounter_Getbintime)
+void rtems_clock_get_realtime_coarse_bintime(struct bintime *);
+
+RTEMS_ALIAS(_Timecounter_Getmicrotime)
+void rtems_clock_get_realtime_coarse_timeval(struct timeval *);
+
+RTEMS_ALIAS(_Timecounter_Nanouptime)
+void rtems_clock_get_monotonic(struct timespec *);
+
+RTEMS_ALIAS(_Timecounter_Binuptime)
+void rtems_clock_get_monotonic_bintime(struct bintime *);
+
+RTEMS_ALIAS(_Timecounter_Sbinuptime)
+sbintime_t rtems_clock_get_monotonic_sbintime(void);
+
+RTEMS_ALIAS(_Timecounter_Microuptime)
+void rtems_clock_get_monotonic_timeval(struct timeval *);
+
+RTEMS_ALIAS(_Timecounter_Getnanouptime)
+void rtems_clock_get_monotonic_coarse(struct timespec *);
+
+RTEMS_ALIAS(_Timecounter_Getbinuptime)
+void rtems_clock_get_monotonic_coarse_bintime(struct bintime *);
+
+RTEMS_ALIAS(_Timecounter_Getmicrouptime)
+void rtems_clock_get_monotonic_coarse_timeval(struct timeval *);
+
+RTEMS_ALIAS(_Timecounter_Getboottimebin)
+void rtems_clock_get_boot_time_bintime(struct bintime *);
+
+RTEMS_ALIAS(_Timecounter_Getboottime)
+void rtems_clock_get_boot_time_timeval(struct timeval *);
 #endif /* __rtems__ */

