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; }