From 57264c50597687e9365cce6f37bec9281bdaadfb Mon Sep 17 00:00:00 2001 From: Marian Buschsieweke Date: Thu, 6 Aug 2020 10:46:17 +0200 Subject: [PATCH] core: Access internal vars via helper funcs Replace accesses to `sched_active_thread`, `sched_active_pid`, and `sched_threads` with `thread_get_active()`, `thread_get_active_pid()`, and `thread_get_unchecked()` where sensible. --- core/cond.c | 2 +- core/include/debug.h | 4 +- core/include/thread_flags.h | 6 +-- core/mbox.c | 18 ++++----- core/msg.c | 81 +++++++++++++++++-------------------- core/msg_bus.c | 4 +- core/mutex.c | 16 ++++---- core/sched.c | 12 +++--- core/thread.c | 14 +++---- core/thread_flags.c | 10 ++--- 10 files changed, 81 insertions(+), 86 deletions(-) diff --git a/core/cond.c b/core/cond.c index 635ec1956e..361fb1fc84 100644 --- a/core/cond.c +++ b/core/cond.c @@ -35,7 +35,7 @@ void cond_init(cond_t *cond) void cond_wait(cond_t *cond, mutex_t *mutex) { unsigned irqstate = irq_disable(); - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); mutex_unlock(mutex); sched_set_status(me, STATUS_COND_BLOCKED); diff --git a/core/include/debug.h b/core/include/debug.h index 5e757688a2..9345aa73ca 100644 --- a/core/include/debug.h +++ b/core/include/debug.h @@ -46,8 +46,8 @@ extern "C" { #include "cpu_conf.h" #define DEBUG_PRINT(...) \ do { \ - if ((sched_active_thread == NULL) || \ - (sched_active_thread->stack_size >= \ + if ((thread_get_active() == NULL) || \ + (thread_get_active()->stack_size >= \ THREAD_EXTRA_STACKSIZE_PRINTF)) { \ printf(__VA_ARGS__); \ } \ diff --git a/core/include/thread_flags.h b/core/include/thread_flags.h index 6dfaedee28..dd31692688 100644 --- a/core/include/thread_flags.h +++ b/core/include/thread_flags.h @@ -132,11 +132,11 @@ thread_flags_t thread_flags_clear(thread_flags_t mask); * immediately, otherwise, it will suspend the thread (as * THREAD_STATUS_WAIT_ANY) until any of the flags in mask get set. * - * Both ways, it will clear and return (sched_active_thread-flags & mask). + * Both ways, it will clear and return (`thread_get_active()->flags & mask`). * * @param[in] mask mask of flags to wait for * - * @returns flags that caused return/wakeup ((sched_active_thread-flags & mask). + * @returns flags that caused return/wakeup (`thread_get_active()->flags & mask`). */ thread_flags_t thread_flags_wait_any(thread_flags_t mask); @@ -147,7 +147,7 @@ thread_flags_t thread_flags_wait_any(thread_flags_t mask); * immediately, otherwise, it will suspend the thread (as * THREAD_STATUS_WAIT_ALL) until all of the flags in mask have been set. * - * Both ways, it will clear and return (sched_active_thread-flags & mask). + * Both ways, it will clear and return (`thread_get_active()->flags & mask`). * * @param[in] mask mask of flags to wait for * diff --git a/core/mbox.c b/core/mbox.c index 6da424b7f9..e970bf829b 100644 --- a/core/mbox.c +++ b/core/mbox.c @@ -33,7 +33,7 @@ static void _wake_waiter(thread_t *thread, unsigned irqstate) sched_set_status(thread, STATUS_PENDING); DEBUG("mbox: Thread %" PRIkernel_pid ": _wake_waiter(): waking up " - "%" PRIkernel_pid ".\n", sched_active_pid, thread->pid); + "%" PRIkernel_pid ".\n", thread_getpid(), thread->pid); uint16_t process_priority = thread->priority; irq_restore(irqstate); @@ -43,16 +43,16 @@ static void _wake_waiter(thread_t *thread, unsigned irqstate) static void _wait(list_node_t *wait_list, unsigned irqstate) { DEBUG("mbox: Thread %" PRIkernel_pid " _wait(): going blocked.\n", - sched_active_pid); + thread_getpid()); - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); sched_set_status(me, STATUS_MBOX_BLOCKED); thread_add_to_list(wait_list, me); irq_restore(irqstate); thread_yield(); DEBUG("mbox: Thread %" PRIkernel_pid " _wait(): woke up.\n", - sched_active_pid); + thread_getpid()); } int _mbox_put(mbox_t *mbox, msg_t *msg, int blocking) @@ -63,7 +63,7 @@ int _mbox_put(mbox_t *mbox, msg_t *msg, int blocking) if (next) { DEBUG("mbox: Thread %" PRIkernel_pid " mbox 0x%08x: _tryput(): " - "there's a waiter.\n", sched_active_pid, (unsigned)mbox); + "there's a waiter.\n", thread_getpid(), (unsigned)mbox); thread_t *thread = container_of((clist_node_t *)next, thread_t, rq_entry); *(msg_t *)thread->wait_data = *msg; @@ -83,8 +83,8 @@ int _mbox_put(mbox_t *mbox, msg_t *msg, int blocking) } DEBUG("mbox: Thread %" PRIkernel_pid " mbox 0x%08x: _tryput(): " - "queued message.\n", sched_active_pid, (unsigned)mbox); - msg->sender_pid = sched_active_pid; + "queued message.\n", thread_getpid(), (unsigned)mbox); + msg->sender_pid = thread_getpid(); /* copy msg into queue */ mbox->msg_array[cib_put_unsafe(&mbox->cib)] = *msg; irq_restore(irqstate); @@ -98,7 +98,7 @@ int _mbox_get(mbox_t *mbox, msg_t *msg, int blocking) if (cib_avail(&mbox->cib)) { DEBUG("mbox: Thread %" PRIkernel_pid " mbox 0x%08x: _tryget(): " - "got queued message.\n", sched_active_pid, (unsigned)mbox); + "got queued message.\n", thread_getpid(), (unsigned)mbox); /* copy msg from queue */ *msg = mbox->msg_array[cib_get_unsafe(&mbox->cib)]; list_node_t *next = list_remove_head(&mbox->writers); @@ -113,7 +113,7 @@ int _mbox_get(mbox_t *mbox, msg_t *msg, int blocking) return 1; } else if (blocking) { - sched_active_thread->wait_data = (void *)msg; + thread_get_active()->wait_data = msg; _wait(&mbox->readers, irqstate); /* sender has copied message */ return 1; diff --git a/core/msg.c b/core/msg.c index fe203af28c..be61d70cc3 100644 --- a/core/msg.c +++ b/core/msg.c @@ -65,7 +65,7 @@ int msg_send(msg_t *m, kernel_pid_t target_pid) if (irq_is_in()) { return msg_send_int(m, target_pid); } - if (sched_active_pid == target_pid) { + if (thread_getpid() == target_pid) { return msg_send_to_self(m); } return _msg_send(m, target_pid, true, irq_disable()); @@ -76,7 +76,7 @@ int msg_try_send(msg_t *m, kernel_pid_t target_pid) if (irq_is_in()) { return msg_send_int(m, target_pid); } - if (sched_active_pid == target_pid) { + if (thread_getpid() == target_pid) { return msg_send_to_self(m); } return _msg_send(m, target_pid, false, irq_disable()); @@ -91,9 +91,9 @@ static int _msg_send(msg_t *m, kernel_pid_t target_pid, bool block, } #endif /* DEVELHELP */ - thread_t *target = (thread_t *)sched_threads[target_pid]; + thread_t *target = thread_get_unchecked(target_pid); - m->sender_pid = sched_active_pid; + m->sender_pid = thread_getpid(); if (target == NULL) { DEBUG("msg_send(): target thread %d does not exist\n", target_pid); @@ -101,11 +101,11 @@ static int _msg_send(msg_t *m, kernel_pid_t target_pid, bool block, return -1; } - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); DEBUG("msg_send() %s:%i: Sending from %" PRIkernel_pid " to %" PRIkernel_pid ". block=%i src->state=%i target->state=%i\n", RIOT_FILE_RELATIVE, - __LINE__, sched_active_pid, target_pid, + __LINE__, thread_getpid(), target_pid, block, me->status, target->status); if (target->status != STATUS_RECEIVE_BLOCKED) { @@ -125,9 +125,8 @@ static int _msg_send(msg_t *m, kernel_pid_t target_pid, bool block, } if (!block) { - DEBUG( - "msg_send: %" PRIkernel_pid ": Receiver not waiting, block=%u\n", - me->pid, block); + DEBUG("msg_send: %" PRIkernel_pid ": Receiver not waiting, " + "block=%u\n", me->pid, block); irq_restore(state); return 0; } @@ -135,7 +134,7 @@ static int _msg_send(msg_t *m, kernel_pid_t target_pid, bool block, DEBUG("msg_send: %" PRIkernel_pid ": going send blocked.\n", me->pid); - me->wait_data = (void *)m; + me->wait_data = m; int newstatus; @@ -146,7 +145,7 @@ static int _msg_send(msg_t *m, kernel_pid_t target_pid, bool block, newstatus = STATUS_SEND_BLOCKED; } - sched_set_status((thread_t *)me, newstatus); + sched_set_status(me, newstatus); thread_add_to_list(&(target->msg_waiters), me); @@ -166,7 +165,7 @@ static int _msg_send(msg_t *m, kernel_pid_t target_pid, bool block, PRIkernel_pid " to %" PRIkernel_pid ".\n", me->pid, thread_getpid(), target_pid); /* copy msg to target */ - msg_t *target_message = (msg_t *)target->wait_data; + msg_t *target_message = target->wait_data; *target_message = *m; sched_set_status(target, STATUS_PENDING); @@ -181,8 +180,8 @@ int msg_send_to_self(msg_t *m) { unsigned state = irq_disable(); - m->sender_pid = sched_active_pid; - int res = queue_msg((thread_t *)sched_active_thread, m); + m->sender_pid = thread_getpid(); + int res = queue_msg(thread_get_active(), m); irq_restore(state); return res; @@ -196,7 +195,7 @@ static int _msg_send_oneway(msg_t *m, kernel_pid_t target_pid) } #endif /* DEVELHELP */ - thread_t *target = (thread_t *)sched_threads[target_pid]; + thread_t *target = thread_get_unchecked(target_pid); if (target == NULL) { DEBUG("%s: target thread %d does not exist\n", __func__, target_pid); @@ -242,7 +241,7 @@ int msg_send_bus(msg_t *m, msg_bus_t *bus) const uint32_t event_mask = (1UL << (m->type & 0x1F)); int count = 0; - m->sender_pid = in_irq ? KERNEL_PID_ISR : sched_active_pid; + m->sender_pid = in_irq ? KERNEL_PID_ISR : thread_getpid(); unsigned state = irq_disable(); @@ -269,11 +268,11 @@ int msg_send_bus(msg_t *m, msg_bus_t *bus) int msg_send_receive(msg_t *m, msg_t *reply, kernel_pid_t target_pid) { - assert(sched_active_pid != target_pid); + assert(thread_getpid() != target_pid); unsigned state = irq_disable(); - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); sched_set_status(me, STATUS_REPLY_BLOCKED); - me->wait_data = (void *)reply; + me->wait_data = reply; /* we re-use (abuse) reply for sending, because wait_data might be * overwritten if the target is not in RECEIVE_BLOCKED */ @@ -286,20 +285,20 @@ int msg_reply(msg_t *m, msg_t *reply) { unsigned state = irq_disable(); - thread_t *target = (thread_t *)sched_threads[m->sender_pid]; + thread_t *target = thread_get_unchecked(m->sender_pid); assert(target != NULL); if (target->status != STATUS_REPLY_BLOCKED) { DEBUG("msg_reply(): %" PRIkernel_pid ": Target \"%" PRIkernel_pid - "\" not waiting for reply.", sched_active_thread->pid, + "\" not waiting for reply.", thread_getpid(), target->pid); irq_restore(state); return -1; } DEBUG("msg_reply(): %" PRIkernel_pid ": Direct msg copy.\n", - sched_active_thread->pid); + thread_getpid()); /* copy msg to target */ msg_t *target_message = (msg_t *)target->wait_data; *target_message = *reply; @@ -313,11 +312,11 @@ int msg_reply(msg_t *m, msg_t *reply) int msg_reply_int(msg_t *m, msg_t *reply) { - thread_t *target = (thread_t *)sched_threads[m->sender_pid]; + thread_t *target = thread_get_unchecked(m->sender_pid); if (target->status != STATUS_REPLY_BLOCKED) { DEBUG("msg_reply_int(): %" PRIkernel_pid ": Target \"%" PRIkernel_pid - "\" not waiting for reply.", sched_active_thread->pid, + "\" not waiting for reply.", thread_getpid(), target->pid); return -1; } @@ -344,9 +343,9 @@ static int _msg_receive(msg_t *m, int block) unsigned state = irq_disable(); DEBUG("_msg_receive: %" PRIkernel_pid ": _msg_receive.\n", - sched_active_thread->pid); + thread_getpid()); - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); int queue_index = -1; @@ -361,9 +360,8 @@ static int _msg_receive(msg_t *m, int block) } if (queue_index >= 0) { - DEBUG( - "_msg_receive: %" PRIkernel_pid ": _msg_receive(): We've got a queued message.\n", - sched_active_thread->pid); + DEBUG("_msg_receive: %" PRIkernel_pid ": _msg_receive(): We've got a " + "queued message.\n", thread_getpid()); *m = me->msg_array[queue_index]; } else { @@ -373,21 +371,19 @@ static int _msg_receive(msg_t *m, int block) list_node_t *next = list_remove_head(&me->msg_waiters); if (next == NULL) { - DEBUG( - "_msg_receive: %" PRIkernel_pid ": _msg_receive(): No thread in waiting list.\n", - sched_active_thread->pid); + DEBUG("_msg_receive: %" PRIkernel_pid ": _msg_receive(): No thread in " + "waiting list.\n", thread_getpid()); if (queue_index < 0) { - DEBUG( - "_msg_receive(): %" PRIkernel_pid ": No msg in queue. Going blocked.\n", - sched_active_thread->pid); + DEBUG("_msg_receive(): %" PRIkernel_pid ": No msg in queue. Going " + "blocked.\n", thread_getpid()); sched_set_status(me, STATUS_RECEIVE_BLOCKED); irq_restore(state); thread_yield_higher(); /* sender copied message */ - assert(sched_active_thread->status != STATUS_RECEIVE_BLOCKED); + assert(thread_get_active()->status != STATUS_RECEIVE_BLOCKED); } else { irq_restore(state); @@ -396,9 +392,8 @@ static int _msg_receive(msg_t *m, int block) return 1; } else { - DEBUG( - "_msg_receive: %" PRIkernel_pid ": _msg_receive(): Waking up waiting thread.\n", - sched_active_thread->pid); + DEBUG("_msg_receive: %" PRIkernel_pid ": _msg_receive(): Waking up " + "waiting thread.\n", thread_getpid()); thread_t *sender = container_of((clist_node_t *)next, thread_t, rq_entry); @@ -435,9 +430,9 @@ static int _msg_receive(msg_t *m, int block) int msg_avail(void) { DEBUG("msg_available: %" PRIkernel_pid ": msg_available.\n", - sched_active_thread->pid); + thread_getpid()); - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); int queue_index = -1; @@ -450,7 +445,7 @@ int msg_avail(void) void msg_init_queue(msg_t *array, int num) { - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); me->msg_array = array; cib_init(&(me->msg_queue), num); @@ -460,7 +455,7 @@ void msg_queue_print(void) { unsigned state = irq_disable(); - thread_t *thread = (thread_t *)sched_active_thread; + thread_t *thread = thread_get_active(); cib_t *msg_queue = &thread->msg_queue; msg_t *msg_array = thread->msg_array; unsigned int i = msg_queue->read_count & msg_queue->mask; diff --git a/core/msg_bus.c b/core/msg_bus.c index d648d12193..f151d0f953 100644 --- a/core/msg_bus.c +++ b/core/msg_bus.c @@ -37,7 +37,7 @@ void msg_bus_attach(msg_bus_t *bus, msg_bus_entry_t *entry) entry->next.next = NULL; entry->event_mask = 0; - entry->pid = sched_active_pid; + entry->pid = thread_getpid(); state = irq_disable(); list_add(&bus->subs, &entry->next); @@ -62,7 +62,7 @@ msg_bus_entry_t *msg_bus_get_entry(msg_bus_t *bus) msg_bus_entry_t *subscriber = container_of(e, msg_bus_entry_t, next); - if (subscriber->pid == sched_active_pid) { + if (subscriber->pid == thread_getpid()) { s = subscriber; break; } diff --git a/core/mutex.c b/core/mutex.c index 0a52e72a9b..d40611d6d9 100644 --- a/core/mutex.c +++ b/core/mutex.c @@ -36,20 +36,20 @@ int _mutex_lock(mutex_t *mutex, volatile uint8_t *blocking) { unsigned irqstate = irq_disable(); - DEBUG("PID[%" PRIkernel_pid "]: Mutex in use.\n", sched_active_pid); + DEBUG("PID[%" PRIkernel_pid "]: Mutex in use.\n", thread_getpid()); if (mutex->queue.next == NULL) { /* mutex is unlocked. */ mutex->queue.next = MUTEX_LOCKED; DEBUG("PID[%" PRIkernel_pid "]: mutex_wait early out.\n", - sched_active_pid); + thread_getpid()); irq_restore(irqstate); return 1; } else if (*blocking) { - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); DEBUG("PID[%" PRIkernel_pid "]: Adding node to mutex queue: prio: %" - PRIu32 "\n", sched_active_pid, (uint32_t)me->priority); + PRIu32 "\n", thread_getpid(), (uint32_t)me->priority); sched_set_status(me, STATUS_MUTEX_BLOCKED); if (mutex->queue.next == MUTEX_LOCKED) { mutex->queue.next = (list_node_t *)&me->rq_entry; @@ -75,7 +75,7 @@ void mutex_unlock(mutex_t *mutex) unsigned irqstate = irq_disable(); DEBUG("mutex_unlock(): queue.next: %p pid: %" PRIkernel_pid "\n", - (void *)mutex->queue.next, sched_active_pid); + (void *)mutex->queue.next, thread_getpid()); if (mutex->queue.next == NULL) { /* the mutex was not locked */ @@ -110,7 +110,7 @@ void mutex_unlock(mutex_t *mutex) void mutex_unlock_and_sleep(mutex_t *mutex) { DEBUG("PID[%" PRIkernel_pid "]: unlocking mutex. queue.next: %p, and " - "taking a nap\n", sched_active_pid, (void *)mutex->queue.next); + "taking a nap\n", thread_getpid(), (void *)mutex->queue.next); unsigned irqstate = irq_disable(); if (mutex->queue.next) { @@ -129,8 +129,8 @@ void mutex_unlock_and_sleep(mutex_t *mutex) } } - DEBUG("PID[%" PRIkernel_pid "]: going to sleep.\n", sched_active_pid); - sched_set_status((thread_t *)sched_active_thread, STATUS_SLEEPING); + DEBUG("PID[%" PRIkernel_pid "]: going to sleep.\n", thread_getpid()); + sched_set_status(thread_get_active(), STATUS_SLEEPING); irq_restore(irqstate); thread_yield_higher(); } diff --git a/core/sched.c b/core/sched.c index d933898e05..2080985c14 100644 --- a/core/sched.c +++ b/core/sched.c @@ -102,7 +102,7 @@ static void _unschedule(thread_t *active_thread) int __attribute__((used)) sched_run(void) { - thread_t *active_thread = (thread_t *)sched_active_thread; + thread_t *active_thread = thread_get_active(); if (!IS_USED(MODULE_CORE_IDLE_THREAD)) { if (!runqueue_bitcache) { @@ -147,7 +147,7 @@ int __attribute__((used)) sched_run(void) next_thread->status = STATUS_RUNNING; sched_active_pid = next_thread->pid; - sched_active_thread = (volatile thread_t *)next_thread; + sched_active_thread = next_thread; #ifdef MODULE_MPU_STACK_GUARD mpu_configure( @@ -194,7 +194,7 @@ void sched_set_status(thread_t *process, thread_status_t status) void sched_switch(uint16_t other_prio) { - thread_t *active_thread = (thread_t *)sched_active_thread; + thread_t *active_thread = thread_get_active(); uint16_t current_prio = active_thread->priority; int on_runqueue = (active_thread->status >= STATUS_ON_RUNQUEUE); @@ -221,13 +221,13 @@ void sched_switch(uint16_t other_prio) NORETURN void sched_task_exit(void) { DEBUG("sched_task_exit: ending thread %" PRIkernel_pid "...\n", - sched_active_thread->pid); + thread_getpid()); (void)irq_disable(); - sched_threads[sched_active_pid] = NULL; + sched_threads[thread_getpid()] = NULL; sched_num_threads--; - sched_set_status((thread_t *)sched_active_thread, STATUS_STOPPED); + sched_set_status(thread_get_active(), STATUS_STOPPED); sched_active_thread = NULL; cpu_switch_context_exit(); diff --git a/core/thread.c b/core/thread.c index 0c5f61f96c..b723bbfde1 100644 --- a/core/thread.c +++ b/core/thread.c @@ -32,7 +32,7 @@ thread_status_t thread_getstatus(kernel_pid_t pid) { - volatile thread_t *thread = thread_get(pid); + thread_t *thread = thread_get(pid); return thread ? thread->status : STATUS_NOT_FOUND; } @@ -40,7 +40,7 @@ thread_status_t thread_getstatus(kernel_pid_t pid) const char *thread_getname(kernel_pid_t pid) { #ifdef DEVELHELP - volatile thread_t *thread = thread_get(pid); + thread_t *thread = thread_get(pid); return thread ? thread->name : NULL; #else (void)pid; @@ -55,7 +55,7 @@ void thread_zombify(void) } irq_disable(); - sched_set_status((thread_t *)sched_active_thread, STATUS_ZOMBIE); + sched_set_status(thread_get_active(), STATUS_ZOMBIE); irq_enable(); thread_yield_higher(); @@ -70,7 +70,7 @@ int thread_kill_zombie(kernel_pid_t pid) int result = (int)STATUS_NOT_FOUND; - thread_t *thread = (thread_t *)thread_get(pid); + thread_t *thread = thread_get(pid); if (!thread) { DEBUG("thread_kill: Thread does not exist!\n"); @@ -98,7 +98,7 @@ void thread_sleep(void) } unsigned state = irq_disable(); - sched_set_status((thread_t *)sched_active_thread, STATUS_SLEEPING); + sched_set_status(thread_get_active(), STATUS_SLEEPING); irq_restore(state); thread_yield_higher(); } @@ -109,7 +109,7 @@ int thread_wakeup(kernel_pid_t pid) unsigned old_state = irq_disable(); - thread_t *thread = (thread_t *)thread_get(pid); + thread_t *thread = thread_get(pid); if (!thread) { DEBUG("thread_wakeup: Thread does not exist!\n"); @@ -135,7 +135,7 @@ int thread_wakeup(kernel_pid_t pid) void thread_yield(void) { unsigned old_state = irq_disable(); - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); if (me->status >= STATUS_ON_RUNQUEUE) { clist_lpoprpush(&sched_runqueues[me->priority]); diff --git a/core/thread_flags.c b/core/thread_flags.c index 88957c3abe..21697d08f8 100644 --- a/core/thread_flags.c +++ b/core/thread_flags.c @@ -52,7 +52,7 @@ static void _thread_flags_wait(thread_flags_t mask, thread_t *thread, thread_flags_t thread_flags_clear(thread_flags_t mask) { - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); mask = _thread_flags_clear_atomic(me, mask); DEBUG("thread_flags_clear(): pid %" PRIkernel_pid " clearing 0x%08x\n", @@ -62,7 +62,7 @@ thread_flags_t thread_flags_clear(thread_flags_t mask) static void _thread_flags_wait_any(thread_flags_t mask) { - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); unsigned state = irq_disable(); if (!(me->flags & mask)) { @@ -75,7 +75,7 @@ static void _thread_flags_wait_any(thread_flags_t mask) thread_flags_t thread_flags_wait_any(thread_flags_t mask) { - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); _thread_flags_wait_any(mask); return _thread_flags_clear_atomic(me, mask); @@ -84,7 +84,7 @@ thread_flags_t thread_flags_wait_any(thread_flags_t mask) thread_flags_t thread_flags_wait_one(thread_flags_t mask) { _thread_flags_wait_any(mask); - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); thread_flags_t tmp = me->flags & mask; /* clear all but least significant bit */ tmp &= (~tmp + 1); @@ -94,7 +94,7 @@ thread_flags_t thread_flags_wait_one(thread_flags_t mask) thread_flags_t thread_flags_wait_all(thread_flags_t mask) { unsigned state = irq_disable(); - thread_t *me = (thread_t *)sched_active_thread; + thread_t *me = thread_get_active(); if (!((me->flags & mask) == mask)) { DEBUG(