void xntimer_freeze(void)
{
int nr_cpus, cpu;
spl_t s;
trace_mark(xn_nucleus, timer_freeze, MARK_NOARGS);
xnlock_get_irqsave(&nklock, s);
nr_cpus = xnarch_num_online_cpus();
for (cpu = 0; cpu < nr_cpus; cpu++) {
xntimerq_t *timerq = &xnpod_sched_slot(cpu)->timerqueue;
xntimerh_t *holder;
while ((holder = xntimerq_head(timerq)) != NULL) {
__setbits(aplink2timer(holder)->status, XNTIMER_DEQUEUED);
xntimerq_remove(timerq, holder);
}
/* Dequeuing all timers from the master time base
* freezes all slave time bases the same way, so there
* is no need to handle anything more here. */
}
xnlock_put_irqrestore(&nklock, s);
}
void xnclock_core_local_shot(struct xnsched *sched)
{
struct xntimerdata *tmd;
struct xntimer *timer;
xnsticks_t delay;
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 (sched->status & XNINTCK)
return;
tmd = xnclock_this_timerdata(&nkclock);
h = xntimerq_head(&tmd->q);
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 ___xnsched_run()),
* or a timer with an earlier timeout date is scheduled,
* 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);
}
}
}
int xntimer_heading_p(struct xntimer *timer)
{
struct xnsched *sched = timer->sched;
xntimerq_t *q;
xntimerh_t *h;
q = xntimer_percpu_queue(timer);
h = xntimerq_head(q);
if (h == &timer->aplink)
return 1;
if (sched->lflags & XNHDEFER) {
h = xntimerq_second(q);
if (h == &timer->aplink)
return 1;
}
return 0;
}
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);
}