added basic syscall handler that allows a task to yield, sleep and delete/create a task

Author: itzandroidtab

klib/rtos/base_task.hpp

@@ -0,0 +1,42 @@
+# set the sources
+set(SOURCES 
+    ${CMAKE_CURRENT_SOURCE_DIR}/syscall.cpp
+)
+
+set(HEADERS_PRIVATE 
+    ${CMAKE_CURRENT_SOURCE_DIR}/base_task.hpp
+)
+
+set(HEADERS_PUBLIC 
+    ${CMAKE_CURRENT_SOURCE_DIR}/scheduler.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/syscall.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/task.hpp
+)
+
+# add the library
+add_library(rtos OBJECT
+    ${SOURCES}
+    ${HEADERS_PUBLIC}
+    ${HEADERS_PRIVATE}
+)
+set_target_properties(rtos PROPERTIES FOLDER "rtos")
+
+# alias projectname::rtos to rtos
+add_library(${PROJECT_NAME}::rtos ALIAS rtos)
+
+# enable C++20 support for the library
+target_compile_features(rtos PUBLIC cxx_std_23)
+
+# link to the traget_cpu_options to get all the cpu flags
+target_link_libraries(rtos PUBLIC target_cpu_options target_cpu klib)
+
+# Global includes. Used by all targets
+# Note:
+#   - header can be included by C++ code `#include <klib/klib.hpp>`
+#   - header location in project: ${CMAKE_CURRENT_BINARY_DIR}/generated_headers
+target_include_directories(
+    rtos PUBLIC
+        "$<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>"
+        "$<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>"
+        "$<BUILD_INTERFACE:${GENERATED_HEADERS_DIR}>"
+)

rtos/CMakeLists.txt

@@ -0,0 +1,43 @@
+#ifndef KLIB_RTOS_BASE_TASK_HPP
+#define KLIB_RTOS_BASE_TASK_HPP
+
+#include <cstdint>
+#include <cstdlib>
+
+#include <klib/units.hpp>
+
+namespace klib::rtos::detail {
+    /**
+     * @brief Task to run in the RTOS
+     * 
+     * @tparam StackSize 
+     */
+    class base_task {
+    public:
+        // time to sleep for the task
+        volatile klib::time::ms time_to_sleep;
+
+        // pointer to the current stack position
+        size_t* stack_pointer;
+
+        // current priority of the task
+        uint8_t current_priority;
+
+        // the base priority of the task
+        const uint8_t priority;
+
+        /**
+         * @brief Construct a new base task
+         * 
+         * @param priority 
+         */
+        base_task(uint8_t priority = 0): 
+            time_to_sleep(0),
+            stack_pointer(nullptr),
+            current_priority(priority),
+            priority(priority)
+        {}
+    };
+}
+
+#endif

rtos/base_task.hpp

@@ -8,10 +8,24 @@
 #include <rtos/rtos.hpp>
 
 #include "task.hpp"
