xnticks_t xntimer_get_timeout_aperiodic(xntimer_t *timer)
{
xnticks_t tsc = xnarch_get_cpu_tsc();
if (xntimerh_date(&timer->aplink) < tsc)
return 1; /* Will elapse shortly. */
return xnarch_tsc_to_ns(xntimerh_date(&timer->aplink) - tsc);
}
static void
xntimer_adjust_periodic(xntimer_t *timer, xnsticks_t delta)
{
xnticks_t now = timer->base->jiffies;
xnsticks_t diff;
xntlholder_date(&timer->plink) -= delta;
diff = now - xntlholder_date(&timer->plink);
if (testbits(timer->status, XNTIMER_PERIODIC)) {
xnticks_t period = xntimer_interval(timer);
xnticks_t mod;
timer->pexpect -= delta;
if ((xnsticks_t) (diff - period) >= 0) {
/* timer should tick several times before now, instead
of calling timer->handler several times, we change
the timer date without changing its pexpect, so that
timer we can call timer->handler only once and the lost
ticks will be counted as overruns. */
mod = xnarch_mod64(diff, period);
xntimerh_date(&timer->aplink) += diff - mod;
} else if (delta < 0
&& testbits(timer->status, XNTIMER_FIRED)
&& (xnsticks_t) (diff + period) <= 0) {
/* timer is periodic and NOT waiting for its first shot,
so we make it tick sooner than its original date in
order to avoid the case where by adjusting time to a
sooner date, real-time periodic timers do not tick
until the original date has passed. */
mod = xnarch_mod64(-diff, period);
xntimerh_date(&timer->aplink) += diff + mod;
timer->pexpect += diff + mod;
}
}
if (diff >= 0) {
xnstat_counter_inc(&timer->fired);
timer->handler(timer);
if (!xntimer_reload_p(timer))
return;
xntlholder_date(&timer->plink) += timer->interval;
}
xntimer_enqueue_periodic(timer);
}
int xntimer_start_aperiodic(xntimer_t *timer,
xnticks_t value, xnticks_t interval,
xntmode_t mode)
{
xnticks_t date, now;
trace_mark(xn_nucleus, timer_start,
"timer %p base %s value %Lu interval %Lu mode %u",
timer, xntimer_base(timer)->name, value, interval, mode);
if (!testbits(timer->status, XNTIMER_DEQUEUED))
xntimer_dequeue_aperiodic(timer);
now = xnarch_get_cpu_tsc();
__clrbits(timer->status,
XNTIMER_REALTIME | XNTIMER_FIRED | XNTIMER_PERIODIC);
switch (mode) {
case XN_RELATIVE:
if ((xnsticks_t)value < 0)
return -ETIMEDOUT;
date = xnarch_ns_to_tsc(value) + now;
break;
case XN_REALTIME:
__setbits(timer->status, XNTIMER_REALTIME);
value -= nktbase.wallclock_offset;
/* fall through */
default: /* XN_ABSOLUTE || XN_REALTIME */
date = xnarch_ns_to_tsc(value);
if ((xnsticks_t)(date - now) <= 0)
return -ETIMEDOUT;
break;
}
xntimerh_date(&timer->aplink) = date;
timer->interval = XN_INFINITE;
if (interval != XN_INFINITE) {
timer->interval = xnarch_ns_to_tsc(interval);
timer->pexpect = date;
__setbits(timer->status, XNTIMER_PERIODIC);
}
xntimer_enqueue_aperiodic(timer);
if (xntimer_heading_p(timer)) {
if (xntimer_sched(timer) != xnpod_current_sched())
xntimer_next_remote_shot(xntimer_sched(timer));
else
xntimer_next_local_shot(xntimer_sched(timer));
}
return 0;
}
void __xntimer_init(struct xntimer *timer,
struct xnclock *clock,
void (*handler)(struct xntimer *timer),
struct xnsched *sched,
int flags)
{
spl_t s __maybe_unused;
int cpu;
#ifdef CONFIG_XENO_OPT_EXTCLOCK
timer->clock = clock;
#endif
xntimerh_init(&timer->aplink);
xntimerh_date(&timer->aplink) = XN_INFINITE;
xntimer_set_priority(timer, XNTIMER_STDPRIO);
timer->status = (XNTIMER_DEQUEUED|(flags & XNTIMER_INIT_MASK));
timer->handler = handler;
timer->interval_ns = 0;
/*
* Timers are affine to a scheduler slot, which is in turn
* bound to a real-time CPU. If no scheduler affinity was
* given, assign the timer to the scheduler slot of the
* current CPU if real-time, otherwise default to the
* scheduler slot of the first real-time CPU.
*/
if (sched)
timer->sched = sched;
else {
cpu = ipipe_processor_id();
if (!xnsched_supported_cpu(cpu))
cpu = first_cpu(xnsched_realtime_cpus);
timer->sched = xnsched_struct(cpu);
}
#ifdef CONFIG_XENO_OPT_STATS
#ifdef CONFIG_XENO_OPT_EXTCLOCK
timer->tracker = clock;
#endif
ksformat(timer->name, XNOBJECT_NAME_LEN, "%d/%s",
current->pid, current->comm);
xntimer_reset_stats(timer);
xnlock_get_irqsave(&nklock, s);
list_add_tail(&timer->next_stat, &clock->timerq);
clock->nrtimers++;
xnvfile_touch(&clock->timer_vfile);
xnlock_put_irqrestore(&nklock, s);
#endif /* CONFIG_XENO_OPT_STATS */
}
void __xntimer_init(xntimer_t *timer, xntbase_t *base,
void (*handler) (xntimer_t *timer))
{
/* CAUTION: Setup from xntimer_init() must not depend on the
periodic/aperiodic timing mode. */
xntimerh_init(&timer->aplink);
xntimerh_date(&timer->aplink) = XN_INFINITE;
#ifdef CONFIG_XENO_OPT_TIMING_PERIODIC
timer->base = base;
xntlholder_init(&timer->plink);
xntlholder_date(&timer->plink) = XN_INFINITE;
#endif /* CONFIG_XENO_OPT_TIMING_PERIODIC */
xntimer_set_priority(timer, XNTIMER_STDPRIO);
timer->status = XNTIMER_DEQUEUED;
timer->handler = handler;
timer->interval = 0;
timer->sched = xnpod_current_sched();
#ifdef CONFIG_XENO_OPT_STATS
{
spl_t s;
if (!xnpod_current_thread() || xnpod_shadow_p())
snprintf(timer->name, XNOBJECT_NAME_LEN, "%d/%s",
current->pid, current->comm);
else
xnobject_copy_name(timer->name,
xnpod_current_thread()->name);
inith(&timer->tblink);
xnstat_counter_set(&timer->scheduled, 0);
xnstat_counter_set(&timer->fired, 0);
xnlock_get_irqsave(&nklock, s);
appendq(&base->timerq, &timer->tblink);
base->timerq_rev++;
xnlock_put_irqrestore(&nklock, s);
}
#endif /* CONFIG_XENO_OPT_TIMING_PERIODIC */
xnarch_init_display_context(timer);
}
* whichever comes first.
*/
sched->lflags &= ~XNHDEFER;
timer = container_of(h, struct xntimer, aplink);
if (unlikely(timer == &sched->htimer)) {
if (xnsched_resched_p(sched) ||
!xnthread_test_state(sched->curr, XNROOT)) {
h = xntimerq_second(&tmd->q);
if (h) {
sched->lflags |= XNHDEFER;
timer = container_of(h, struct xntimer, aplink);
}
}
}
delay = xntimerh_date(&timer->aplink) - xnclock_core_read_raw();
if (delay < 0)
delay = 0;
else if (delay > ULONG_MAX)
delay = ULONG_MAX;
xntrace_tick((unsigned)delay);
ipipe_timer_set(delay);
}
#ifdef CONFIG_SMP
void xnclock_core_remote_shot(struct xnsched *sched)
{
cpumask_t mask = cpumask_of_cpu(xnsched_cpu(sched));
ipipe_send_ipi(IPIPE_HRTIMER_IPI, mask);
void xntimer_next_local_shot(xnsched_t *sched)
{
struct xntimer *timer;
xnsticks_t delay;
xntimerq_it_t it;
xntimerh_t *h;
/*
* Do not reprogram locally when inside the tick handler -
* will be done on exit anyway. Also exit if there is no
* pending timer.
*/
if (testbits(sched->status, XNINTCK))
return;
h = xntimerq_it_begin(&sched->timerqueue, &it);
if (h == NULL)
return;
/*
* Here we try to defer the host tick heading the timer queue,
* so that it does not preempt a real-time activity uselessly,
* in two cases:
*
* 1) a rescheduling is pending for the current CPU. We may
* assume that a real-time thread is about to resume, so we
* want to move the host tick out of the way until the host
* kernel resumes, unless there is no other outstanding
* timers.
*
* 2) the current thread is running in primary mode, in which
* case we may also defer the host tick until the host kernel
* resumes.
*
* The host tick deferral is cleared whenever Xenomai is about
* to yield control to the host kernel (see
* __xnpod_schedule()), or a timer with an earlier timeout
* date is scheduled, whichever comes first.
*/
__clrbits(sched->status, XNHDEFER);
timer = aplink2timer(h);
if (unlikely(timer == &sched->htimer)) {
if (xnsched_self_resched_p(sched) ||
!xnthread_test_state(sched->curr, XNROOT)) {
h = xntimerq_it_next(&sched->timerqueue, &it, h);
if (h) {
__setbits(sched->status, XNHDEFER);
timer = aplink2timer(h);
}
}
}
delay = xntimerh_date(&timer->aplink) -
(xnarch_get_cpu_tsc() + nklatency);
if (delay < 0)
delay = 0;
else if (delay > ULONG_MAX)
delay = ULONG_MAX;
xnarch_trace_tick((unsigned)delay);
xnarch_program_timer_shot(delay);
}
void xntimer_tick_aperiodic(void)
{
xnsched_t *sched = xnpod_current_sched();
xntimerq_t *timerq = &sched->timerqueue;
xntimerh_t *holder;
xntimer_t *timer;
xnsticks_t delta;
xnticks_t now;
/*
* Optimisation: any local timer reprogramming triggered by
* invoked timer handlers can wait until we leave the tick
* handler. Use this status flag as hint to
* xntimer_start_aperiodic.
*/
__setbits(sched->status, XNINTCK);
now = xnarch_get_cpu_tsc();
while ((holder = xntimerq_head(timerq)) != NULL) {
timer = aplink2timer(holder);
/*
* If the delay to the next shot is greater than the
* intrinsic latency value, we may stop scanning the
* timer queue there, since timeout dates are ordered
* by increasing values.
*/
delta = (xnsticks_t)(xntimerh_date(&timer->aplink) - now);
if (delta > (xnsticks_t)nklatency)
break;
trace_mark(xn_nucleus, timer_expire, "timer %p", timer);
xntimer_dequeue_aperiodic(timer);
xnstat_counter_inc(&timer->fired);
if (likely(timer != &sched->htimer)) {
if (likely(!testbits(nktbase.status, XNTBLCK)
|| testbits(timer->status, XNTIMER_NOBLCK))) {
timer->handler(timer);
now = xnarch_get_cpu_tsc();
/*
* If the elapsed timer has no reload
* value, or was re-enqueued or killed
* by the timeout handler: don't not
* re-enqueue it for the next shot.
*/
if (!xntimer_reload_p(timer))
continue;
__setbits(timer->status, XNTIMER_FIRED);
} else if (likely(!testbits(timer->status, XNTIMER_PERIODIC))) {
/*
* Postpone the next tick to a
* reasonable date in the future,
* waiting for the timebase to be
* unlocked at some point.
*/
xntimerh_date(&timer->aplink) = xntimerh_date(&sched->htimer.aplink);
continue;
}
} else {
/*
* By postponing the propagation of the
* low-priority host tick to the interrupt
* epilogue (see xnintr_irq_handler()), we
* save some I-cache, which translates into
* precious microsecs on low-end hw.
*/
__setbits(sched->status, XNHTICK);
__clrbits(sched->status, XNHDEFER);
if (!testbits(timer->status, XNTIMER_PERIODIC))
continue;
}
do {
xntimerh_date(&timer->aplink) += timer->interval;
} while (xntimerh_date(&timer->aplink) < now + nklatency);
xntimer_enqueue_aperiodic(timer);
}
__clrbits(sched->status, XNINTCK);
xntimer_next_local_shot(sched);
}
xnticks_t xntimer_get_raw_expiry_aperiodic(xntimer_t *timer)
{
return xntimerh_date(&timer->aplink);
}
xnticks_t xntimer_get_date_aperiodic(xntimer_t *timer)
{
return xnarch_tsc_to_ns(xntimerh_date(&timer->aplink));
}
* whichever comes first.
*/
sched->lflags &= ~XNHDEFER;
timer = container_of(h, struct xntimer, aplink);
if (unlikely(timer == &sched->htimer)) {
if (xnsched_resched_p(sched) ||
!xnthread_test_state(sched->curr, XNROOT)) {
h = xntimerq_it_next(&tmd->q, &it, h);
if (h) {
sched->lflags |= XNHDEFER;
timer = container_of(h, struct xntimer, aplink);
}
}
}
delay = xntimerh_date(&timer->aplink) -
(xnclock_core_read_raw() + nkclock.gravity);
if (delay < 0)
delay = 0;
else if (delay > ULONG_MAX)
delay = ULONG_MAX;
xntrace_tick((unsigned)delay);
ipipe_timer_set(delay);
}
#ifdef CONFIG_SMP
void xnclock_core_remote_shot(struct xnsched *sched)
{
/**
* Arm a timer.
*
* Activates a timer so that the associated timeout handler will be
* fired after each expiration time. A timer can be either periodic or
* one-shot, depending on the reload value passed to this routine. The
* given timer must have been previously initialized.
*
* A timer is attached to the clock specified in xntimer_init().
*
* @param timer The address of a valid timer descriptor.
*
* @param value The date of the initial timer shot, expressed in
* nanoseconds.
*
* @param interval The reload value of the timer. It is a periodic
* interval value to be used for reprogramming the next timer shot,
* expressed in nanoseconds. If @a interval is equal to XN_INFINITE,
* the timer will not be reloaded after it has expired.
*
* @param mode The timer mode. It can be XN_RELATIVE if @a value shall
* be interpreted as a relative date, XN_ABSOLUTE for an absolute date
* based on the monotonic clock of the related time base (as returned
* my xnclock_read_monotonic()), or XN_REALTIME if the absolute date
* is based on the adjustable real-time date for the relevant clock
* (obtained from xnclock_read_realtime()).
*
* @return 0 is returned upon success, or -ETIMEDOUT if an absolute
* date in the past has been given. In such an event, the timer is
* nevertheless armed for the next shot in the timeline if @a interval
* is different from XN_INFINITE.
*
* @coretags{unrestricted, atomic-entry}
*/
int xntimer_start(struct xntimer *timer,
xnticks_t value, xnticks_t interval,
xntmode_t mode)
{
struct xnclock *clock = xntimer_clock(timer);
xntimerq_t *q = xntimer_percpu_queue(timer);
xnticks_t date, now, delay, period;
unsigned long gravity;
struct xnsched *sched;
int ret = 0;
trace_cobalt_timer_start(timer, value, interval, mode);
if ((timer->status & XNTIMER_DEQUEUED) == 0)
xntimer_dequeue(timer, q);
now = xnclock_read_raw(clock);
timer->status &= ~(XNTIMER_REALTIME | XNTIMER_FIRED | XNTIMER_PERIODIC);
switch (mode) {
case XN_RELATIVE:
if ((xnsticks_t)value < 0)
return -ETIMEDOUT;
date = xnclock_ns_to_ticks(clock, value) + now;
break;
case XN_REALTIME:
timer->status |= XNTIMER_REALTIME;
value -= xnclock_get_offset(clock);
/* fall through */
default: /* XN_ABSOLUTE || XN_REALTIME */
date = xnclock_ns_to_ticks(clock, value);
if ((xnsticks_t)(date - now) <= 0) {
ret = -ETIMEDOUT;
if (interval == XN_INFINITE)
return ret;
/*
* We are late on arrival for the first
* delivery, wait for the next shot on the
* periodic time line.
*/
delay = now - date;
period = xnclock_ns_to_ticks(clock, interval);
date += period * (xnarch_div64(delay, period) + 1);
}
break;
}
/*
* To cope with the basic system latency, we apply a clock
* gravity value, which is the amount of time expressed in
* clock ticks by which we should anticipate the shot for any
* outstanding timer. The gravity value varies with the type
* of context the timer wakes up, i.e. irq handler, kernel or
* user thread.
*/
gravity = xntimer_gravity(timer);
xntimerh_date(&timer->aplink) = date - gravity;
if (now >= xntimerh_date(&timer->aplink))
xntimerh_date(&timer->aplink) += gravity / 2;
timer->interval_ns = XN_INFINITE;
timer->interval = XN_INFINITE;
if (interval != XN_INFINITE) {
timer->interval_ns = interval;
timer->interval = xnclock_ns_to_ticks(clock, interval);
timer->periodic_ticks = 0;
timer->start_date = date;
timer->pexpect_ticks = 0;
timer->status |= XNTIMER_PERIODIC;
}
xntimer_enqueue(timer, q);
timer->status |= XNTIMER_RUNNING;
if (xntimer_heading_p(timer)) {
sched = xntimer_sched(timer);
if (sched != xnsched_current())
xnclock_remote_shot(clock, sched);
else
xnclock_program_shot(clock, sched);
}
return ret;
}
