rom/kernel/kernel_scheduler.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6 */
   7
   8 #include <exec/alerts.h>
   9 #include <exec/execbase.h>
  10 #include <proto/exec.h>
  11
  12 #include <kernel_base.h>
  13 #include <kernel_debug.h>
  14 #include <kernel_scheduler.h>
  15
  16 #define D(x)
  17
  18 /*
  19  * Schedule the currently running task away. Put it into the TaskReady list
  20  * in some smart way. This function is subject of change and it will be probably replaced
  21  * by some plugin system in the future
  22  */
  23 BOOL core_Schedule(void)
  24 {
  25     struct Task *task = SysBase->ThisTask;
  26
  27     D(bug("[KRN] core_Schedule()\n"));
  28
  29     SysBase->AttnResched &= ~ARF_AttnSwitch;
  30
  31     /* If task has pending exception, reschedule it so that the dispatcher may handle the exception */
  32     if (!(task->tc_Flags & TF_EXCEPT))
  33     {
  34         BYTE pri;
  35
  36         /* Is the TaskReady empty? If yes, then the running task is the only one. Let it work */
  37         if (IsListEmpty(&SysBase->TaskReady))
  38             return FALSE;
  39
  40         /* Does the TaskReady list contains tasks with priority equal or lower than current task?
  41          * If so, then check further... */
  42         pri = ((struct Task*)GetHead(&SysBase->TaskReady))->tc_Node.ln_Pri;
  43         if (pri <= task->tc_Node.ln_Pri)
  44         {
  45             /* If the running task did not used it's whole quantum yet, let it work */
  46             if (!(SysBase->SysFlags & SFF_QuantumOver))
  47                 return FALSE;
  48         }
  49     }
  50
  51     /*
  52      * If we got here, then the rescheduling is necessary.
  53      * Put the task into the TaskReady list.
  54      */
  55     D(bug("[KRN] Setting task 0x%p (%s) to READY\n", task, task->tc_Node.ln_Name));
  56     task->tc_State = TS_READY;
  57     Enqueue(&SysBase->TaskReady, &task->tc_Node);
  58
  59     /* Select new task to run */
  60     return TRUE;
  61 }
  62
  63 /* Actually switch away from the task */
  64 void core_Switch(void)
  65 {
  66     struct Task *task = SysBase->ThisTask;
  67
  68     D(bug("[KRN] core_Switch(): Old task = %p (%s)\n", task, task->tc_Node.ln_Name));
  69
  70 #ifndef __mc68000
  71     if (task->tc_SPReg <= task->tc_SPLower || task->tc_SPReg > task->tc_SPUpper)
  72     {
  73         bug("[KRN] Task %s went out of stack limits\n", task->tc_Node.ln_Name);
  74         bug("[KRN] Lower %p, upper %p, SP %p\n", task->tc_SPLower, task->tc_SPUpper, task->tc_SPReg);
  75         /*
  76          * Suspend the task to stop it from causing more harm. In some rare cases, if the task is holding
  77          * lock on some global/library semaphore it will most likelly mean immenent freeze. In most cases
  78          * however, user will be shown an alert.
  79          */
  80         Remove(&task->tc_Node);
  81         task->tc_SigWait    = 0;
  82         task->tc_State      = TS_WAIT;
  83         Enqueue(&SysBase->TaskWait, &task->tc_Node);
  84
  85         Alert(AN_StackProbe);
  86     }
  87 #endif
  88
  89     task->tc_IDNestCnt = SysBase->IDNestCnt;
  90
  91     if (task->tc_Flags & TF_SWITCH)
  92         AROS_UFC1NR(void, task->tc_Switch, AROS_UFCA(struct ExecBase *, SysBase, A6));
  93 }
  94
  95 /*
  96  * Task dispatcher. Basically it may be the same one no matter
  97  * what scheduling algorithm is used (except SysBase->Elapsed reloading)
  98  */
  99 struct Task *core_Dispatch(void)
 100 {
 101     struct Task *task;
 102
 103     D(bug("[KRN] core_Dispatch()\n"));
 104
 105     task = (struct Task *)REMHEAD(&SysBase->TaskReady);
 106     if (!task)
 107     {
 108         /* Is the list of ready tasks empty? Well, go idle. */
 109         D(bug("[KRN] No ready tasks, entering sleep mode\n"));
 110
 111         /*
 112          * Idle counter is incremented every time when we enter here,
 113          * not only once. This is correct.
 114          */
 115         SysBase->IdleCount++;
 116         SysBase->AttnResched |= ARF_AttnSwitch;
 117
 118         return NULL;
 119     }
 120
 121     SysBase->DispCount++;
 122     SysBase->IDNestCnt = task->tc_IDNestCnt;
 123     SysBase->ThisTask  = task;
 124     SysBase->Elapsed   = SysBase->Quantum;
 125     SysBase->SysFlags &= ~SFF_QuantumOver;
 126     task->tc_State     = TS_RUN;
 127
 128     D(bug("[KRN] New task = %p (%s)\n", task, task->tc_Node.ln_Name));
 129
 130     /*
 131      * Check the stack of the task we are about to launch.
 132      * Unfortunately original m68k programs can change stack manually without updating SPLower or SPUpper.
 133      * For example WB3.1 C:SetPatch adds exec/OpenDevice() patch that swaps stacks manually.
 134      * Result is that _all_ programs that call OpenDevice() crash if stack is checked.
 135      */
 136 #ifndef __mc68000
 137     if (task->tc_SPReg <= task->tc_SPLower || task->tc_SPReg > task->tc_SPUpper)
 138     {
 139         /* Don't let the task run, switch it away (raising Alert) and dispatch another task */
 140         core_Switch();
 141         return core_Dispatch();
 142     }
 143 #endif
 144
 145     if (task->tc_Flags & TF_LAUNCH)
 146         AROS_UFC1NR(void, task->tc_Launch, AROS_UFCA(struct ExecBase *, SysBase, A6));
 147
 148     /* Leave interrupt and jump to the new task */
 149     return task;
 150 }