int xntbase_switch(const char *name, u_long period, xntbase_t **basep)
{
xntbase_t *oldbase = *basep, *newbase;
int err = 0;
if (!*basep)
/* Switching from no time base to a valid one is ok,
we only need to assume that the old time base was the
master one. */
oldbase = &nktbase;
if (period == XN_APERIODIC_TICK) {
if (xntbase_periodic_p(oldbase)) {
/* The following call cannot fail. */
xntbase_alloc(name, XN_APERIODIC_TICK, 0, basep);
xntbase_free(oldbase);
}
} else {
if (xntbase_periodic_p(oldbase))
xntbase_update(oldbase, period);
else {
err = xntbase_alloc(name, period, 0, &newbase);
if (!err) {
int enabled = xntbase_enabled_p(oldbase);
*basep = newbase;
xntbase_free(oldbase);
if (enabled)
xntbase_start(newbase);
}
}
}
return err;
}
xnticks_t xnthread_get_timeout(xnthread_t *thread, xnticks_t tsc_ns)
{
xnticks_t timeout;
xntimer_t *timer;
if (!xnthread_test_state(thread,XNDELAY))
return 0LL;
if (xntimer_running_p(&thread->rtimer))
timer = &thread->rtimer;
else if (xntimer_running_p(&thread->ptimer))
timer = &thread->ptimer;
else
return 0LL;
/*
* The caller should have masked IRQs while collecting the
* timeout(s), so no tick could be announced in the meantime,
* and all timeouts would always use the same epoch
* value. Obviously, this can't be a valid assumption for
* aperiodic timers, which values are based on the hardware
* TSC, and as such the current time will change regardless of
* the interrupt state; for this reason, we use the "tsc_ns"
* input parameter (TSC converted to nanoseconds) the caller
* has passed us as the epoch value instead.
*/
if (xntbase_periodic_p(xnthread_time_base(thread)))
return xntimer_get_timeout(timer);
timeout = xntimer_get_date(timer);
if (timeout <= tsc_ns)
return 1;
return timeout - tsc_ns;
}
