rom/exec/exec_util.c

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