rom/exec/remtask.c

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