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     ULONG cpuusage;
  75 };
  76
  77 static int addtask(struct List *tasks, struct Task *task)
  78 {
  79     struct task *t;
  80     STRPTR s1,s2, e = NULL;
  81 #if defined(__AROS__)
  82     struct TagItem QueryTaskTags[] =
  83     {
  84         {TaskTag_CPUTime        , 0  },
  85         {TaskTag_CPUUsage       , 0  },
  86         {TAG_DONE               , 0                     }
  87     };
  88 #endif
  89
  90     if (task->tc_Node.ln_Type == NT_PROCESS && ((struct Process *)task)->pr_CLI)
  91     {
  92         struct CommandLineInterface *cli = BADDR(((struct Process *)task)->pr_CLI);
  93
  94         if (cli->cli_CommandName)
  95            s1 = AROS_BSTR_ADDR(cli->cli_CommandName);
  96         else
  97            s1 = task->tc_Node.ln_Name;
  98     }
  99     else
 100         s1 = task->tc_Node.ln_Name;
 101
 102     if (s1 == NULL)
 103         t = AllocVec(sizeof(struct task), MEMF_CLEAR|MEMF_PUBLIC);
 104     else
 105     {
 106         t = AllocVec(sizeof(struct task) + strlen(s1) + 1, MEMF_CLEAR|MEMF_PUBLIC);
 107         e = (STRPTR)&t[1] + strlen(s1);
 108     }
 109
 110     if (!t)
 111         return 0;
 112
 113 #if defined(__AROS__)
 114     QueryTaskTags[0].ti_Data = (IPTR)&t->cputime;
 115     QueryTaskTags[1].ti_Data = (IPTR)&t->cpuusage;
 116     QueryTaskTagList(task, QueryTaskTags);
 117 #endif
 118
 119     t->address = task;
 120     if (task->tc_Node.ln_Type == NT_PROCESS && ((struct Process *)task)->pr_CLI)
 121         t->node.ln_Type = -1;
 122     else
 123         t->node.ln_Type = task->tc_Node.ln_Type;
 124     t->node.ln_Pri = task->tc_Node.ln_Pri;
 125     t->state = task->tc_State;
 126     t->stacksize = (STRPTR)task->tc_SPUpper - (STRPTR)task->tc_SPLower;
 127 #if AROS_STACK_GROWS_DOWNWARDS
 128     t->stackused = (STRPTR)task->tc_SPUpper - SP_OFFSET - (STRPTR)task->tc_SPReg;
 129 #else
 130     t->stackused = (STRPTR)task->tc_SPReg - SP_OFFSET - (STRPTR)task->tc_SPLower;
 131 #endif
 132     if (task->tc_State == TS_RUN)
 133     {
 134         /* The tc_SPReg for the actual process is invalid
 135            if it had no context switch yet */
 136         t->stackused = 0;
 137     }
 138
 139     if (s1 != NULL)
 140     {
 141         s2 = s1;
 142
 143         while (*s2++)
 144             ;
 145
 146         while (s2 > s1)
 147             *--e=*--s2;
 148
 149         t->node.ln_Name = e;
 150     }
 151
 152     AddTail(tasks, &t->node);
 153
 154     return 1;
 155 }
 156
 157 static int fillbuffer(struct List *tasks)
 158 {
 159     struct Task *task;
 160
 161 #if !defined(__AROS__)
 162     Disable();
 163
 164     if (!addtask(task, FindTask(NULL)))
 165     {
 166         Enable();
 167         return RETURN_FAIL;
 168     }
 169     for (task = (struct Task *)SysBase->TaskReady.lh_Head;
 170         task->tc_Node.ln_Succ != NULL;
 171         task = (struct Task *)task->tc_Node.ln_Succ)
 172     {
 173         if (!addtask(tasks, task))
 174         {
 175             Enable();
 176             return RETURN_FAIL;
 177         }
 178     }
 179     for (task = (struct Task *)SysBase->TaskWait.lh_Head;
 180         task->tc_Node.ln_Succ != NULL;
 181         task = (struct Task *)task->tc_Node.ln_Succ)
 182     {
 183         if (!addtask(tasks, task))
 184         {
 185             Enable();
 186             return RETURN_FAIL;
 187         }
 188     }
 189     Enable();
 190 #else
 191     struct TaskList *taskList;
 192
 193     taskList = LockTaskList(LTF_ALL);
 194     while ((task = NextTaskEntry(taskList, LTF_ALL)) != NULL)
 195     {
 196         if (!addtask(tasks, task))
 197         {
 198             break;
 199         }
 200     }
 201     UnLockTaskList(taskList, LTF_ALL);
 202 #endif
 203
 204     return RETURN_OK;
 205 }
 206
 207 int main(void)
 208 {
 209     struct task *currentTask, *tmpTask;
 210     struct List tasks;
 211     int retval;
 212
 213 #if defined(__AROS__)
 214     TaskResBase = OpenResource("task.resource");
 215     if (!TaskResBase) {
 216         PutStr("Can't open task.resource\n");
 217         return RETURN_FAIL;
 218     }
 219 #endif
 220
 221     NEWLIST(&tasks);
 222
 223     retval = fillbuffer(&tasks);
 224
 225     if (!IsListEmpty(&tasks))
 226     {
 227 #if (__WORDSIZE == 64)
 228         PutStr("       Address     Type   Pri    State      CPU Time  CPU Usage     Stack      Used  Name\n");
 229 #else
 230         PutStr("   Address     Type   Pri    State      CPU Time  CPU Usage     Stack      Used  Name\n");
 231 #endif
 232         ForeachNodeSafe(&tasks, currentTask, tmpTask)
 233         {
 234             IPTR time;
 235             IPTR usec;
 236             ULONG usage = ((currentTask->cpuusage >> 16) * 10000) >> 16;
 237
 238             Remove((struct Node *)currentTask);
 239
 240             time = currentTask->cputime.tv_secs;
 241             /* Dunno why I need the mask on tv_usec, but sometimes high bits leak from somewhere into this code. gcc issue? */
 242             usec = (((currentTask->cputime.tv_usec & 0xfffff) + 5000) / 10000);
 243 #if (__WORDSIZE == 64)
 244             Printf("0x%012.ix %8s  %4id  %7s  %3id:%02id:%02id.%02id    %3id.%02id%% %9id %9id  %s\n",
 245 #else
 246             Printf("0x%08.ix %8s  %4id  %7s  %3id:%02id:%02id.%02id    %3id.%02id%% %9id %9id  %s\n",
 247 #endif
 248                     currentTask->address,
 249                     (currentTask->node.ln_Type == NT_TASK) ? "task" :
 250                     (currentTask->node.ln_Type == NT_PROCESS) ? "process" : "CLI",
 251                     (SIPTR)currentTask->node.ln_Pri,
 252                     (currentTask->state == TS_RUN) ? "running" :
 253                     (currentTask->state == TS_READY) ? "ready" : "waiting",
 254                     (IPTR)(time / 60 / 60), (IPTR)((time / 60) % 60), (IPTR)(time % 60), usec,
 255                     (IPTR)usage / 100, (IPTR)usage % 100,
 256                     currentTask->stacksize, currentTask->stackused,
 257                     (currentTask->node.ln_Name != NULL) ? currentTask->node.ln_Name : "(null)");
 258
 259             FreeVec(currentTask);
 260         }
 261     }
 262     return retval;
 263 }