rom/exec/exec_util.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Exec utility functions.
   6     Lang: english
   7 */
   8 #include <exec/lists.h>
   9 #include <exec/tasks.h>
  10 #include <exec/memory.h>
  11 #include <exec/execbase.h>
  12 #include <dos/dosextens.h>
  13
  14 #include <proto/exec.h>
  15
  16 #include "etask.h"
  17 #include "exec_util.h"
  18
  19 /*****************************************************************************
  20
  21     NAME */
  22 #include "exec_util.h"
  23
  24         APTR Exec_AllocTaskMem (
  25
  26 /*  SYNOPSIS */
  27         struct Task * task,
  28         ULONG         size,
  29         ULONG         req,
  30         struct ExecBase *SysBase)
  31
  32 /*  FUNCTION
  33         Allocate memory which will be freed when the task is removed.
  34
  35     INPUTS
  36         task      - The memory will be freed when this task is removed.
  37         size      - How much memory.
  38         req       - What memory. See AllocMem() for details.
  39
  40     RESULT
  41         Adress to a memory block or NULL if no memory was available.
  42
  43     NOTES
  44
  45     EXAMPLE
  46
  47     BUGS
  48
  49     SEE ALSO
  50         AllocMem(), FreeTaskMem()
  51
  52     INTERNALS
  53         The memory is allocated and queued in the tc_MemList. This
  54         list is freed in RemTask().
  55
  56 ******************************************************************************/
  57 {
  58     struct MemList * ml;
  59     APTR mem;
  60
  61     ml = AllocMem (sizeof (struct MemList), MEMF_ANY);
  62     mem = AllocMem (size, req);
  63
  64     if (!ml || !mem)
  65     {
  66         if (ml)
  67             FreeMem (ml, sizeof (struct MemList));
  68
  69         if (mem)
  70             FreeMem (mem, size);
  71
  72         return NULL;
  73     }
  74
  75     ml->ml_NumEntries      = 1;
  76     ml->ml_ME[0].me_Addr   = mem;
  77     ml->ml_ME[0].me_Length = size;
  78
  79     Forbid ();
  80     AddHead (&task->tc_MemEntry, &ml->ml_Node);
  81     Permit ();
  82
  83     return mem;
  84 } /* AllocTaskMem */
  85
  86
  87 /*****************************************************************************
  88
  89     NAME */
  90 #include "exec_util.h"
  91
  92         void Exec_FreeTaskMem (
  93
  94 /*  SYNOPSIS */
  95         struct Task * task,
  96         APTR          mem,
  97         struct ExecBase *SysBase)
  98
  99 /*  FUNCTION
 100         Freeate memory which will be freed when the task is removed.
 101
 102     INPUTS
 103         task      - The memory will be freed when this task is removed.
 104         size      - How much memory.
 105         req       - What memory. See FreeMem() for details.
 106
 107     RESULT
 108         Adress to a memory block or NULL if no memory was available.
 109
 110     NOTES
 111
 112     EXAMPLE
 113
 114     BUGS
 115
 116     SEE ALSO
 117         FreeMem(), FreeTaskMem()
 118
 119     INTERNALS
 120         The memory is allocated and queued in the tc_MemList. This
 121         list is freed in RemTask().
 122
 123 ******************************************************************************/
 124 {
 125     struct MemList * ml, * next;
 126
 127     Forbid ();
 128
 129     ForeachNodeSafe (&task->tc_MemEntry, ml, next)
 130     {
 131         /*
 132             Quick check: If the node was allocated by AllocTaskMem(),
 133             then it has only one entry.
 134         */
 135         if (ml->ml_NumEntries == 1
 136             && ml->ml_ME[0].me_Addr == mem
 137         )
 138         {
 139             Remove (&ml->ml_Node);
 140             Permit ();
 141
 142             FreeMem (ml->ml_ME[0].me_Addr, ml->ml_ME[0].me_Length);
 143             FreeMem (ml, sizeof (struct MemList));
 144
 145             return;
 146         }
 147     }
 148
 149     Permit ();
 150
 151 } /* FreeTaskMem */
 152
 153 /*****************************************************************************
 154
 155     NAME */
 156 #include "exec_util.h"
 157
 158         struct Task * Exec_FindTaskByID(
 159
 160 /*  SYNOPSIS */
 161         ULONG       id,
 162         struct ExecBase *SysBase)
 163
 164 /*  FUNCTION
 165         Scan through the task lists searching for the task whose
 166         et_UniqueID field matches.
 167
 168     INPUTS
 169         id      -   The task ID to match.
 170
 171     RESULT
 172         Address of the Task control structure that matches, or
 173         NULL otherwise.
 174
 175     NOTES
 176
 177     EXAMPLE
 178
 179     BUGS
 180
 181     SEE ALSO
 182
 183     INTERNALS
 184
 185 ******************************************************************************/
 186 {
 187     struct Task *t;
 188     struct ETask *et;
 189
 190     /*
 191         First up, check ThisTask. It could be NULL because of exec_init.c
 192     */
 193     if (SysBase->ThisTask != NULL)
 194     {
 195         et = GetETask(SysBase->ThisTask);
 196         if (et != NULL && et->et_UniqueID == id)
 197             return SysBase->ThisTask;
 198     }
 199
 200     /*  Next, go through the ready list */
 201     ForeachNode(&SysBase->TaskReady, t)
 202     {
 203         et = GetETask(t);
 204         if (et != NULL && et->et_UniqueID == id)
 205             return t;
 206     }
 207
 208     /* Finally, go through the wait list */
 209     ForeachNode(&SysBase->TaskWait, t)
 210     {
 211         et = GetETask(t);
 212         if (et != NULL && et->et_UniqueID == id)
 213             return t;
 214     }
 215
 216     return NULL;
 217 }
 218
 219 /*****************************************************************************
 220
 221     NAME */
 222 #include "exec_util.h"
 223
 224         struct ETask * Exec_FindChild(
 225
 226 /*  SYNOPSIS */
 227         ULONG       id,
 228         struct ExecBase *SysBase)
 229
 230 /*  FUNCTION
 231         Scan through the current tasks children list searching for the task
 232         whose et_UniqueID field matches.
 233
 234     INPUTS
 235         id      -   The task ID to match.
 236
 237     RESULT
 238         Address of the ETask structure that matches, or
 239         NULL otherwise.
 240
 241     NOTES
 242
 243     EXAMPLE
 244
 245     BUGS
 246
 247     SEE ALSO
 248
 249     INTERNALS
 250
 251 ******************************************************************************/
 252 {
 253     struct ETask *et;
 254     struct ETask *thisET;
 255
 256     thisET = GetETask(FindTask(NULL));
 257     if (thisET != NULL)
 258     {
 259         ForeachNode (&thisET->et_Children, et)
 260         {
 261             if (et->et_UniqueID == id)
 262                 return et;
 263         }
 264         ForeachNode(&thisET->et_TaskMsgPort.mp_MsgList, et)
 265         {
 266             if (et->et_UniqueID == id)
 267                 return et;
 268         }
 269     }
 270     return NULL;
 271 }
 272
 273 void
 274 Exec_InitETask(struct Task *task, struct ETask *et, struct ExecBase *SysBase)
 275 {
 276     et->et_Parent = FindTask(NULL);
 277     NEWLIST(&et->et_Children);
 278
 279     /* Initialise the message list */
 280     NEWLIST(&et->et_TaskMsgPort.mp_MsgList);
 281     et->et_TaskMsgPort.mp_Flags = PA_SIGNAL;
 282     et->et_TaskMsgPort.mp_Node.ln_Type = NT_MSGPORT;
 283     et->et_TaskMsgPort.mp_SigTask = task;
 284     et->et_TaskMsgPort.mp_SigBit = SIGB_CHILD;
 285
 286     /* Initialise the trap fields */
 287     et->et_TrapAlloc = SysBase->TaskTrapAlloc;
 288     et->et_TrapAble = 0;
 289
 290 #ifdef DEBUG_ETASK
 291     {
 292         int len = strlen(task->tc_Node.ln_Name) + 1;
 293         IntETask(et)->iet_Me = AllocVec(len, MEMF_CLEAR|MEMF_PUBLIC);
 294         if (IntETask(et)->iet_Me != NULL)
 295             CopyMem(task->tc_Node.ln_Name, IntETask(et)->iet_Me, len);
 296     }
 297 #endif
 298
 299     /* Get an unique identifier for this task */
 300     Forbid();
 301     while(et->et_UniqueID == 0)
 302     {
 303         /*
 304          *      Add some fuzz on wrapping. Its likely that the early numbers
 305          *      where taken by somebody else.
 306          */
 307         if(++SysBase->ex_TaskID == 0)
 308             SysBase->ex_TaskID = 1024;
 309
 310         Disable();
 311         if(Exec_FindTaskByID(SysBase->ex_TaskID, SysBase) == NULL)
 312             et->et_UniqueID = SysBase->ex_TaskID;
 313         Enable();
 314     }
 315     Permit();
 316
 317     /* Finally if the parent task is an ETask, add myself as its child */
 318     if(et->et_Parent && ((struct Task*) et->et_Parent)->tc_Flags & TF_ETASK)
 319     {
 320         Forbid();
 321         ADDHEAD(&GetETask(et->et_Parent)->et_Children, et);
 322         Permit();
 323     }
 324 }
 325
 326 void
 327 Exec_CleanupETask(struct Task *task, struct ETask *et, struct ExecBase *SysBase)
 328 {
 329     struct ETask *child, *parent;
 330     struct Node *tmpNode;
 331     if(!et)
 332         return;
 333
 334     /* Clean up after all the children that the task didn't do itself. */
 335     ForeachNodeSafe(&et->et_TaskMsgPort.mp_MsgList, child, tmpNode)
 336     {
 337         /* This is effectively ChildFree() */
 338         if(child->et_Result2)
 339             FreeVec(child->et_Result2);
 340 #ifdef DEBUG_ETASK
 341         FreeVec(child->iet_Me);
 342 #endif
 343         FreeVec(child);
 344     }
 345
 346     /* Orphan all our remaining children. */
 347 #warning FIXME: should we link the children to our parent?
 348     ForeachNode(&et->et_Children, child)
 349         child->et_Parent = NULL;
 350
 351     /* If we have an ETask parent, tell it we have exited. */
 352     if(et->et_Parent != NULL)
 353     {
 354         parent = GetETask(et->et_Parent);
 355         /* Nofity parent only if child was created with NP_NotifyOnDeath set
 356            to TRUE */
 357         if(
 358             parent != NULL &&
 359             (((struct Task *)task)->tc_Node.ln_Type == NT_PROCESS) &&
 360             (((struct Process*) task)->pr_Flags & PRF_NOTIFYONDEATH)
 361         )
 362         {
 363             REMOVE(et);
 364             PutMsg(&parent->et_TaskMsgPort, et);
 365         }
 366         else if(parent != NULL)
 367         {
 368 #ifdef DEBUG_ETASK
 369             FreeVec(et->iet_Me);
 370 #endif
 371             REMOVE(et);
 372             FreeVec(et);
 373         }
 374         else
 375         {
 376 #ifdef DEBUG_ETASK
 377             FreeVec(et->iet_Me);
 378 #endif
 379             FreeVec(et);
 380         }
 381     }
 382     else
 383     {
 384 #ifdef DEBUG_ETASK
 385         FreeVec(et->iet_Me);
 386 #endif
 387         FreeVec(et);
 388     }
 389 }
 390