rom/task/task_init.c

   1 /*
   2     Copyright © 2015-2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7
   8 #include <aros/debug.h>
   9 #include <aros/symbolsets.h>
  10
  11 #include <proto/exec.h>
  12 #include <proto/execlock.h>
  13 #include <resources/execlock.h>
  14 #include <resources/task.h>
  15
  16 #include "etask.h"
  17
  18 #include "task_intern.h"
  19
  20 extern APTR AROS_SLIB_ENTRY(NewAddTask, Task, 176)();
  21 extern void AROS_SLIB_ENTRY(RemTask, Task, 48)();
  22
  23 static LONG taskres_Init(struct TaskResBase *TaskResBase)
  24 {
  25 #ifdef TASKRES_ENABLE
  26     struct TaskListEntry *taskEntry = NULL;
  27     struct Task *curTask = NULL;
  28
  29 #if defined(__AROSEXEC_SMP__)
  30     void *ExecLockBase = NULL;
  31 #endif
  32 #endif /* TASKRES_ENABLE */
  33
  34     KernelBase = OpenResource("kernel.resource");
  35     if (!KernelBase)
  36         return FALSE;
  37
  38 #if defined(__AROSEXEC_SMP__)
  39     TaskResBase->trb_ExecLock = OpenResource("execlock.resource");
  40     ExecLockBase = TaskResBase->trb_ExecLock;
  41 #endif
  42
  43     TaskResBase->trb_UtilityBase = OpenLibrary("utility.library", 0);
  44     if (!TaskResBase->trb_UtilityBase)
  45         return FALSE;
  46
  47     NEWLIST(&TaskResBase->trb_TaskList);
  48     NEWLIST(&TaskResBase->trb_NewTasks);
  49     NEWLIST(&TaskResBase->trb_LockedLists);
  50
  51     SysBase->lb_TaskResBase = (struct Library *)TaskResBase;
  52
  53     InitSemaphore(&TaskResBase->trb_Sem);
  54
  55 #ifdef TASKRES_ENABLE
  56     TaskResBase->trb_RemTask = SetFunction((struct Library *)SysBase, -48*LIB_VECTSIZE, AROS_SLIB_ENTRY(RemTask, Task, 48));
  57     TaskResBase->trb_NewAddTask = SetFunction((struct Library *)SysBase, -176*LIB_VECTSIZE, AROS_SLIB_ENTRY(NewAddTask, Task, 176));
  58
  59     /*
  60        Add existing tasks to our internal list ..
  61     */
  62 #if defined(__AROSEXEC_SMP__)
  63     ObtainSystemLock(&PrivExecBase(SysBase)->TaskRunning, SPINLOCK_MODE_READ, LOCKF_DISABLE);
  64     ForeachNode(&PrivExecBase(SysBase)->TaskRunning, curTask)
  65     {
  66         if (curTask->tc_State & TS_RUN)
  67         {
  68             if ((taskEntry = AllocMem(sizeof(struct TaskListEntry), MEMF_CLEAR)) != NULL)
  69             {
  70                 D(bug("[TaskRes] 0x%p [R  ] %02d %s\n", curTask, GetIntETask(curTask)->iet_CpuNumber, curTask->tc_Node.ln_Name));
  71                 taskEntry->tle_Task = curTask;
  72                 AddTail(&TaskResBase->trb_TaskList, &taskEntry->tle_Node);
  73             }
  74             else
  75             {
  76                 bug("[TaskRes] Failed to allocate storage for task @  0x%p!!\n", curTask);
  77             }
  78         }
  79         else
  80         {
  81             bug("[TaskRes] Invalid Task State %08x for task @ 0x%p\n", curTask->tc_State, curTask);
  82         }
  83     }
  84     ReleaseSystemLock(&PrivExecBase(SysBase)->TaskRunning, LOCKF_DISABLE);
  85
  86     ObtainSystemLock(&PrivExecBase(SysBase)->TaskSpinning, SPINLOCK_MODE_READ, LOCKF_DISABLE);
  87     ForeachNode(&PrivExecBase(SysBase)->TaskSpinning, curTask)
  88     {
  89         if (curTask->tc_State & TS_SPIN)
  90         {
  91             if ((taskEntry = AllocMem(sizeof(struct TaskListEntry), MEMF_CLEAR)) != NULL)
  92             {
  93                 D(bug("[TaskRes] 0x%p [  S] %02d %s\n", curTask, GetIntETask(curTask)->iet_CpuNumber, curTask->tc_Node.ln_Name));
  94                 taskEntry->tle_Task = curTask;
  95                 AddTail(&TaskResBase->trb_TaskList, &taskEntry->tle_Node);
  96             }
  97             else
  98             {
  99                 bug("[TaskRes] Failed to allocate storage for task @  0x%p!!\n", curTask);
 100             }
 101         }
 102         else
 103         {
 104             bug("[TaskRes] Invalid Task State %08x for task @ 0x%p\n", curTask->tc_State, curTask);
 105         }
 106     }
 107     ReleaseSystemLock(&PrivExecBase(SysBase)->TaskSpinning, LOCKF_DISABLE);
 108
 109     ObtainSystemLock(&SysBase->TaskReady, SPINLOCK_MODE_READ, LOCKF_DISABLE);
 110     // TODO : list TaskSpinning tasks..
 111 #else
 112     Disable();
 113     if (SysBase->ThisTask)
 114     {
 115         if (SysBase->ThisTask->tc_State & TS_RUN)
 116         {
 117             if ((taskEntry = AllocMem(sizeof(struct TaskListEntry), MEMF_CLEAR)) != NULL)
 118             {
 119                 D(bug("[TaskRes] 0x%p [R--] 00 %s\n", SysBase->ThisTask, SysBase->ThisTask->tc_Node.ln_Name));
 120                 taskEntry->tle_Task = SysBase->ThisTask;
 121                 AddTail(&TaskResBase->trb_TaskList, &taskEntry->tle_Node);
 122             }
 123             else
 124             {
 125                 bug("[TaskRes] Failed to allocate storage for task @  0x%p!!\n", SysBase->ThisTask);
 126             }
 127         }
 128         else
 129         {
 130             bug("[TaskRes] Invalid Task State %08x for task @ 0x%p\n", SysBase->ThisTask->tc_State, curTask);
 131         }
 132     }
 133 #endif
 134     ForeachNode(&SysBase->TaskReady, curTask)
 135     {
 136         if (curTask->tc_State & (TS_READY|TS_RUN))
 137         {
 138             if ((taskEntry = AllocMem(sizeof(struct TaskListEntry), MEMF_CLEAR)) != NULL)
 139             {
 140                 D(bug("[TaskRes] 0x%p [-R-] -- %s\n", curTask, curTask->tc_Node.ln_Name));
 141                 taskEntry->tle_Task = curTask;
 142                 AddTail(&TaskResBase->trb_TaskList, &taskEntry->tle_Node);
 143             }
 144             else
 145             {
 146                 bug("[TaskRes] Failed to allocate storage for task @  0x%p!!\n", curTask);
 147             }
 148         }
 149         else
 150         {
 151             bug("[TaskRes] Invalid Task State %08x for task @ 0x%p\n", curTask->tc_State, curTask);
 152         }
 153     }
 154 #if defined(__AROSEXEC_SMP__)
 155     ReleaseSystemLock(&SysBase->TaskReady, LOCKF_DISABLE);
 156
 157     ObtainSystemLock(&SysBase->TaskWait, SPINLOCK_MODE_READ, LOCKF_DISABLE);
 158 #endif
 159     ForeachNode(&SysBase->TaskWait, curTask)
 160     {
 161         if (curTask->tc_State & TS_WAIT)
 162         {
 163             if ((taskEntry = AllocMem(sizeof(struct TaskListEntry), MEMF_CLEAR)) != NULL)
 164             {
 165                 D(bug("[TaskRes] 0x%p [--W] -- %s\n", curTask, curTask->tc_Node.ln_Name));
 166                 taskEntry->tle_Task = curTask;
 167                 AddTail(&TaskResBase->trb_TaskList, &taskEntry->tle_Node);
 168             }
 169             else
 170             {
 171                 bug("[TaskRes] Failed to allocate storage for task @  0x%p!!\n", curTask);
 172             }
 173         }
 174         else
 175         {
 176             bug("[TaskRes] Invalid Task State %08x for task @ 0x%p\n", curTask->tc_State, curTask);
 177         }
 178     }
 179 #if defined(__AROSEXEC_SMP__)
 180     ReleaseSystemLock(&SysBase->TaskWait, LOCKF_DISABLE);
 181 #else
 182     Enable();
 183 #endif
 184
 185 #endif /* TASKRES_ENABLE */
 186
 187     return TRUE;
 188 }
 189
 190 static LONG taskres_Exit(struct TaskResBase *TaskResBase)
 191 {
 192 #ifdef TASKRES_ENABLE
 193     SetFunction((struct Library *)SysBase, -176*LIB_VECTSIZE, TaskResBase->trb_NewAddTask);
 194     SetFunction((struct Library *)SysBase, -48*LIB_VECTSIZE, TaskResBase->trb_RemTask);
 195 #endif /* TASKRES_ENABLE */
 196
 197     CloseLibrary(TaskResBase->trb_UtilityBase);
 198
 199     return TRUE;
 200 }
 201
 202 ADD2INITLIB(taskres_Init, 0)
 203
 204 ADD2EXPUNGELIB(taskres_Exit, 0)