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 41.4 (29.4.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         /* The tc_SPReg for the actual process is invalid
  99            if it had no context switch yet */
 100         (*t)->stackused=0;
 101     s1=task->tc_Node.ln_Name;
 102     if(task->tc_Node.ln_Type==NT_PROCESS&&((struct Process *)task)->pr_CLI)
 103     {
 104         /* TODO: Use cli_CommandName field for the name */
 105         (*t)->type=-1;
 106     }
 107     if(s1!=NULL)
 108     {
 109         s2=s1;
 110         while(*s2++)
 111             ;
 112         while(s2>s1)
 113         {
 114             if(*e<=(STRPTR)*t)
 115                 return 0;
 116             *--(*e)=*--s2;
 117         }
 118     }
 119     if((STRPTR)(*t+1)>*e)
 120         return 0;
 121     (*t)->name=*e;
 122     ++*t;
 123     return 1;
 124 }
 125
 126 static int fillbuffer(struct task **buffer, IPTR size)
 127 {
 128     STRPTR end=(STRPTR)*buffer+size;
 129     struct Task *task;
 130     Disable();
 131     if(!addtask(FindTask(NULL),buffer,&end))
 132     {
 133         Enable();
 134         return 0;
 135     }
 136     for(task=(struct Task *)SysBase->TaskReady.lh_Head;
 137         task->tc_Node.ln_Succ!=NULL;
 138         task=(struct Task *)task->tc_Node.ln_Succ)
 139     {
 140         if(!addtask(task,buffer,&end))
 141         {
 142             Enable();
 143             return 0;
 144         }
 145     }
 146     for(task=(struct Task *)SysBase->TaskWait.lh_Head;
 147         task->tc_Node.ln_Succ!=NULL;
 148         task=(struct Task *)task->tc_Node.ln_Succ)
 149     {
 150         if(!addtask(task,buffer,&end))
 151         {
 152             Enable();
 153             return 0;
 154         }
 155     }
 156     Enable();
 157     return 1;
 158 }
 159
 160 int __nocommandline;
 161
 162 int main(void)
 163 {
 164     IPTR size;
 165     struct task *buffer,*tasks,*tasks2;
 166
 167     TaskResBase = OpenResource("task.resource");
 168
 169     for(size=2048;;size+=2048)
 170     {
 171         buffer=AllocVec(size,MEMF_ANY);
 172         if(buffer==NULL)
 173         {
 174             FPuts(Output(),"Not Enough memory for task buffer\n");
 175             return 20;
 176         }
 177         tasks=buffer;
 178         if(fillbuffer(&tasks,size))
 179         {
 180             FPuts(Output(),"Address\t\tType\tPri\tState\tCPU Time\tStack\tUsed\tName\n");
 181             for(tasks2=buffer;tasks2<tasks;tasks2++)
 182             {
 183                 ULONG time;
 184
 185                 IPTR args[10];
 186                 args[0]=(IPTR)tasks2->address;
 187                 args[1]=(IPTR)(tasks2->type==NT_TASK?"task":
 188                                tasks2->type==NT_PROCESS?"process":"CLI");
 189                 args[2]=tasks2->pri;
 190                 args[3]=(IPTR)(tasks2->state==TS_RUN?"running":
 191                                tasks2->state==TS_READY?"ready":"waiting");
 192
 193                 time = tasks2->cputime.tv_secs;
 194                 args[6]=time % 60;
 195                 time /= 60;
 196                 args[5]=time % 60;
 197                 time /= 60;
 198                 args[4]=time % 60;
 199
 200                 args[7]=tasks2->stacksize;
 201                 args[8]=tasks2->stackused;
 202                 args[9]=tasks2->name!=NULL?(IPTR)tasks2->name:0;
 203                 VPrintf("0x%08.lx\t%s\t%ld\t%s\t%02ld:%02ld:%02ld\t%ld\t%ld\t%s\n",args);
 204             }
 205             FreeVec(buffer);
 206             return 0;
 207         }
 208         FreeVec(buffer);
 209     }
 210 }