workbench/c/TaskList.c

   1 /*
   2     Copyright © 1995-2015, 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 #include <exec/memory.h>
  47 #include <exec/tasks.h>
  48 #include <exec/execbase.h>
  49 #include <proto/exec.h>
  50 #include <proto/timer.h>
  51 #include <aros/debug.h>
  52 #include <devices/timer.h>
  53 #include <dos/dosextens.h>
  54 #include <proto/dos.h>
  55 #include <proto/task.h>
  56
  57 #include <resources/task.h>
  58
  59 const TEXT version[] = "$VER: tasklist 42.0 (02.5.2015)\n";
  60
  61 APTR TaskResBase = NULL;
  62 ULONG eclock;
  63
  64 struct task
  65 {
  66     STRPTR name;
  67     APTR address;
  68     WORD type;
  69     WORD state;
  70     IPTR stacksize;
  71     IPTR stackused;
  72     WORD pri;
  73     struct timeval cputime;
  74 };
  75
  76 static int addtask(struct Task *task, struct task **t, STRPTR *e)
  77 {
  78     STRPTR s1,s2;
  79     struct TagItem QueryTaskTags[] =
  80     {
  81         {TaskTag_CPUTime        , (IPTR)&(*t)->cputime  },
  82         {TAG_DONE               , 0                     }
  83     };
  84
  85     QueryTaskTagList(task, QueryTaskTags);
  86
  87     (*t)->address = task;
  88     (*t)->type = task->tc_Node.ln_Type;
  89     (*t)->pri = (WORD)task->tc_Node.ln_Pri;
  90     (*t)->state = task->tc_State;
  91     (*t)->stacksize = (STRPTR)task->tc_SPUpper - (STRPTR)task->tc_SPLower;
  92 #if AROS_STACK_GROWS_DOWNWARDS
  93     (*t)->stackused = (STRPTR)task->tc_SPUpper - SP_OFFSET - (STRPTR)task->tc_SPReg;
  94 #else
  95     (*t)->stackused = (STRPTR)task->tc_SPReg - SP_OFFSET - (STRPTR)task->tc_SPLower;
  96 #endif
  97     if (task->tc_State == TS_RUN)
  98     {
  99         /* The tc_SPReg for the actual process is invalid
 100            if it had no context switch yet */
 101         (*t)->stackused = 0;
 102     }
 103     s1 = task->tc_Node.ln_Name;
 104     if (task->tc_Node.ln_Type == NT_PROCESS && ((struct Process *)task)->pr_CLI)
 105     {
 106         /* TODO: Use cli_CommandName field for the name */
 107         (*t)->type = -1;
 108     }
 109     if (s1 != NULL)
 110     {
 111         s2 = s1;
 112
 113         while (*s2++)
 114             ;
 115
 116         while (s2 > s1)
 117         {
 118             if (*e<=(STRPTR)*t)
 119                 return 0;
 120             *--(*e)=*--s2;
 121         }
 122     }
 123     if ((STRPTR)(*t + 1) > *e)
 124         return 0;
 125
 126     (*t)->name = *e;
 127     ++*t;
 128
 129     return 1;
 130 }
 131
 132 static int fillbuffer(struct task **buffer, IPTR size)
 133 {
 134     STRPTR end = (STRPTR)*buffer + size;
 135     struct Task *task;
 136
 137 #if !defined(__AROS__)
 138     Disable();
 139
 140     if (!addtask(FindTask(NULL), buffer, &end))
 141     {
 142         Enable();
 143         return 0;
 144     }
 145     for (task = (struct Task *)SysBase->TaskReady.lh_Head;
 146         task->tc_Node.ln_Succ != NULL;
 147         task = (struct Task *)task->tc_Node.ln_Succ)
 148     {
 149         if (!addtask(task, buffer, &end))
 150         {
 151             Enable();
 152             return 0;
 153         }
 154     }
 155     for (task = (struct Task *)SysBase->TaskWait.lh_Head;
 156         task->tc_Node.ln_Succ != NULL;
 157         task = (struct Task *)task->tc_Node.ln_Succ)
 158     {
 159         if (!addtask(task, buffer, &end))
 160         {
 161             Enable();
 162             return 0;
 163         }
 164     }
 165     Enable();
 166 #else
 167     struct TaskList *taskList;
 168
 169     taskList = LockTaskList(0);
 170     while ((task = NextTaskEntry(taskList, 0)) != NULL)
 171     {
 172         if (!addtask(task, buffer, &end))
 173         {
 174             break;
 175         }
 176     }
 177     UnLockTaskList(0);
 178 #endif
 179
 180     return 1;
 181 }
 182
 183 int __nocommandline;
 184
 185 int main(void)
 186 {
 187     IPTR size;
 188     struct task *buffer,*tasks,*tasks2;
 189
 190     TaskResBase = OpenResource("task.resource");
 191
 192     for(size = 2048; ; size += 2048)
 193     {
 194         buffer = AllocVec(size, MEMF_ANY);
 195         if (buffer == NULL)
 196         {
 197             FPuts(Output(),"Not Enough memory for task buffer\n");
 198             return 20;
 199         }
 200         tasks = buffer;
 201         if (fillbuffer(&tasks, size))
 202         {
 203             FPuts(Output(), "Address\t\tType\tPri\tState\tCPU Time\tStack\tUsed\tName\n");
 204             for (tasks2 = buffer; tasks2 < tasks; tasks2++)
 205             {
 206                 ULONG time;
 207
 208                 IPTR args[10];
 209                 args[0] = (IPTR)tasks2->address;
 210                 args[1] = (IPTR)((tasks2->type == NT_TASK) ? "task" :
 211                                (tasks2->type == NT_PROCESS) ? "process" : "CLI" );
 212                 args[2] = tasks2->pri;
 213                 args[3] = (IPTR)((tasks2->state == TS_RUN) ? "running" :
 214                                (tasks2->state == TS_READY) ? "ready" : "waiting" );
 215
 216                 time = tasks2->cputime.tv_secs;
 217                 args[6] = time % 60;
 218                 time /= 60;
 219                 args[5] = time % 60;
 220                 time /= 60;
 221                 args[4] = time % 60;
 222
 223                 args[7] = tasks2->stacksize;
 224                 args[8] = tasks2->stackused;
 225                 args[9] = (tasks2->name != NULL) ? (IPTR)tasks2->name : 0;
 226                 VPrintf("0x%08.lx\t%s\t%ld\t%s\t%02ld:%02ld:%02ld\t%ld\t%ld\t%s\n", args);
 227             }
 228             FreeVec(buffer);
 229             return 0;
 230         }
 231         FreeVec(buffer);
 232     }
 233 }