sched.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2014-2017 Freie Universität Berlin
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once

 
#include <stddef.h>
#include <inttypes.h>
 
#include "kernel_defines.h"
#include "native_sched.h"
#include "clist.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#ifndef MAXTHREADS
#if defined(MODULE_CORE_THREAD)
#define MAXTHREADS 32
#else
#define MAXTHREADS 0
#endif
#endif

#define KERNEL_PID_UNDEF 0

#define KERNEL_PID_FIRST (KERNEL_PID_UNDEF + 1)

#define KERNEL_PID_LAST (KERNEL_PID_FIRST + MAXTHREADS - 1)

#define PRIkernel_pid PRIi16
 
#if defined(DEVELHELP) || defined(DOXYGEN)
#ifndef SCHED_TEST_STACK
#define SCHED_TEST_STACK    1
#endif  /* SCHED_TEST_STACK */
#endif  /* DEVELHELP */

typedef int16_t kernel_pid_t;

static inline int pid_is_valid(kernel_pid_t pid)
{
    return ((KERNEL_PID_FIRST <= pid) && (pid <= KERNEL_PID_LAST));
}

typedef struct _thread thread_t;

typedef enum {
    STATUS_STOPPED,                 
    STATUS_ZOMBIE,                  
    STATUS_SLEEPING,                
    STATUS_MUTEX_BLOCKED,           
    STATUS_RECEIVE_BLOCKED,         
    STATUS_SEND_BLOCKED,            
    STATUS_REPLY_BLOCKED,           
    STATUS_FLAG_BLOCKED_ANY,        
    STATUS_FLAG_BLOCKED_ALL,        
    STATUS_MBOX_BLOCKED,            
    STATUS_COND_BLOCKED,            
    STATUS_RUNNING,                 
    STATUS_PENDING,                 
    STATUS_NUMOF                    
} thread_status_t;


#define STATUS_ON_RUNQUEUE      STATUS_RUNNING  
#define STATUS_NOT_FOUND ((thread_status_t)~0)  
#ifndef SCHED_PRIO_LEVELS
#define SCHED_PRIO_LEVELS 16
#endif

thread_t *sched_run(void);

void sched_set_status(thread_t *process, thread_status_t status);

void sched_switch(uint16_t other_prio);

NORETURN void cpu_switch_context_exit(void);

extern volatile unsigned int sched_context_switch_request;

extern volatile thread_t *sched_threads[KERNEL_PID_LAST + 1];

extern volatile int sched_num_threads;

extern clist_node_t sched_runqueues[SCHED_PRIO_LEVELS];

NORETURN void sched_task_exit(void);

void sched_change_priority(thread_t *thread, uint8_t priority);

void sched_arch_idle(void);
 
#if IS_USED(MODULE_SCHED_CB) || defined(DOXYGEN)
typedef void (*sched_callback_t)(kernel_pid_t active, kernel_pid_t next);

void sched_register_cb(sched_callback_t callback);
#endif /* MODULE_SCHED_CB */

static inline void sched_runq_advance(uint8_t prio)
{
    clist_lpoprpush(&sched_runqueues[prio]);
}
 
#if (IS_USED(MODULE_SCHED_RUNQ_CALLBACK)) || defined(DOXYGEN)
extern void sched_runq_callback(uint8_t prio);
#endif

static inline int sched_runq_is_empty(uint8_t prio)
{
    return clist_is_empty(&sched_runqueues[prio]);
}

static inline int sched_runq_exactly_one(uint8_t prio)
{
    return clist_exactly_one(&sched_runqueues[prio]);
}

static inline int sched_runq_more_than_one(uint8_t prio)
{
    return clist_more_than_one(&sched_runqueues[prio]);
}
 
#ifdef __cplusplus
}
#endif