bertos/kern/preempt.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2008 Bernie Innocenti <bernie@codewiz.org>
  30  * -->
  31  *
  32  * \brief Simple preemptive multitasking scheduler.
  33  *
  34  * All voluntary and preemptive context switching happens on exit from
  35  * a common interrupt (signal) dispatcher.  Preemption on quantum timeout
  36  * is regulated by a soft-timer.  Other kinds of preemption could happen
  37  * if an interrupt sends a signal to a higher priority process (but this
  38  * is still unimplemented).
  39  *
  40  * In the POSIX implementaiton, context switching is done by the portable
  41  * SVR4 swapcontext() facility.
  42  *
  43  * \version $Id$
  44  * \author Bernie Innocenti <bernie@codewiz.org>
  45  */
  46
  47 #include "cfg/cfg_proc.h"
  48
  49 #if CONFIG_KERN_PREEMPT
  50
  51 #include "proc_p.h"
  52 #include "proc.h"
  53 #include "idle.h"
  54
  55 #include <kern/irq.h>
  56 #include <kern/monitor.h>
  57 #include <cpu/frame.h> // CPU_IDLE
  58 #include <cpu/irq.h>   // IRQ_DISABLE()...
  59 #include <drv/timer.h>
  60 #include <cfg/module.h>
  61 #include <cfg/depend.h>    // CONFIG_DEPEND()
  62
  63 // Check config dependencies
  64 CONFIG_DEPEND(CONFIG_KERN_PREEMPT, CONFIG_KERN && CONFIG_TIMER_EVENTS && CONFIG_KERN_IRQ);
  65
  66 MOD_DEFINE(preempt)
  67
  68 /// Global preemption disabling nesting counter
  69 cpu_atomic_t _preempt_forbid_cnt;
  70
  71 static Timer preempt_timer;
  72
  73
  74 void proc_schedule(void)
  75 {
  76         IRQ_DISABLE;
  77
  78         ASSERT(proc_allowed());
  79         LIST_ASSERT_VALID(&ProcReadyList);
  80         CurrentProcess = (struct Process *)list_remHead(&ProcReadyList);
  81         ASSERT2(CurrentProcess, "no idle proc?");
  82
  83         IRQ_ENABLE;
  84
  85         TRACEMSG("launching %p:%s", CurrentProcess, proc_currentName());
  86 }
  87
  88 void proc_preempt(UNUSED_ARG(void *, param))
  89 {
  90         if (proc_allowed())
  91         {
  92                 IRQ_DISABLE;
  93
  94                 #if CONFIG_KERN_PRI
  95                         Process *rival = (Process *)LIST_HEAD(&ProcReadyList);
  96                         if (rival && rival->link.pri >= CurrentProcess->link.pri)
  97                         {
  98                 #endif
  99
 100                 TRACEMSG("preempting %p:%s", CurrentProcess, proc_currentName());
 101
 102 // FIXME: this still breaks havoc, probably because of some reentrancy issue
 103 #if 0
 104                 SCHED_ENQUEUE(CurrentProcess);
 105                 proc_schedule();
 106 #endif
 107                 #if CONFIG_KERN_PRI
 108                         }
 109                 #endif
 110
 111                 IRQ_ENABLE;
 112         }
 113
 114         timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM);
 115         timer_add(&preempt_timer);
 116 }
 117
 118 void proc_switch(void)
 119 {
 120         ATOMIC(LIST_ASSERT_VALID(&ProcReadyList));
 121         TRACEMSG("%p:%s", CurrentProcess, proc_currentName());
 122         ATOMIC(LIST_ASSERT_VALID(&ProcReadyList));
 123
 124         /* Sleeping with IRQs disabled or preemption forbidden is illegal */
 125         IRQ_ASSERT_ENABLED();
 126         ASSERT(proc_allowed());
 127
 128         // Will invoke proc_switch() in interrupt context
 129         kill(0, SIGUSR1);
 130 }
 131
 132 void proc_yield(void)
 133 {
 134         TRACEMSG("%p:%s", CurrentProcess, proc_currentName());
 135
 136         IRQ_DISABLE;
 137         SCHED_ENQUEUE(CurrentProcess);
 138         IRQ_ENABLE;
 139
 140         proc_switch();
 141 }
 142
 143 void proc_entry(void (*user_entry)(void))
 144 {
 145         user_entry();
 146         proc_exit();
 147 }
 148
 149 void preempt_init(void)
 150 {
 151         MOD_CHECK(irq);
 152         MOD_CHECK(timer);
 153
 154         irq_register(SIGUSR1, proc_schedule);
 155
 156         timer_setSoftint(&preempt_timer, proc_preempt, NULL);
 157         timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM);
 158         timer_add(&preempt_timer);
 159
 160         idle_init();
 161
 162         MOD_INIT(preempt);
 163 }
 164
 165 #endif // CONFIG_KERN_PREEMPT