rom/exec/exec_util.c

   1 /*
   2     Copyright © 1995-2011, 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 ETask *et;
  60     struct ETask *thisET;
  61
  62     thisET = GetETask(FindTask(NULL));
  63     if (thisET != NULL)
  64     {
  65         ForeachNode (&thisET->et_Children, et)
  66         {
  67             if (et->et_UniqueID == id)
  68                 return et;
  69         }
  70         ForeachNode(&thisET->et_TaskMsgPort.mp_MsgList, et)
  71         {
  72             if (et->et_UniqueID == id)
  73                 return et;
  74         }
  75     }
  76     return NULL;
  77 }
  78
  79 BOOL
  80 Exec_InitETask(struct Task *task, struct ExecBase *SysBase)
  81 {
  82     struct Task *thistask = FindTask(NULL);
  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     D(bug("[TSS] Create new ETask=%p for task=%p with size %d\n",
  91         et, task, sizeof(struct IntETask)));
  92
  93     task->tc_UnionETask.tc_ETask = et;
  94     if (!et)
  95         return FALSE;
  96     task->tc_Flags |= TF_ETASK;
  97
  98     if (thistask != NULL)
  99     {
 100         /* Clone parent's TaskStorage */
 101         struct ETask *thiset = GetETask(thistask);
 102         if (thiset) {
 103             IPTR *thists = thiset->et_TaskStorage;
 104
 105             if (thists) {
 106                 IPTR *ts = AllocMem(thists[__TS_FIRSTSLOT] * sizeof(thists[0]), MEMF_ANY);
 107                 if (!ts) {
 108                     FreeMem(et, sizeof(struct IntETask));
 109                     return FALSE;
 110                 }
 111                 CopyMem(thists, ts, thists[__TS_FIRSTSLOT] * sizeof(thists[0]));
 112                 et->et_TaskStorage = ts;
 113             }
 114         }
 115     }
 116
 117     et->et_Parent = thistask;
 118     NEWLIST(&et->et_Children);
 119
 120     /* Initialise the message list */
 121     InitMsgPort(&et->et_TaskMsgPort);
 122     et->et_TaskMsgPort.mp_SigTask = task;
 123     et->et_TaskMsgPort.mp_SigBit = SIGB_CHILD;
 124
 125     /* Initialise the trap fields */
 126     et->et_TrapAlloc = SysBase->TaskTrapAlloc;
 127     et->et_TrapAble = 0;
 128
 129 #ifdef DEBUG_ETASK
 130     {
 131         int len = strlen(task->tc_Node.ln_Name) + 1;
 132         IntETask(et)->iet_Me = AllocVec(len, MEMF_CLEAR|MEMF_PUBLIC);
 133         if (IntETask(et)->iet_Me != NULL)
 134             CopyMem(task->tc_Node.ln_Name, IntETask(et)->iet_Me, len);
 135     }
 136 #endif
 137
 138     /* Get a unique identifier for this task */
 139     Forbid();
 140     while(et->et_UniqueID == 0)
 141     {
 142         /*
 143          *      Add some fuzz on wrapping. It's likely that the early numbers
 144          *      where taken by somebody else.
 145          */
 146         if(++SysBase->ex_TaskID == 0)
 147             SysBase->ex_TaskID = 1024;
 148
 149         Disable();
 150         if (FindTaskByPID(SysBase->ex_TaskID) == NULL)
 151             et->et_UniqueID = SysBase->ex_TaskID;
 152         Enable();
 153     }
 154     Permit();
 155
 156     /* Finally if the parent task is an ETask, add myself as its child */
 157     if(et->et_Parent && ((struct Task*) et->et_Parent)->tc_Flags & TF_ETASK)
 158     {
 159         Forbid();
 160         ADDHEAD(&GetETask(et->et_Parent)->et_Children, et);
 161         Permit();
 162     }
 163
 164     return TRUE;
 165 }
 166
 167 void
 168 Exec_CleanupETask(struct Task *task, struct ExecBase *SysBase)
 169 {
 170     struct ETask *et = NULL, *child, *nextchild, *parent;
 171     struct Node *tmpNode;
 172     BOOL expunge = TRUE;
 173
 174     if(task->tc_Flags & TF_ETASK)
 175         et = task->tc_UnionETask.tc_ETask;
 176     if(!et)
 177         return;
 178
 179     D(bug("CleanupETask: task=%x, et=%x\n", task, et));
 180
 181     Forbid();
 182
 183     /* Clean up after all the children that the task didn't do itself. */
 184     ForeachNodeSafe(&et->et_TaskMsgPort.mp_MsgList, child, tmpNode)
 185     {
 186         ExpungeETask(child);
 187     }
 188
 189     /* If we have an ETask parent, tell it we have exited. */
 190     if(et->et_Parent != NULL)
 191     {
 192         parent = GetETask(et->et_Parent);
 193
 194         /* Link children to our parent. */
 195         ForeachNodeSafe(&et->et_Children, child, nextchild)
 196         {
 197             child->et_Parent = et->et_Parent;
 198             //Forbid();
 199             if (parent)
 200                 ADDTAIL(&parent->et_Children, child);
 201             //Permit();
 202         }
 203
 204         /* Notify parent only if child was created with NP_NotifyOnDeath set
 205            to TRUE */
 206         if(parent != NULL)
 207         {
 208             REMOVE(et);
 209
 210             if(
 211                (((struct Task *)task)->tc_Node.ln_Type == NT_PROCESS) &&
 212                (((struct Process*) task)->pr_Flags & PRF_NOTIFYONDEATH)
 213             )
 214             {
 215                 PutMsg(&parent->et_TaskMsgPort, (struct Message *)et);
 216                 expunge = FALSE;
 217             }
 218         }
 219     }
 220     else
 221     {
 222         /* Orphan all our remaining children. */
 223         ForeachNode(&et->et_Children, child)
 224             child->et_Parent = NULL;
 225     }
 226
 227     if(expunge)
 228         ExpungeETask(et);
 229
 230     Permit();
 231 }
 232
 233 void
 234 Exec_ExpungeETask(struct ETask *et, struct ExecBase *SysBase)
 235 {
 236     IPTR *ts = et->et_TaskStorage;
 237
 238     if(et->et_Result2)
 239         FreeVec(et->et_Result2);
 240
 241 #ifdef DEBUG_ETASK
 242     FreeVec(IntETask(et)->iet_Me);
 243 #endif
 244     D(bug("Exec_ExpungeETask: Freeing et=%x, ts=%x, size=%d\n",
 245           et, ts, ts ? (ULONG)ts[__TS_FIRSTSLOT] : 0
 246     ));
 247     FreeMem(et, sizeof(struct IntETask));
 248     if (ts)
 249         FreeMem(ts, ts[__TS_FIRSTSLOT] * sizeof(ts[0]));
 250 }
 251
 252 BOOL Exec_CheckTask(struct Task *task, struct ExecBase *SysBase)
 253 {
 254     struct Task *t;
 255
 256     if (!task)
 257         return FALSE;
 258
 259     Forbid();
 260
 261     if (task == SysBase->ThisTask)
 262     {
 263         Permit();
 264         return TRUE;
 265     }
 266
 267     ForeachNode(&SysBase->TaskReady, t)
 268     {
 269         if (task == t)
 270         {
 271             Permit();
 272             return TRUE;
 273         }
 274     }
 275
 276     ForeachNode(&SysBase->TaskWait, t)
 277     {
 278         if (task == t)
 279         {
 280             Permit();
 281             return TRUE;
 282         }
 283     }
 284
 285     Permit();
 286     return FALSE;
 287 }