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  * \version $Id: proc.c 1616 2008-08-10 19:41:26Z bernie $
  35  * \author Bernie Innocenti <bernie@codewiz.org>
  36  */
  37
  38 #include "proc_p.h"
  39 #include "proc.h"
  40
  41 #include <kern/irq.h>
  42 #include <kern/monitor.h>
  43 #include <cpu/frame.h> // CPU_IDLE
  44 #include <drv/timer.h>
  45 #include <cfg/module.h>
  46
  47
  48
  49 Timer preempt_timer;
  50
  51 /**
  52  * Disable preemptive task switching.
  53  *
  54  * The scheduler maintains a per-process nesting counter.  Task switching is
  55  * effectively re-enabled only when the number of calls to proc_permit()
  56  * matches the number of calls to proc_forbid().
  57  *
  58  * Calling functions that could sleep while task switching is disabled
  59  * is dangerous, although supported.  Preemptive task switching is
  60  * resumed while the process is sleeping and disabled again as soon as
  61  * it wakes up again.
  62  *
  63  * \sa proc_permit()
  64  */
  65 void proc_forbid(void)
  66 {
  67         /* No need to protect against interrupts here. */
  68         ++CurrentProcess->forbid_cnt;
  69 }
  70
  71 /**
  72  * Re-enable preemptive task switching.
  73  *
  74  * \sa proc_forbid()
  75  */
  76 void proc_permit(void)
  77 {
  78         /* No need to protect against interrupts here. */
  79         --CurrentProcess->forbid_cnt;
  80 }
  81
  82
  83 void proc_preempt(void)
  84 {
  85         IRQ_DISABLE;
  86
  87         LIST_ASSERT_VALID(&ProcReadyList);
  88         CurrentProcess = (struct Process *)list_remHead(&ProcReadyList);
  89         LIST_ASSERT_VALID(&ProcReadyList);
  90         ASSERT2(CurrentProcess, "no idle proc?");
  91
  92         IRQ_ENABLE;
  93
  94         TRACEMSG("new proc: %p:%s", CurrentProcess, CurrentProcess ? CurrentProcess->monitor.name : "---");
  95         monitor_report();
  96 }
  97
  98 void proc_preempt_timer(UNUSED_ARG(void *, param))
  99 {
 100         IRQ_DISABLE;
 101 /*
 102         if (!CurrentProcess->forbid_cnt)
 103         {
 104                 TRACEMSG("preempting %p:%s", CurrentProcess, CurrentProcess->monitor.name);
 105                 LIST_ASSERT_VALID(&ProcReadyList);
 106                 SCHED_ENQUEUE(CurrentProcess);
 107                 proc_preempt();
 108         }
 109 */
 110         IRQ_ENABLE;
 111
 112         timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM);
 113         timer_add(&preempt_timer);
 114 }
 115
 116 void proc_schedule(void)
 117 {
 118         TRACE;
 119
 120         // Will invoke proc_preempt() in interrupt context
 121         kill(0, SIGUSR1);
 122 }
 123
 124 void proc_yield(void)
 125 {
 126         TRACE;
 127
 128         ASSERT_IRQ_ENABLED();
 129         IRQ_DISABLE;
 130         SCHED_ENQUEUE(CurrentProcess);
 131         LIST_ASSERT_VALID(&ProcReadyList);
 132         proc_schedule();
 133         IRQ_ENABLE;
 134 }
 135
 136 void proc_entry(void (*user_entry)(void))
 137 {
 138         user_entry();
 139         proc_exit();
 140 }
 141
 142
 143 static cpustack_t idle_stack[CONFIG_PROC_DEFSTACKSIZE / sizeof(cpustack_t)];
 144
 145 /*
 146  * The idle process
 147  *
 148  * This process never dies and never sleeps.  It's also quite apathic
 149  * and a bit antisocial.
 150  *
 151  * Having an idle process costs some stack space, but simplifies the
 152  * interrupt-driven preemption logic because there is always a user
 153  * context to which we can return.
 154  */
 155 static NORETURN void idle(void)
 156 {
 157         for (;;)
 158         {
 159                 TRACE;
 160                 monitor_report();
 161                 proc_yield(); // FIXME: CPU_IDLE
 162         }
 163 }
 164
 165 void preempt_init(void)
 166 {
 167         MOD_CHECK(irq);
 168         MOD_CHECK(timer);
 169
 170         irq_register(SIGUSR1, proc_preempt);
 171
 172         timer_setSoftint(&preempt_timer, proc_preempt_timer, NULL);
 173         timer_setDelay(&preempt_timer, CONFIG_KERN_QUANTUM);
 174         timer_add(&preempt_timer);
 175
 176         proc_new(idle, NULL, sizeof(idle_stack), idle_stack);
 177 }