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
  13 #include <proto/exec.h>
  14
  15 #include "etask.h"
  16 #include "exec_util.h"
  17
  18 /*****************************************************************************
  19
  20     NAME */
  21 #include "exec_util.h"
  22
  23         APTR Exec_AllocTaskMem (
  24
  25 /*  SYNOPSIS */
  26         struct Task * task,
  27         ULONG         size,
  28         ULONG         req,
  29         struct ExecBase *SysBase)
  30
  31 /*  FUNCTION
  32         Allocate memory which will be freed when the task is removed.
  33
  34     INPUTS
  35         task      - The memory will be freed when this task is removed.
  36         size      - How much memory.
  37         req       - What memory. See AllocMem() for details.
  38
  39     RESULT
  40         Adress to a memory block or NULL if no memory was available.
  41
  42     NOTES
  43
  44     EXAMPLE
  45
  46     BUGS
  47
  48     SEE ALSO
  49         AllocMem(), FreeTaskMem()
  50
  51     INTERNALS
  52         The memory is allocated and queued in the tc_MemList. This
  53         list is freed in RemTask().
  54
  55 ******************************************************************************/
  56 {
  57     struct MemList * ml;
  58     APTR mem;
  59
  60     ml = AllocMem (sizeof (struct MemList), MEMF_ANY);
  61     mem = AllocMem (size, req);
  62
  63     if (!ml || !mem)
  64     {
  65         if (ml)
  66             FreeMem (ml, sizeof (struct MemList));
  67
  68         if (mem)
  69             FreeMem (mem, size);
  70
  71         return NULL;
  72     }
  73
  74     ml->ml_NumEntries      = 1;
  75     ml->ml_ME[0].me_Addr   = mem;
  76     ml->ml_ME[0].me_Length = size;
  77
  78     Forbid ();
  79     AddHead (&task->tc_MemEntry, &ml->ml_Node);
  80     Permit ();
  81
  82     return mem;
  83 } /* AllocTaskMem */
  84
  85
  86 /*****************************************************************************
  87
  88     NAME */
  89 #include "exec_util.h"
  90
  91         void Exec_FreeTaskMem (
  92
  93 /*  SYNOPSIS */
  94         struct Task * task,
  95         APTR          mem,
  96         struct ExecBase *SysBase)
  97
  98 /*  FUNCTION
  99         Freeate memory which will be freed when the task is removed.
 100
 101     INPUTS
 102         task      - The memory will be freed when this task is removed.
 103         size      - How much memory.
 104         req       - What memory. See FreeMem() for details.
 105
 106     RESULT
 107         Adress to a memory block or NULL if no memory was available.
 108
 109     NOTES
 110
 111     EXAMPLE
 112
 113     BUGS
 114
 115     SEE ALSO
 116         FreeMem(), FreeTaskMem()
 117
 118     INTERNALS
 119         The memory is allocated and queued in the tc_MemList. This
 120         list is freed in RemTask().
 121
 122 ******************************************************************************/
 123 {
 124     struct MemList * ml, * next;
 125
 126     Forbid ();
 127
 128     ForeachNodeSafe (&task->tc_MemEntry, ml, next)
 129     {
 130         /*
 131             Quick check: If the node was allocated by AllocTaskMem(),
 132             then it has only one entry.
 133         */
 134         if (ml->ml_NumEntries == 1
 135             && ml->ml_ME[0].me_Addr == mem
 136         )
 137         {
 138             Remove (&ml->ml_Node);
 139             Permit ();
 140
 141             FreeMem (ml->ml_ME[0].me_Addr, ml->ml_ME[0].me_Length);
 142             FreeMem (ml, sizeof (struct MemList));
 143
 144             return;
 145         }
 146     }
 147
 148     Permit ();
 149
 150 } /* FreeTaskMem */
 151
 152 /*****************************************************************************
 153
 154     NAME */
 155 #include "exec_util.h"
 156
 157         struct Task * Exec_FindTaskByID(
 158
 159 /*  SYNOPSIS */
 160         ULONG       id,
 161         struct ExecBase *SysBase)
 162
 163 /*  FUNCTION
 164         Scan through the task lists searching for the task whose
 165         et_UniqueID field matches.
 166
 167     INPUTS
 168         id      -   The task ID to match.
 169
 170     RESULT
 171         Address of the Task control structure that matches, or
 172         NULL otherwise.
 173
 174     NOTES
 175
 176     EXAMPLE
 177
 178     BUGS
 179
 180     SEE ALSO
 181
 182     INTERNALS
 183
 184 ******************************************************************************/
 185 {
 186     struct Task *t;
 187     struct ETask *et;
 188
 189     /*
 190         First up, check ThisTask. It could be NULL because of exec_init.c
 191     */
 192     if (SysBase->ThisTask != NULL)
 193     {
 194         et = GetETask(SysBase->ThisTask);
 195         if (et != NULL && et->et_UniqueID == id)
 196             return SysBase->ThisTask;
 197     }
 198
 199     /*  Next, go through the ready list */
 200     ForeachNode(&SysBase->TaskReady, t)
 201     {
 202         et = GetETask(t);
 203         if (et != NULL && et->et_UniqueID == id)
 204             return t;
 205     }
 206
 207     /* Finally, go through the wait list */
 208     ForeachNode(&SysBase->TaskWait, t)
 209     {
 210         et = GetETask(t);
 211         if (et != NULL && et->et_UniqueID == id)
 212             return t;
 213     }
 214
 215     return NULL;
 216 }
 217
 218 /*****************************************************************************
 219
 220     NAME */
 221 #include "exec_util.h"
 222
 223         struct ETask * Exec_FindChild(
 224
 225 /*  SYNOPSIS */
 226         ULONG       id,
 227         struct ExecBase *SysBase)
 228
 229 /*  FUNCTION
 230         Scan through the current tasks children list searching for the task
 231         whose et_UniqueID field matches.
 232
 233     INPUTS
 234         id      -   The task ID to match.
 235
 236     RESULT
 237         Address of the ETask structure that matches, or
 238         NULL otherwise.
 239
 240     NOTES
 241
 242     EXAMPLE
 243
 244     BUGS
 245
 246     SEE ALSO
 247
 248     INTERNALS
 249
 250 ******************************************************************************/
 251 {
 252     struct ETask *et;
 253     struct ETask *thisET;
 254
 255     thisET = GetETask(FindTask(NULL));
 256     if (thisET != NULL)
 257     {
 258         ForeachNode (&thisET->et_Children, et)
 259         {
 260             if (et->et_UniqueID == id)
 261                 return et;
 262         }
 263     }
 264     return NULL;
 265 }
 266
 267 void
 268 Exec_InitETask(struct Task *task, struct ETask *et, struct ExecBase *SysBase)
 269 {
 270     et->et_Parent = FindTask(NULL);
 271     NEWLIST(&et->et_Children);
 272
 273     /* Initialise the message list */
 274     NEWLIST(&et->et_TaskMsgPort.mp_MsgList);
 275     et->et_TaskMsgPort.mp_Flags = PA_SIGNAL;
 276     et->et_TaskMsgPort.mp_Node.ln_Type = NT_MSGPORT;
 277     et->et_TaskMsgPort.mp_SigTask = task;
 278     et->et_TaskMsgPort.mp_SigBit = SIGB_CHILD;
 279
 280     /* Initialise the trap fields */
 281     et->et_TrapAlloc = SysBase->TaskTrapAlloc;
 282     et->et_TrapAble = 0;
 283
 284 #ifdef DEBUG_ETASK
 285     {
 286         int len = strlen(task->tc_Node.ln_Name) + 1;
 287         IntETask(et)->iet_Me = AllocVec(len, MEMF_CLEAR|MEMF_PUBLIC);
 288         if (IntETask(et)->iet_Me != NULL)
 289             CopyMem(task->tc_Node.ln_Name, IntETask(et)->iet_Me, len);
 290     }
 291 #endif
 292
 293 #if 1
 294     Forbid();
 295     while(et->et_UniqueID == 0)
 296     {
 297         /*
 298          *      Add some fuzz on wrapping. Its likely that the early numbers
 299          *      where taken by somebody else.
 300          */
 301         if(++SysBase->ex_TaskID == 0)
 302             SysBase->ex_TaskID = 1024;
 303
 304         Disable();
 305         if(Exec_FindTaskByID(SysBase->ex_TaskID, SysBase) == NULL)
 306             et->et_UniqueID = SysBase->ex_TaskID;
 307         Enable();
 308     }
 309     Permit();
 310 #endif
 311 }