sched.h

#pragma once
 
#include <kernel/process.h>
 
#include <utils/compiler.h>
 
// TODO: Remove this once we implemented another timer for the scheduler
extern bool scheduler_initialized;
 
void schedule(void);
 
void schedule_preempt(void);
 
bool scheduler_preempt_disable(void);
 
void scheduler_preempt_enable(bool old_if_flag);
 
void sched_new_thread(thread_t *);
 
static ALWAYS_INLINE void
sched_new_thread_create(thread_entry_t entrypoint, void *data, u32 flags)
{
    struct thread *thread = thread_spawn(current->process, entrypoint, data,
                                         NULL, flags);
    if (!IS_ERR(thread))
        sched_new_thread(thread);
}
 
void sched_block_thread(struct thread *);
 
void sched_unblock_thread(thread_t *);
 
void sched_block_waiting_until(struct thread *, clock_t until);
 
void sched_unblock_waiting_before(clock_t deadline);
 
typedef struct {
    const bool old_if;
    bool done;
} sched_scope_t;
 
static inline sched_scope_t sched_scope_constructor(void)
{
    return (sched_scope_t){
        .old_if = scheduler_preempt_disable(),
        .done = false,
    };
}
 
static inline void sched_scope_destructor(sched_scope_t *scope)
{
    scheduler_preempt_enable(scope->old_if);
}
 
#define no_preemption_scope()                                  \
    for (sched_scope_t scope CLEANUP(sched_scope_destructor) = \
             sched_scope_constructor();                        \
         !scope.done; scope.done = true)