+#include "syscall.hpp"
 
 namespace klib::rtos {
-    template <uint32_t CpuId, typename Irq>
     class scheduler {
+    public:
+        /**
+         * @brief All the available syscalls
+         * 
+         */
+        enum class syscalls {
+            create_task = 0,
+            delete_task = 1,
+            yield = 2,
+            sleep = 3,
+            malloc = 4,
+            free = 5
+        };
+
     protected:
         // make sure we can register our callback with the systick handler
         static_assert(SYSTICK_CALLBACK_ENABLED, "Systick callback needs to be enabled to switch tasks");
@@ -46,6 +60,13 @@ namespace klib::rtos {
          * 
          */
         static void schedule_irq() {
+            // check if we have any tasks when we are called
+            // by the systick interrupt
+            if (tasks.size() == 0) {
+                // no tasks to schedule
+                return;
+            }
+
             // TODO: implement tick count for tasks
             // decrement sleep time for all tasks
             for (size_t i = 0; i < tasks.size(); i++) {
@@ -54,18 +75,6 @@ namespace klib::rtos {
                 }
             }
 
-            // remove tasks that are marked for deletion. We move backwards
-            // to not mess up the indexing when erasing. Note this is something
-            // that is specific to our dynamic array implementation. 
-            // TODO: update this when changing away from the dynamic array
-            if (tasks.size() > 0) {
-                for (auto it = tasks.end() - 1; it != tasks.begin(); it--) {
-                    if ((*it)->marked_for_deletion) {
-                        tasks.erase(it);
-                    }
-                }
-            }
-
             // call the scheduler to pick the next task
             schedule();
         }
@@ -76,14 +85,23 @@ namespace klib::rtos {
          *
          */
         static void schedule() {
-            if (!tasks.size()) {
-                return;
-            }
+            // schedule the next task. We use the priority to pick
+            // the next task to run. We always pick the first task
+            // with the highest priority that is not sleeping. If no
+            // task is ready we run the idle task.
+            next_task = (current_task == nullptr ? &idle_task : (
+                current_task->time_to_sleep.value == 0 ? current_task : &idle_task
+            ));
 
             // TODO: implement a better scheduling algorithm
-            // check if we have a task that is not sleeping
             for (size_t i = 0; i < tasks.size(); i++) {
-                if (tasks[i]->time_to_sleep.value == 0) {
+                if (tasks[i]->time_to_sleep.value > 0) {
+                    // task is sleeping
+                    continue;
+                }
+
+                // task is not sleeping, check priority
+                if (tasks[i]->current_priority > next_task->current_priority) {
                     next_task = tasks[i];
                     break;
                 }
@@ -112,26 +130,22 @@ namespace klib::rtos {
          * @brief Start the scheduler
          *
          */
+        template <uint32_t CpuId, typename Irq>
         static void start() {
             // update the callback to our scheduler
             io::systick<CpuId, SYSTICK_CALLBACK_ENABLED>::set_callback(schedule_irq);
 
             // register our interrupt to the pendsv interrupt
-            // Irq::template register_irq<Irq::arm_vector::pendsv>(pendsv_handler);
             Irq::template register_irq<Irq::arm_vector::pendsv>(pendsv);
 
+            // register the syscall handler
+            Irq::template register_irq<Irq::arm_vector::svcall>(klib::target::rtos::detail::sycall_handler<scheduler>);
+
             // add the idle task to the scheduler. This task is always ready to run
             create_task(&idle_task);
 
             // start the scheduler from the target
             klib::target::rtos::detail::scheduler_start();
-
-            // endless loop to wait on the start of the scheduler
-            while (true) {
-                // wait for a interrupt. The systick callback
-                // should schedule what task to run
-                asm volatile("wfi");
-            }
         }
 
         /**
@@ -144,25 +158,70 @@ namespace klib::rtos {
             // add the task to the queue
             tasks.push_back(task);
         }
-
+        
+    public:
         /**
-         * @brief Sleep the current task for the given time
+         * @brief Syscall handler, called when a syscall is invoked 
+         * by the target implementation. Parameters need to be passed
+         * in registers r1-r3. These are converted to the correct
+         * types based on the syscall.
          * 
+         * @param number 
+         * @param arg0 
+         * @param arg1 
+         * @param arg2 
+         * @return uint32_t 
          */
-        static void sleep(klib::time::ms time) {
-            // TODO: change this to use syscalls. This should stop
-            // the current task from running and switch to another task
-            // if available. As we are in unprivileged mode we cannot
-            // trigger a context switch ourselves.
-
-            // set the time to sleep for the current task
-            current_task->time_to_sleep.value = time.value;
-
-            // wait until the time to sleep is over
-            while (current_task->time_to_sleep.value > 0) {
-                // wait for the systick to wake us up
-                asm volatile("wfi");
+        static uint32_t syscall_handler(syscalls number, uint32_t arg0, uint32_t arg1, uint32_t arg2) {
+            switch (number) {
+                case syscalls::create_task:
+                    // add the task to the scheduler
+                    tasks.push_back(reinterpret_cast<detail::base_task*>(arg0));
+                    break;
+
+                case syscalls::delete_task:
+                    // find and remove the task from the scheduler. We move backwards
+                    // to not mess up the indexing when erasing. Note this is something
+                    // that is specific to our dynamic array implementation. 
+                    // TODO: update this when changing away from the dynamic array
+                    for (size_t i = 0; i < tasks.size(); i++) {
+                        if (tasks[i] == reinterpret_cast<detail::base_task*>(arg0)) {
+                            // erase the provided task
+                            tasks.erase(tasks.begin() + i);
+
+                            // check if we are running the task we are deleting
+                            if (current_task == reinterpret_cast<detail::base_task*>(arg0)) {
+                                // clear the current task and switch to the 
+                                // next one
+                                current_task = nullptr;
+
+                                // switch to the next task
+                                schedule();
+                            }
+                            
+                            // task found and deleted
+                            return true;
+                        }
+                    }
+
+                    // task not found
+                    return false;
+
+                case syscalls::yield:
+                    // yield the cpu to the next task
+                    schedule();
+                    break;
+
+                case syscalls::sleep:
+                    // set the time to sleep for the current task
+                    current_task->time_to_sleep.value = arg0;
+
+                    // switch to the next task
+                    schedule();
+                    break;
             }
+
+            return true;
         }
     };
 }

klib/rtos/scheduler.hpp renamed to rtos/scheduler.hpp

@@ -0,0 +1,53 @@
+#include <rtos/rtos.hpp>
+
+#include "syscall.hpp"
+#include "scheduler.hpp"
+
+namespace klib::rtos::syscall {
+    /**
+     * @brief Invoke a syscall with the given arguments
+     * 
+     * @tparam Return 
+     * @tparam Args 
+     * @param number 
+     * @param args 
+     * @return Return 
+     */
+    template <typename Return, typename... Args>
+    static Return syscall_invoke(scheduler::syscalls number, Args... args) {
+        // Call the target specific syscall invoke function
+        return klib::target::rtos::detail::syscall_invoke<Return, Args...>(
+            static_cast<uint32_t>(number), args...
+        );
+    }
+
+    bool create_task(detail::base_task* task) {
+        // invoke the create_task syscall
+        return syscall_invoke<bool, detail::base_task*>(scheduler::syscalls::create_task, task);
+    }
+
+    bool delete_task(detail::base_task* task) {
+        // invoke the delete_task syscall
+        return syscall_invoke<bool, detail::base_task*>(scheduler::syscalls::delete_task, task);
+    }
+
+    void yield() {
+        // invoke the yield syscall
+        syscall_invoke<void>(scheduler::syscalls::yield);
+    }
+
+    void sleep(klib::time::ms time) {
+        // invoke the sleep syscall
+        syscall_invoke<void, klib::time::ms>(scheduler::syscalls::sleep, time.value);
+    }
+
+    void* malloc(uint32_t size) {
+        // invoke the malloc syscall
+        return syscall_invoke<void*, uint32_t>(scheduler::syscalls::malloc, size);
+    }
+
+    void free(const void *const ptr) {
+        // invoke the free syscall
+        syscall_invoke<void, const void*>(scheduler::syscalls::free, ptr);
+    }
+}