workbench/c/TaskList.c

   1 /*
   2     Copyright © 1995-2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 /******************************************************************************
  10
  11
  12     NAME
  13
  14         TaskList
  15
  16     SYNOPSIS
  17
  18         (N/A)
  19
  20     LOCATION
  21
  22         C:
  23
  24     FUNCTION
  25
  26         Prints a list of all tasks.
  27
  28     INPUTS
  29
  30     RESULT
  31
  32     NOTES
  33
  34     EXAMPLE
  35
  36     BUGS
  37
  38     SEE ALSO
  39
  40     INTERNALS
  41
  42     HISTORY
  43
  44 ******************************************************************************/
  45
  46 int __nocommandline;
  47
  48 #include <exec/memory.h>
  49 #include <exec/tasks.h>
  50 #include <exec/execbase.h>
  51 #include <proto/exec.h>
  52 #include <proto/timer.h>
  53 #include <aros/debug.h>
  54 #include <devices/timer.h>
  55 #include <dos/dosextens.h>
  56 #include <proto/dos.h>
  57 #include <proto/task.h>
  58
  59 #include <resources/task.h>
  60
  61 const TEXT version[] = "$VER: TaskList 42.2 (21.01.2017)\n";
  62
  63 APTR TaskResBase = NULL;
  64 ULONG eclock;
  65
  66 struct task
  67 {
  68     struct Node node;
  69     APTR address;
  70     WORD state;
  71     IPTR stacksize;
  72     IPTR stackused;
  73     struct timeval cputime;
  74 };
  75
  76 static int addtask(struct List *tasks, struct Task *task)
  77 {
  78     struct task *t;
  79     STRPTR s1,s2, e = NULL;
  80 #if defined(__AROS__)
  81     struct TagItem QueryTaskTags[] =
  82     {
  83         {TaskTag_CPUTime        , 0  },
  84         {TAG_DONE               , 0                     }
  85     };
  86 #endif
  87
  88     if (task->tc_Node.ln_Type == NT_PROCESS && ((struct Process *)task)->pr_CLI)
  89     {
  90         struct CommandLineInterface *cli = BADDR(((struct Process *)task)->pr_CLI);
  91
  92         if (cli->cli_CommandName)
  93            s1 = AROS_BSTR_ADDR(cli->cli_CommandName);
  94         else
  95            s1 = task->tc_Node.ln_Name;
  96     }
  97     else
  98         s1 = task->tc_Node.ln_Name;
  99
 100     if (s1 == NULL)
 101         t = AllocVec(sizeof(struct task), MEMF_CLEAR|MEMF_PUBLIC);
 102     else
 103     {
 104         t = AllocVec(sizeof(struct task) + strlen(s1) + 1, MEMF_CLEAR|MEMF_PUBLIC);
 105         e = (STRPTR)&t[1] + strlen(s1);
 106     }
 107
 108     if (!t)
 109         return 0;
 110
 111 #if defined(__AROS__)
 112     QueryTaskTags[0].ti_Data = (IPTR)&t->cputime;
 113     QueryTaskTagList(task, QueryTaskTags);
 114 #endif
 115
 116     t->address = task;
 117     if (task->tc_Node.ln_Type == NT_PROCESS && ((struct Process *)task)->pr_CLI)
 118         t->node.ln_Type = -1;
 119     else
 120         t->node.ln_Type = task->tc_Node.ln_Type;
 121     t->node.ln_Pri = task->tc_Node.ln_Pri;
 122     t->state = task->tc_State;
 123     t->stacksize = (STRPTR)task->tc_SPUpper - (STRPTR)task->tc_SPLower;
 124 #if AROS_STACK_GROWS_DOWNWARDS
 125     t->stackused = (STRPTR)task->tc_SPUpper - SP_OFFSET - (STRPTR)task->tc_SPReg;
 126 #else
 127     t->stackused = (STRPTR)task->tc_SPReg - SP_OFFSET - (STRPTR)task->tc_SPLower;
 128 #endif
 129     if (task->tc_State == TS_RUN)
 130     {
 131         /* The tc_SPReg for the actual process is invalid
 132            if it had no context switch yet */
 133         t->stackused = 0;
 134     }
 135
 136     if (s1 != NULL)
 137     {
 138         s2 = s1;
 139
 140         while (*s2++)
 141             ;
 142
 143         while (s2 > s1)
 144             *--e=*--s2;
 145
 146         t->node.ln_Name = e;
 147     }
 148
 149     AddTail(tasks, &t->node);
 150
 151     return 1;
 152 }
 153
 154 static int fillbuffer(struct List *tasks)
 155 {
 156     struct Task *task;
 157
 158 #if !defined(__AROS__)
 159     Disable();
 160
 161     if (!addtask(task, FindTask(NULL)))
 162     {
 163         Enable();
 164         return RETURN_FAIL;
 165     }
 166     for (task = (struct Task *)SysBase->TaskReady.lh_Head;
 167         task->tc_Node.ln_Succ != NULL;
 168         task = (struct Task *)task->tc_Node.ln_Succ)
 169     {
 170         if (!addtask(tasks, task))
 171         {
 172             Enable();
 173             return RETURN_FAIL;
 174         }
 175     }
 176     for (task = (struct Task *)SysBase->TaskWait.lh_Head;
 177         task->tc_Node.ln_Succ != NULL;
 178         task = (struct Task *)task->tc_Node.ln_Succ)
 179     {
 180         if (!addtask(tasks, task))
 181         {
 182             Enable();
 183             return RETURN_FAIL;
 184         }
 185     }
 186     Enable();
 187 #else
 188     struct TaskList *taskList;
 189
 190     taskList = LockTaskList(LTF_ALL);
 191     while ((task = NextTaskEntry(taskList, LTF_ALL)) != NULL)
 192     {
 193         if (!addtask(tasks, task))
 194         {
 195             break;
 196         }
 197     }
 198     UnLockTaskList(taskList, LTF_ALL);
 199 #endif
 200
 201     return RETURN_OK;
 202 }
 203
 204 int main(void)
 205 {
 206     struct task *currentTask, *tmpTask;
 207     struct List tasks;
 208     int retval;
 209
 210 #if defined(__AROS__)
 211     TaskResBase = OpenResource("task.resource");
 212     if (!TaskResBase) {
 213         PutStr("Can't open task.resource\n");
 214         return RETURN_FAIL;
 215     }
 216 #endif
 217
 218     NEWLIST(&tasks);
 219
 220     retval = fillbuffer(&tasks);
 221
 222     if (!IsListEmpty(&tasks))
 223     {
 224         PutStr("Address\t\tType\tPri\tState\tCPU Time\tStack\tUsed\tName\n");
 225         ForeachNodeSafe(&tasks, currentTask, tmpTask)
 226         {
 227             ULONG time;
 228
 229             Remove((struct Node *)currentTask);
 230
 231             time = currentTask->cputime.tv_secs;
 232             Printf("0x%08.ix\t%s\t%ld\t%s\t%03ld:%02ld:%02ld\t%id\t%id\t%s\n",
 233                     currentTask->address,
 234                     (currentTask->node.ln_Type == NT_TASK) ? "task" :
 235                     (currentTask->node.ln_Type == NT_PROCESS) ? "process" : "CLI",
 236                     (ULONG)currentTask->node.ln_Pri,
 237                     (currentTask->state == TS_RUN) ? "running" :
 238                     (currentTask->state == TS_READY) ? "ready" : "waiting",
 239                     (time / 60 / 60), (time / 60) % 60, time % 60,
 240                     currentTask->stacksize, currentTask->stackused,
 241                     (currentTask->node.ln_Name != NULL) ? currentTask->node.ln_Name : "(null)");
 242
 243             FreeVec(currentTask);
 244         }
 245     }
 246     return retval;
 247 }