static int mbx_wait_until(MBX *mbx, int *fravbs, RTIME time, RT_TASK *rt_current)
{
unsigned long flags;
flags = rt_global_save_flags_and_cli();
if (!(*fravbs))
{
void *retp;
rt_current->blocked_on = (void *)mbx;
mbx->waiting_task = rt_current;
if ((rt_current->resume_time = time) > rt_smp_time_h[rtai_cpuid()])
{
rt_current->state |= (RT_SCHED_MBXSUSP | RT_SCHED_DELAYED);
rem_ready_current(rt_current);
enq_timed_task(rt_current);
rt_schedule();
}
if (unlikely((retp = rt_current->blocked_on) != NULL))
{
mbx->waiting_task = NULL;
rt_global_restore_flags(flags);
return likely(retp > RTP_HIGERR) ? RTE_TIMOUT : (retp == RTP_UNBLKD ? RTE_UNBLKD : RTE_OBJREM);
}
}
rt_global_restore_flags(flags);
return 0;
}
RTAI_SYSCALL_MODE int rt_insert_timer(struct rt_tasklet_struct *timer, int priority, RTIME firing_time, RTIME period, void (*handler)(unsigned long), unsigned long data, int pid)
{
spinlock_t *lock;
unsigned long flags, cpuid;
RT_TASK *timer_manager;
// timer initialization
timer->uses_fpu = 0;
if (pid >= 0) {
if (!handler) {
return -EINVAL;
}
timer->handler = handler;
timer->data = data;
} else {
if (timer->handler != NULL || timer->handler == (void *)1) {
timer->handler = (void *)1;
timer->data = data;
}
}
timer->priority = priority;
REALTIME2COUNT(firing_time)
timer->firing_time = firing_time;
timer->period = period;
if (!pid) {
timer->task = 0;
timer->cpuid = cpuid = NUM_CPUS > 1 ? rtai_cpuid() : 0;
} else {
timer->cpuid = cpuid = NUM_CPUS > 1 ? (timer->task)->runnable_on_cpus : 0;
(timer->task)->priority = priority;
rt_copy_to_user(timer->usptasklet, timer, sizeof(struct rt_usp_tasklet_struct));
}
// timer insertion in timers_list
flags = rt_spin_lock_irqsave(lock = &timers_lock[LIST_CPUID]);
enq_timer(timer);
rt_spin_unlock_irqrestore(flags, lock);
// timers_manager priority inheritance
if (timer->priority < (timer_manager = &timers_manager[LIST_CPUID])->priority) {
timer_manager->priority = timer->priority;
}
// timers_task deadline inheritance
flags = rt_global_save_flags_and_cli();
if (timers_list[LIST_CPUID].next == timer && (timer_manager->state & RT_SCHED_DELAYED) && firing_time < timer_manager->resume_time) {
timer_manager->resume_time = firing_time;
rem_timed_task(timer_manager);
enq_timed_task(timer_manager);
rt_schedule();
}
rt_global_restore_flags(flags);
return 0;
}
RTAI_SYSCALL_MODE int _rt_bits_wait_until(BITS *bits, int testfun, unsigned long testmasks, int exitfun, unsigned long exitmasks, RTIME time, unsigned long *resulting_mask, int space)
{
RT_TASK *rt_current;
unsigned long flags, mask = 0;
int retval;
CHECK_BITS_MAGIC(bits);
flags = rt_global_save_flags_and_cli();
if (!test_fun[testfun](bits, testmasks)) {
void *retpnt;
long bits_test[2];
rt_current = RT_CURRENT;
TEST_BUF(rt_current, bits_test);
TEST_FUN(rt_current) = testfun;
TEST_MASK(rt_current) = testmasks;
rt_current->blocked_on = &bits->queue;
if ((rt_current->resume_time = time) > get_time()) {
rt_current->state |= (RT_SCHED_SEMAPHORE | RT_SCHED_DELAYED);
rem_ready_current(rt_current);
enqueue_blocked(rt_current, &bits->queue, 1);
enq_timed_task(rt_current);
rt_schedule();
} else {
rt_current->queue.prev = rt_current->queue.next = &rt_current->queue;
}
if (unlikely((retpnt = rt_current->blocked_on) != NULL)) {
if (likely(retpnt != RTP_OBJREM)) {
dequeue_blocked(rt_current);
retval = likely(retpnt > RTP_HIGERR) ? RTE_TIMOUT : RTE_UNBLKD;
} else {
rt_current->prio_passed_to = NULL;
retval = RTE_OBJREM;
}
goto retmask;
}
}
retval = 0;
mask = bits->mask;
exec_fun[exitfun](bits, exitmasks);
retmask:
rt_global_restore_flags(flags);
if (resulting_mask) {
if (space) {
*resulting_mask = mask;
} else {
rt_copy_to_user(resulting_mask, &mask, sizeof(mask));
}
}
return retval;
}
RTAI_SYSCALL_MODE void rt_set_timer_firing_time(struct rt_tasklet_struct *timer, RTIME firing_time)
{
unsigned long flags;
RT_TASK *timer_manager;
set_timer_firing_time(timer, firing_time);
flags = rt_global_save_flags_and_cli();
if (timers_list[TIMER_CPUID].next == timer && ((timer_manager = &timers_manager[TIMER_CPUID])->state & RT_SCHED_DELAYED) && firing_time < timer_manager->resume_time) {
timer_manager->resume_time = firing_time;
rem_timed_task(timer_manager);
enq_timed_task(timer_manager);
rt_schedule();
}
rt_global_restore_flags(flags);
}
RTAI_SYSCALL_MODE int rt_timer_insert(struct rtdm_timer_struct *timer, int priority, RTIME firing_time, RTIME period, void (*handler)(unsigned long), unsigned long data)
{
spinlock_t *lock;
unsigned long flags, cpuid;
RT_TASK *timer_manager;
if (!handler) {
return -EINVAL;
}
timer->handler = handler;
timer->data = data;
timer->priority = priority;
timer->firing_time = firing_time;
timer->period = period;
REALTIME2COUNT(firing_time)
timer->cpuid = cpuid = NUM_CPUS > 1 ? rtai_cpuid() : 0;
// timer insertion in timers_list
flags = rt_spin_lock_irqsave(lock = &timers_lock[LIST_CPUID]);
enq_timer(timer);
rt_spin_unlock_irqrestore(flags, lock);
// timers_manager priority inheritance
if (timer->priority < (timer_manager = &timers_manager[LIST_CPUID])->priority) {
timer_manager->priority = timer->priority;
}
// timers_task deadline inheritance
flags = rt_global_save_flags_and_cli();
if (timers_list[LIST_CPUID].next == timer && (timer_manager->state & RT_SCHED_DELAYED) && firing_time < timer_manager->resume_time) {
timer_manager->resume_time = firing_time;
rem_timed_task(timer_manager);
enq_timed_task(timer_manager);
rt_schedule();
}
rt_global_restore_flags(flags);
return 0;
}
