rom/exec/remtask.c

   1 /*
   2     Copyright © 1995-2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Remove a task
   6     Lang: english
   7 */
   8
   9 #include <exec/execbase.h>
  10 #include <exec/tasks.h>
  11 #include <aros/libcall.h>
  12 #include <proto/exec.h>
  13 #include <aros/symbolsets.h>
  14
  15 #include "etask.h"
  16 #include "exec_intern.h"
  17 #include "exec_util.h"
  18 #include "exec_debug.h"
  19
  20 /*****************************************************************************
  21
  22     NAME */
  23
  24         AROS_LH1(void, RemTask,
  25
  26 /*  SYNOPSIS */
  27         AROS_LHA(struct Task *, task, A1),
  28
  29 /*  LOCATION */
  30         struct ExecBase *, SysBase, 48, Exec)
  31
  32 /*  FUNCTION
  33         Remove a task from the task lists. All memory in the tc_MemEntry list
  34         is freed and a reschedule is done. It's safe to call RemTask() outside
  35         Forbid() or Disable().
  36
  37         This function is one way to get rid of the current task. The other way
  38         is to fall through the end of the entry point.
  39
  40     INPUTS
  41         task - Task to be removed. NULL means current task.
  42
  43     RESULT
  44
  45     NOTES
  46
  47     EXAMPLE
  48
  49     BUGS
  50
  51     SEE ALSO
  52         AddTask()
  53
  54     INTERNALS
  55
  56 ******************************************************************************/
  57 {
  58     AROS_LIBFUNC_INIT
  59
  60     struct MemList *mb;
  61     struct ETask *et;
  62     struct Task *suicide = GET_THIS_TASK;
  63
  64     /* A value of NULL means current task */
  65     if (task == NULL)
  66         task = suicide;
  67
  68     DREMTASK("RemTask (0x%p (\"%s\"))", task, task->tc_Node.ln_Name);
  69
  70     /* Don't let any other task interfere with us at the moment */
  71     Forbid();
  72
  73     /* Dont try to kill a dying task .. */
  74     if ((task->tc_State != TS_INVALID) &&
  75         (task->tc_State != TS_TOMBSTONED) &&
  76         (task->tc_State != TS_REMOVED))
  77     {
  78         /*
  79          * The task is being removed.
  80          * This is an important signal for Alert() which will not attempt to use
  81          * the context which is being deleted, for example.
  82          */
  83
  84         if (suicide == task)
  85         {
  86             DREMTASK("Removing itself");
  87             task->tc_State = TS_REMOVED;
  88 #if defined(EXEC_REMTASK_NEEDSSWITCH)
  89             // make the scheduler detach us...
  90             krnSysCallSwitch();
  91 #endif
  92         }
  93         else
  94         {
  95             /*
  96              * Remove() here, before freeing the MemEntry list. Because
  97              * the MemEntry list might contain the task struct itself!
  98             */
  99 #if !defined(EXEC_REMTASK_NEEDSSWITCH)
 100             task->tc_State = TS_REMOVED;
 101             Remove(&task->tc_Node);
 102 #else
 103             krnSysCallReschedTask(task, TS_REMOVED);
 104 #endif
 105         }
 106
 107         /* Delete context */
 108         et = GetETask(task);
 109         if (et != NULL)
 110         {
 111 #if defined(__AROSEXEC_SMP__)
 112             // We must cache the CPU number here for the Exec Service Task...
 113             task->tc_UserData = (APTR)IntETask(et)->iet_CpuNumber;
 114 #endif
 115             KrnDeleteContext(et->et_RegFrame);
 116         }
 117
 118         /* Uninitialize ETask structure */
 119         DREMTASK("Cleaning up ETask et=%p", et);
 120         CleanupETask(task);
 121
 122         /* Freeing itself? */
 123         if (suicide == task)
 124         {
 125             /*
 126              * Send task to task cleaner to clean up memory. This avoids ripping
 127              * memory from underneath a running Task. Message is basically a
 128              * Node, so we use our task's tc_Node as a message. We use
 129              * InternalPutMsg() because it won't change ln_Type. Just in case...
 130              */
 131             DREMTASK("Sending to Exec service task");
 132             InternalPutMsg(PrivExecBase(SysBase)->ServicePort,
 133                 (struct Message *)task, SysBase);
 134
 135             DREMTASK("Disabling interrupts");
 136             /* Changing the task lists always needs a Disable(). */
 137             Disable();
 138
 139             DREMTASK("And multitasking..");
 140             /*
 141              * We don't know how many levels of Forbid()
 142              * are already pending, so use a default value.
 143             */
 144             TDNESTCOUNT_SET(-1);
 145
 146             /*
 147              * Force rescheduling.
 148              * Note #1: We dont want to preseve the task context so use Dispatch, not Switch.
 149              * Note #2: We will never return from the dispatch to "ThisTask"
 150             */
 151
 152             DREMTASK("Switching away..");
 153             /* It is  no longer a valid task.. */
 154             task->tc_State = TS_INVALID;
 155             KrnDispatch();
 156         }
 157         else
 158         {
 159             /*
 160              * Free all memory in the tc_MemEntry list.
 161              * We do this here because it's unsafe to send it to the service task:
 162              * by the time the service task processes it, the task structure may
 163              * have been freed following the return of this function.
 164              */
 165             while((mb = (struct MemList *) RemHead(&task->tc_MemEntry)) != NULL)
 166                 FreeEntry(mb);
 167         }
 168     }
 169
 170     /* All done. */
 171     Permit();
 172
 173     DREMTASK("Success");
 174
 175     AROS_LIBFUNC_EXIT
 176 }