/*
|
* Copyright (C) 2005 Philippe Gerum <rpm@xenomai.org>.
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2 of the License, or (at your option) any later version.
|
*
|
* This library is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* Lesser General Public License for more details.
|
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
*/
|
|
#include <sys/types.h>
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <errno.h>
|
#include <stdint.h>
|
#include <pthread.h>
|
#include <unistd.h>
|
#include <time.h>
|
#include <sys/time.h>
|
#include <cobalt/uapi/time.h>
|
#include <cobalt/ticks.h>
|
#include <asm/xenomai/syscall.h>
|
#include <asm/xenomai/tsc.h>
|
#include "umm.h"
|
#include "internal.h"
|
|
/**
|
* @ingroup cobalt_api
|
* @defgroup cobalt_api_time Clocks and timers
|
*
|
* Cobalt/POSIX clock and timer services
|
*
|
* Cobalt supports three built-in clocks:
|
*
|
* CLOCK_REALTIME maps to the nucleus system clock, keeping time as the amount
|
* of time since the Epoch, with a resolution of one nanosecond.
|
*
|
* CLOCK_MONOTONIC maps to an architecture-dependent high resolution
|
* counter, so is suitable for measuring short time
|
* intervals. However, when used for sleeping (with
|
* clock_nanosleep()), the CLOCK_MONOTONIC clock has a resolution of
|
* one nanosecond, like the CLOCK_REALTIME clock.
|
*
|
* CLOCK_MONOTONIC_RAW is Linux-specific, and provides monotonic time
|
* values from a hardware timer which is not adjusted by NTP. This is
|
* strictly equivalent to CLOCK_MONOTONIC with Cobalt, which is not
|
* NTP adjusted either.
|
*
|
* In addition, external clocks can be dynamically registered using
|
* the cobalt_clock_register() service. These clocks are fully managed
|
* by Cobalt extension code, which should advertise each incoming tick
|
* by calling xnclock_tick() for the relevant clock, from an interrupt
|
* context.
|
*
|
* Timer objects may be created with the timer_create() service using
|
* any of the built-in or external clocks. The resolution of these
|
* timers is clock-specific. However, built-in clocks all have
|
* nanosecond resolution, as specified for clock_nanosleep().
|
*
|
* @see
|
* <a href="http://www.opengroup.org/onlinepubs/000095399/functions/xsh_chap02_08.html#tag_02_08_05">
|
* Specification.</a>
|
*
|
*@{
|
*/
|
|
/**
|
* Get the resolution of the specified clock.
|
*
|
* This service returns, at the address @a res, if it is not @a NULL, the
|
* resolution of the clock @a clock_id.
|
*
|
* For both CLOCK_REALTIME and CLOCK_MONOTONIC, this resolution is the duration
|
* of one system clock tick. No other clock is supported.
|
*
|
* @param clock_id clock identifier, either CLOCK_REALTIME or CLOCK_MONOTONIC;
|
*
|
* @param tp the address where the resolution of the specified clock will be
|
* stored on success.
|
*
|
* @retval 0 on success;
|
* @retval -1 with @a errno set if:
|
* - EINVAL, @a clock_id is invalid;
|
*
|
* @see
|
* <a href="http://www.opengroup.org/onlinepubs/000095399/functions/clock_getres.html">
|
* Specification.</a>
|
*
|
* @apitags{unrestricted}
|
*/
|
COBALT_IMPL(int, clock_getres, (clockid_t clock_id, struct timespec *tp))
|
{
|
int ret;
|
|
#ifdef __USE_TIME_BITS64
|
ret = -XENOMAI_SYSCALL2(sc_cobalt_clock_getres64, clock_id, tp);
|
#else
|
ret = -XENOMAI_SYSCALL2(sc_cobalt_clock_getres, clock_id, tp);
|
#endif
|
|
if (ret) {
|
errno = ret;
|
return -1;
|
}
|
|
return 0;
|
}
|
|
static int __do_clock_host_realtime(struct timespec *ts)
|
{
|
uint64_t now, base, mask, cycle_delta, nsec;
|
struct xnvdso_hostrt_data *hostrt_data;
|
uint32_t mult, shift;
|
unsigned long rem;
|
urwstate_t tmp;
|
|
if (!xnvdso_test_feature(cobalt_vdso, XNVDSO_FEAT_HOST_REALTIME))
|
return -1;
|
|
hostrt_data = &cobalt_vdso->hostrt_data;
|
|
if (!hostrt_data->live)
|
return -1;
|
|
/*
|
* The following is essentially a verbatim copy of the
|
* mechanism in the kernel.
|
*/
|
unsynced_read_block(&tmp, &hostrt_data->lock) {
|
now = cobalt_read_legacy_tsc();
|
base = hostrt_data->cycle_last;
|
mask = hostrt_data->mask;
|
mult = hostrt_data->mult;
|
shift = hostrt_data->shift;
|
ts->tv_sec = hostrt_data->wall_sec;
|
nsec = hostrt_data->wall_nsec;
|
}
|
|
cycle_delta = (now - base) & mask;
|
nsec += (cycle_delta * mult) >> shift;
|
|
ts->tv_sec += cobalt_divrem_billion(nsec, &rem);
|
ts->tv_nsec = rem;
|
|
return 0;
|
}
|
|
static int __do_clock_gettime(clockid_t clock_id, struct timespec *tp)
|
{
|
#ifdef __USE_TIME_BITS64
|
return -XENOMAI_SYSCALL2(sc_cobalt_clock_gettime64, clock_id, tp);
|
#else
|
return -XENOMAI_SYSCALL2(sc_cobalt_clock_gettime, clock_id, tp);
|
#endif
|
}
|
|
static int gettime_via_tsc(clockid_t clock_id, struct timespec *tp)
|
{
|
unsigned long rem;
|
xnticks_t ns;
|
int ret;
|
|
switch (clock_id) {
|
case CLOCK_HOST_REALTIME:
|
ret = __do_clock_host_realtime(tp);
|
break;
|
case CLOCK_MONOTONIC:
|
case CLOCK_MONOTONIC_RAW:
|
ns = cobalt_ticks_to_ns(cobalt_read_legacy_tsc());
|
tp->tv_sec = cobalt_divrem_billion(ns, &rem);
|
tp->tv_nsec = rem;
|
return 0;
|
case CLOCK_REALTIME:
|
ns = cobalt_ticks_to_ns(cobalt_read_legacy_tsc());
|
ns += cobalt_vdso->wallclock_offset;
|
tp->tv_sec = cobalt_divrem_billion(ns, &rem);
|
tp->tv_nsec = rem;
|
return 0;
|
default:
|
ret = __do_clock_gettime(clock_id, tp);
|
}
|
|
if (ret) {
|
errno = ret;
|
return -1;
|
}
|
|
return 0;
|
}
|
|
static int gettime_via_vdso(clockid_t clock_id, struct timespec *tp)
|
{
|
int ret;
|
|
switch (clock_id) {
|
case CLOCK_REALTIME:
|
case CLOCK_HOST_REALTIME:
|
ret = __cobalt_vdso_gettime(CLOCK_REALTIME, tp);
|
break;
|
case CLOCK_MONOTONIC:
|
case CLOCK_MONOTONIC_RAW:
|
ret = __cobalt_vdso_gettime(clock_id, tp);
|
break;
|
default:
|
ret = __do_clock_gettime(clock_id, tp);
|
}
|
|
if (ret) {
|
errno = ret;
|
return -1;
|
}
|
|
return 0;
|
}
|
|
/**
|
* Read the specified clock.
|
*
|
* This service returns, at the address @a tp the current value of the clock @a
|
* clock_id. If @a clock_id is:
|
* - CLOCK_REALTIME, the clock value represents the amount of time since the
|
* Epoch, with a precision of one system clock tick;
|
* - CLOCK_MONOTONIC or CLOCK_MONOTONIC_RAW, the clock value is given
|
* by an architecture-dependent high resolution counter, with a
|
* precision independent from the system clock tick duration.
|
* - CLOCK_HOST_REALTIME, the clock value as seen by the host, typically
|
* Linux. Resolution and precision depend on the host, but it is guaranteed
|
* that both, host and Cobalt, see the same information.
|
*
|
* @param clock_id clock identifier, either CLOCK_REALTIME, CLOCK_MONOTONIC,
|
* or CLOCK_HOST_REALTIME;
|
*
|
* @param tp the address where the value of the specified clock will be stored.
|
*
|
* @retval 0 on success;
|
* @retval -1 with @a errno set if:
|
* - EINVAL, @a clock_id is invalid.
|
*
|
* @see
|
* <a href="http://www.opengroup.org/onlinepubs/000095399/functions/clock_gettime.html">
|
* Specification.</a>
|
*
|
* @apitags{unrestricted}
|
*/
|
COBALT_IMPL(int, clock_gettime, (clockid_t clock_id, struct timespec *tp))
|
{
|
if (cobalt_use_legacy_tsc())
|
return gettime_via_tsc(clock_id, tp);
|
|
return gettime_via_vdso(clock_id, tp);
|
}
|
|
/**
|
* Set the specified clock.
|
*
|
* Set the CLOCK_REALTIME or Cobalt-specific clocks.
|
*
|
* @param clock_id the id of the clock to be set. CLOCK_REALTIME,
|
* and Cobalt-specific clocks are supported.
|
*
|
* @param tp the address of a struct timespec specifying the new date.
|
*
|
* @retval 0 on success;
|
* @retval -1 with @a errno set if:
|
* - EINVAL, @a clock_id is undefined;
|
* - EINVAL, the date specified by @a tp is invalid.
|
*
|
* @see
|
* <a href="http://www.opengroup.org/onlinepubs/000095399/functions/clock_settime.html">
|
* Specification.</a>
|
*
|
* @note Setting CLOCK_REALTIME may cause the caller to switch to
|
* secondary mode.
|
*
|
* @apitags{unrestricted, switch-secondary}
|
*/
|
COBALT_IMPL(int, clock_settime, (clockid_t clock_id, const struct timespec *tp))
|
{
|
int ret;
|
|
if (clock_id == CLOCK_REALTIME && !cobalt_use_legacy_tsc())
|
return __STD(clock_settime(CLOCK_REALTIME, tp));
|
|
#ifdef __USE_TIME_BITS64
|
ret = -XENOMAI_SYSCALL2(sc_cobalt_clock_settime64, clock_id, tp);
|
#else
|
ret = -XENOMAI_SYSCALL2(sc_cobalt_clock_settime, clock_id, tp);
|
#endif
|
if (ret) {
|
errno = ret;
|
return -1;
|
}
|
|
return 0;
|
}
|
|
/* @apitags{unrestricted} */
|
|
COBALT_IMPL(int, clock_adjtime, (clockid_t clock_id, struct timex *tx))
|
{
|
int ret;
|
|
#ifdef __USE_TIME_BITS64
|
ret = -XENOMAI_SYSCALL2(sc_cobalt_clock_adjtime64, clock_id, tx);
|
#else
|
ret = -XENOMAI_SYSCALL2(sc_cobalt_clock_adjtime, clock_id, tx);
|
#endif
|
|
if (ret < 0) {
|
errno = ret;
|
return -1;
|
}
|
|
return ret;
|
}
|
|
/**
|
* Sleep some amount of time.
|
*
|
* This service suspends the calling thread until the wakeup time specified by
|
* @a rqtp, or a signal is delivered to the caller. If the flag TIMER_ABSTIME is
|
* set in the @a flags argument, the wakeup time is specified as an absolute
|
* value of the clock @a clock_id. If the flag TIMER_ABSTIME is not set, the
|
* wakeup time is specified as a time interval.
|
*
|
* If this service is interrupted by a signal, the flag TIMER_ABSTIME is not
|
* set, and @a rmtp is not @a NULL, the time remaining until the specified
|
* wakeup time is returned at the address @a rmtp.
|
*
|
* The resolution of this service is one system clock tick.
|
*
|
* @param clock_id clock identifier, either CLOCK_REALTIME or CLOCK_MONOTONIC.
|
*
|
* @param flags one of:
|
* - 0 meaning that the wakeup time @a rqtp is a time interval;
|
* - TIMER_ABSTIME, meaning that the wakeup time is an absolute value of the
|
* clock @a clock_id.
|
*
|
* @param rqtp address of the wakeup time.
|
*
|
* @param rmtp address where the remaining time before wakeup will be stored if
|
* the service is interrupted by a signal.
|
*
|
* @return 0 on success;
|
* @return an error number if:
|
* - EPERM, the caller context is invalid;
|
* - ENOTSUP, the specified clock is unsupported;
|
* - EINVAL, the specified wakeup time is invalid;
|
* - EINTR, this service was interrupted by a signal.
|
*
|
* @see
|
* <a href="http://www.opengroup.org/onlinepubs/000095399/functions/clock_nanosleep.html">
|
* Specification.</a>
|
*
|
* @apitags{xthread-only, switch-primary}
|
*/
|
COBALT_IMPL(int, clock_nanosleep, (clockid_t clock_id,
|
int flags,
|
const struct timespec *rqtp, struct timespec *rmtp))
|
{
|
int ret, oldtype;
|
|
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);
|
|
#ifdef __USE_TIME_BITS64
|
ret = -XENOMAI_SYSCALL4(sc_cobalt_clock_nanosleep64,
|
clock_id, flags, rqtp, rmtp);
|
#else
|
ret = -XENOMAI_SYSCALL4(sc_cobalt_clock_nanosleep,
|
clock_id, flags, rqtp, rmtp);
|
#endif
|
|
pthread_setcanceltype(oldtype, NULL);
|
|
return ret;
|
}
|
|
/**
|
* Sleep some amount of time.
|
*
|
* This service suspends the calling thread until the wakeup time specified by
|
* @a rqtp, or a signal is delivered. The wakeup time is specified as a time
|
* interval.
|
*
|
* If this service is interrupted by a signal and @a rmtp is not @a NULL, the
|
* time remaining until the specified wakeup time is returned at the address @a
|
* rmtp.
|
*
|
* The resolution of this service is one system clock tick.
|
*
|
* @param rqtp address of the wakeup time.
|
*
|
* @param rmtp address where the remaining time before wakeup will be stored if
|
* the service is interrupted by a signal.
|
*
|
* @retval 0 on success;
|
* @retval -1 with @a errno set if:
|
* - EPERM, the caller context is invalid;
|
* - EINVAL, the specified wakeup time is invalid;
|
* - EINTR, this service was interrupted by a signal.
|
*
|
* @see
|
* <a href="http://www.opengroup.org/onlinepubs/000095399/functions/nanosleep.html">
|
* Specification.</a>
|
*
|
* @apitags{xthread-only, switch-primary}
|
*/
|
COBALT_IMPL(int, nanosleep, (const struct timespec *rqtp, struct timespec *rmtp))
|
{
|
int ret;
|
|
ret = __WRAP(clock_nanosleep(CLOCK_REALTIME, 0, rqtp, rmtp));
|
if (ret) {
|
errno = ret;
|
return -1;
|
}
|
|
return 0;
|
}
|
|
/* @apitags{thread-unrestricted, switch-primary} */
|
|
COBALT_IMPL(unsigned int, sleep, (unsigned int seconds))
|
{
|
struct timespec rqt, rem;
|
int ret;
|
|
if (cobalt_get_current_fast() == XN_NO_HANDLE)
|
return __STD(sleep(seconds));
|
|
rqt.tv_sec = seconds;
|
rqt.tv_nsec = 0;
|
ret = __WRAP(clock_nanosleep(CLOCK_MONOTONIC, 0, &rqt, &rem));
|
if (ret)
|
return rem.tv_sec;
|
|
return 0;
|
}
|
|
/* @apitags{thread-unrestricted, switch-primary} */
|
|
COBALT_IMPL(int, usleep, (useconds_t usec))
|
{
|
struct timespec rqt;
|
|
if (cobalt_get_current_fast() == XN_NO_HANDLE)
|
return __STD(usleep(usec));
|
|
rqt.tv_sec = usec / 1000000;
|
rqt.tv_nsec = (usec % 1000000) * 1000;
|
return __WRAP(clock_nanosleep(CLOCK_MONOTONIC, 0, &rqt, NULL));
|
}
|
|
/* @apitags{unrestricted} */
|
|
COBALT_IMPL(int, gettimeofday, (struct timeval *tv, struct timezone *tz))
|
{
|
struct timespec ts;
|
int ret = __WRAP(clock_gettime(CLOCK_REALTIME, &ts));
|
if (ret == 0) {
|
tv->tv_sec = ts.tv_sec;
|
tv->tv_usec = ts.tv_nsec / 1000;
|
}
|
return ret;
|
}
|
|
/* @apitags{unrestricted} */
|
|
COBALT_IMPL(time_t, time, (time_t *t))
|
{
|
struct timespec ts;
|
int ret = __WRAP(clock_gettime(CLOCK_REALTIME, &ts));
|
if (ret)
|
return (time_t)-1;
|
|
if (t)
|
*t = ts.tv_sec;
|
return ts.tv_sec;
|
}
|
/** @} */
|
