rom/exec/exec_util.c

   1 /*
   2     Copyright © 1995-2013, 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     FreeVec(et->et_Result2);
 239
 240 #ifdef DEBUG_ETASK
 241     FreeVec(IntETask(et)->iet_Me);
 242 #endif
 243     D(bug("Exec_ExpungeETask: Freeing et=%x, ts=%x, size=%d\n",
 244           et, ts, ts ? (ULONG)ts[__TS_FIRSTSLOT] : 0
 245     ));
 246     FreeMem(et, sizeof(struct IntETask));
 247     if (ts)
 248         FreeMem(ts, ts[__TS_FIRSTSLOT] * sizeof(ts[0]));
 249 }
 250
 251 BOOL Exec_CheckTask(struct Task *task, struct ExecBase *SysBase)
 252 {
 253     struct Task *t;
 254
 255     if (!task)
 256         return FALSE;
 257
 258     Forbid();
 259
 260     if (task == SysBase->ThisTask)
 261     {
 262         Permit();
 263         return TRUE;
 264     }
 265
 266     ForeachNode(&SysBase->TaskReady, t)
 267     {
 268         if (task == t)
 269         {
 270             Permit();
 271             return TRUE;
 272         }
 273     }
 274
 275     ForeachNode(&SysBase->TaskWait, t)
 276     {
 277         if (task == t)
 278         {
 279             Permit();
 280             return TRUE;
 281         }
 282     }
 283
 284     Permit();
 285     return FALSE;
 286 }