rom/exec/exec_util.c

   1 /*
   2     Copyright © 1995-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Exec utility functions.
   6     Lang: english
   7 */
   8
   9 #include <aros/debug.h>
  10 #include <exec/lists.h>
  11 #include <exec/tasks.h>
  12 #include <exec/memory.h>
  13 #include <exec/execbase.h>
  14 #include <dos/dosextens.h>
  15
  16 #include <proto/exec.h>
  17
  18 #include "etask.h"
  19 #include "exec_intern.h"
  20 #include "exec_util.h"
  21 #include "taskstorage.h"
  22
  23 /*i***************************************************************************
  24
  25     NAME */
  26 #include "exec_util.h"
  27
  28         struct ETask * Exec_FindChild(
  29
  30 /*  SYNOPSIS */
  31         ULONG       id,
  32         struct ExecBase *SysBase)
  33
  34 /*  FUNCTION
  35         Scan through the current tasks children list searching for the task
  36         whose et_UniqueID field matches.
  37
  38     INPUTS
  39         id      -   The task ID to match.
  40
  41     RESULT
  42         Address of the ETask structure that matches, or
  43         NULL otherwise.
  44
  45     NOTES
  46         This is an internal exec.library function not exported from the
  47         library.
  48
  49     EXAMPLE
  50
  51     BUGS
  52
  53     SEE ALSO
  54
  55     INTERNALS
  56
  57 ******************************************************************************/
  58 {
  59     struct Task *ThisTask = GET_THIS_TASK;
  60     struct ETask *et;
  61     struct ETask *thisET;
  62
  63     thisET = GetETask(ThisTask);
  64     if (thisET != NULL)
  65     {
  66         ForeachNode (&thisET->et_Children, et)
  67         {
  68             if (et->et_UniqueID == id)
  69                 return et;
  70         }
  71         ForeachNode(&thisET->et_TaskMsgPort.mp_MsgList, et)
  72         {
  73             if (et->et_UniqueID == id)
  74                 return et;
  75         }
  76     }
  77     return NULL;
  78 }
  79
  80 BOOL
  81 Exec_InitETask(struct Task *task, struct ExecBase *SysBase)
  82 {
  83     /*
  84      *  We don't add this to the task memory, it isn't free'd by
  85      *  RemTask(), rather by somebody else calling ChildFree().
  86      *  Alternatively, an orphaned task will free its own ETask.
  87      */
  88     struct ETask *et =
  89         AllocMem(sizeof(struct IntETask), MEMF_PUBLIC | MEMF_CLEAR);
  90
  91     D(bug("[EXEC:ETask] Init: Allocated ETask @ 0x%p, %d bytes for Task @ %p\n",
  92         et, sizeof(struct IntETask), task);)
  93
  94     task->tc_UnionETask.tc_ETask = et;
  95     if (!et)
  96         return FALSE;
  97     task->tc_Flags |= TF_ETASK;
  98
  99 #if defined(__AROSEXEC_SMP__)
 100     EXEC_SPINLOCK_INIT(&IntETask(et)->iet_TaskLock);
 101     IntETask(et)->iet_CpuAffinity = (1 << 0);
 102 #endif
 103
 104     et->et_Parent = GET_THIS_TASK;
 105     NEWLIST(&et->et_Children);
 106
 107     /* Initialise the message list */
 108     InitMsgPort(&et->et_TaskMsgPort);
 109     et->et_TaskMsgPort.mp_SigTask = task;
 110     et->et_TaskMsgPort.mp_SigBit = SIGB_CHILD;
 111
 112     /* Initialise the trap fields */
 113     et->et_TrapAlloc = SysBase->TaskTrapAlloc;
 114     et->et_TrapAble = 0;
 115
 116 #ifdef DEBUG_ETASK
 117     {
 118         int len = strlen(task->tc_Node.ln_Name) + 1;
 119         IntETask(et)->iet_Me = AllocVec(len, MEMF_CLEAR|MEMF_PUBLIC);
 120         if (IntETask(et)->iet_Me != NULL)
 121             CopyMem(task->tc_Node.ln_Name, IntETask(et)->iet_Me, len);
 122     }
 123 #endif
 124
 125     /* Get a unique identifier for this task */
 126     Forbid();
 127     while(et->et_UniqueID == 0)
 128     {
 129         /*
 130          *      Add some fuzz on wrapping. It's likely that the early numbers
 131          *      where taken by somebody else.
 132          */
 133         if(++SysBase->ex_TaskID == 0)
 134             SysBase->ex_TaskID = 1024;
 135
 136         Disable();
 137         if (FindTaskByPID(SysBase->ex_TaskID) == NULL)
 138             et->et_UniqueID = SysBase->ex_TaskID;
 139         Enable();
 140     }
 141     Permit();
 142
 143     /* Finally if the parent task is an ETask, add myself as its child */
 144     if(et->et_Parent && ((struct Task*) et->et_Parent)->tc_Flags & TF_ETASK)
 145     {
 146         Forbid();
 147         ADDHEAD(&GetETask(et->et_Parent)->et_Children, et);
 148         Permit();
 149     }
 150
 151     return TRUE;
 152 }
 153
 154 void
 155 Exec_CleanupETask(struct Task *task, struct ExecBase *SysBase)
 156 {
 157     struct ETask *et = NULL, *child, *nextchild, *parent;
 158     struct Node *tmpNode;
 159     BOOL expunge = TRUE;
 160
 161     if(task->tc_Flags & TF_ETASK)
 162         et = task->tc_UnionETask.tc_ETask;
 163     if(!et)
 164         return;
 165
 166     D(bug("[EXEC:ETask] Cleanup: Task @ 0x%p, ETask @ 0x%p\n", task, et);)
 167
 168     Forbid();
 169
 170     /* Clean up after all the children that the task didn't do itself. */
 171     ForeachNodeSafe(&et->et_TaskMsgPort.mp_MsgList, child, tmpNode)
 172     {
 173         ExpungeETask(child);
 174     }
 175
 176     /* If we have an ETask parent, tell it we have exited. */
 177     if(et->et_Parent != NULL)
 178     {
 179         parent = GetETask(et->et_Parent);
 180
 181         /* Link children to our parent. */
 182         ForeachNodeSafe(&et->et_Children, child, nextchild)
 183         {
 184             child->et_Parent = et->et_Parent;
 185             //Forbid();
 186             if (parent)
 187                 ADDTAIL(&parent->et_Children, child);
 188             //Permit();
 189         }
 190
 191         /* Notify parent only if child was created with NP_NotifyOnDeath set
 192            to TRUE */
 193         if(parent != NULL)
 194         {
 195             REMOVE(et);
 196
 197             if(
 198                (((struct Task *)task)->tc_Node.ln_Type == NT_PROCESS) &&
 199                (((struct Process*) task)->pr_Flags & PRF_NOTIFYONDEATH)
 200             )
 201             {
 202                 PutMsg(&parent->et_TaskMsgPort, (struct Message *)et);
 203                 expunge = FALSE;
 204             }
 205         }
 206     }
 207     else
 208     {
 209         /* Orphan all our remaining children. */
 210         ForeachNode(&et->et_Children, child)
 211             child->et_Parent = NULL;
 212     }
 213
 214     if(expunge)
 215         ExpungeETask(et);
 216
 217     Permit();
 218 }
 219
 220 void
 221 Exec_ExpungeETask(struct ETask *et, struct ExecBase *SysBase)
 222 {
 223     IPTR *ts = et->et_TaskStorage;
 224
 225     FreeVec(et->et_Result2);
 226
 227 #ifdef DEBUG_ETASK
 228     FreeVec(IntETask(et)->iet_Me);
 229 #endif
 230     D(bug("[EXEC:ETask] Expunge: Freeing ETask @ 0x%p, TS @ 0x%p, size=%d\n",
 231           et, ts, ts ? (ULONG)ts[__TS_FIRSTSLOT] : 0
 232     );)
 233     FreeMem(et, sizeof(struct IntETask));
 234     if (ts)
 235         FreeMem(ts, ts[__TS_FIRSTSLOT] * sizeof(ts[0]));
 236 }
 237
 238 BOOL Exec_CheckTask(struct Task *task, struct ExecBase *SysBase)
 239 {
 240     struct Task *t;
 241
 242     if (!task)
 243         return FALSE;
 244
 245 #if defined(__AROSEXEC_SMP__)
 246     EXEC_SPINLOCK_LOCK(&PrivExecBase(SysBase)->TaskRunningSpinLock, SPINLOCK_MODE_READ);
 247 #endif
 248     Forbid();
 249
 250 #if defined(__AROSEXEC_SMP__)
 251     ForeachNode(&PrivExecBase(SysBase)->TaskRunning, t)
 252     {
 253         if (task == t)
 254         {
 255             EXEC_SPINLOCK_UNLOCK(&PrivExecBase(SysBase)->TaskRunningSpinLock);
 256             Permit();
 257             return TRUE;
 258         }
 259     }
 260     EXEC_SPINLOCK_UNLOCK(&PrivExecBase(SysBase)->TaskRunningSpinLock);
 261     Permit();
 262     EXEC_SPINLOCK_LOCK(&PrivExecBase(SysBase)->TaskSpinningLock, SPINLOCK_MODE_READ);
 263     Forbid();
 264     ForeachNode(&PrivExecBase(SysBase)->TaskSpinning, t)
 265     {
 266         if (task == t)
 267         {
 268             EXEC_SPINLOCK_UNLOCK(&PrivExecBase(SysBase)->TaskSpinningLock);
 269             Permit();
 270             return TRUE;
 271         }
 272     }
 273     EXEC_SPINLOCK_UNLOCK(&PrivExecBase(SysBase)->TaskSpinningLock);
 274     Permit();
 275     EXEC_SPINLOCK_LOCK(&PrivExecBase(SysBase)->TaskReadySpinLock, SPINLOCK_MODE_READ);
 276     Forbid();
 277 #else
 278     if (task == GET_THIS_TASK)
 279     {
 280         Permit();
 281         return TRUE;
 282     }
 283 #endif
 284
 285     ForeachNode(&SysBase->TaskReady, t)
 286     {
 287         if (task == t)
 288         {
 289 #if defined(__AROSEXEC_SMP__)
 290             EXEC_SPINLOCK_UNLOCK(&PrivExecBase(SysBase)->TaskReadySpinLock);
 291 #endif
 292             Permit();
 293             return TRUE;
 294         }
 295     }
 296 #if defined(__AROSEXEC_SMP__)
 297     EXEC_SPINLOCK_UNLOCK(&PrivExecBase(SysBase)->TaskReadySpinLock);
 298     Permit();
 299     EXEC_SPINLOCK_LOCK(&PrivExecBase(SysBase)->TaskWaitSpinLock, SPINLOCK_MODE_READ);
 300     Forbid();
 301 #endif
 302     ForeachNode(&SysBase->TaskWait, t)
 303     {
 304         if (task == t)
 305         {
 306 #if defined(__AROSEXEC_SMP__)
 307             EXEC_SPINLOCK_UNLOCK(&PrivExecBase(SysBase)->TaskWaitSpinLock);
 308 #endif
 309             Permit();
 310             return TRUE;
 311         }
 312     }
 313 #if defined(__AROSEXEC_SMP__)
 314     EXEC_SPINLOCK_UNLOCK(&PrivExecBase(SysBase)->TaskWaitSpinLock);
 315 #endif
 316     Permit();
 317
 318     return FALSE;
 319 }