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.

Author: maribu

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

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__); \
         } \

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
  *

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;

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,21 +91,21 @@ 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);
         irq_restore(state);
         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,17 +125,16 @@ 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;
         }
 
         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;

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