workbench/system/SysMon/tasks.c

   1 /*
   2     Copyright 2010-2016, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <exec/execbase.h>
   7 #include <resources/task.h>
   8 #include <clib/alib_protos.h>
   9
  10 #include <proto/task.h>
  11 #include <proto/dos.h>
  12
  13 #include "locale.h"
  14
  15 #include "sysmon_intern.h"
  16
  17 //#define DEBUG 1
  18 #include <aros/debug.h>
  19
  20
  21 APTR TaskResBase = NULL;
  22
  23 /* Task information handling*/
  24 struct TaskInfo
  25 {
  26     struct Node TINode;
  27     struct Task *Task;
  28     ULONG TimeCurrent;
  29     ULONG TimeLast;
  30 };
  31
  32 VOID UpdateTasksInformation(struct SysMonData * smdata)
  33 {
  34     struct Task * task;
  35     IPTR firstvis = 0, entryid = 0;
  36     struct Task *selected = smdata->sm_TaskSelected;
  37     struct TaskList *systasklist;
  38
  39     set(smdata->tasklist, MUIA_List_Quiet, TRUE);
  40
  41     get(smdata->tasklist, MUIA_List_First, &firstvis);
  42
  43     DoMethod(smdata->tasklist, MUIM_List_Clear);
  44
  45     smdata->sm_TasksWaiting = 0;
  46     smdata->sm_TasksReady = 0;
  47     smdata->sm_TaskTotalRuntime = 0;
  48
  49 #if 0
  50     /* We are unlikely to disappear and this code still run... so don't disable yet */
  51     if ((entryid = DoMethod(smdata->tasklist, MUIM_List_InsertSingle, smdata->sm_Task, MUIV_List_Insert_Bottom)) == 0)
  52     {
  53         return;
  54     }
  55 #endif
  56     if (smdata->sm_Task == selected)
  57     {
  58         set(smdata->tasklist, MUIA_List_Active, entryid);
  59     }
  60
  61     systasklist = LockTaskList(0);
  62     while ((task = NextTaskEntry(systasklist, 0)) != NULL)
  63     {
  64         D(bug("[SysMon] task %s state %d\n", task->tc_Node.ln_Name, task->tc_State));
  65
  66         if (task->tc_State == TS_READY)
  67         {
  68             smdata->sm_TasksReady++;
  69         }
  70         if (task->tc_State == TS_WAIT)
  71         {
  72             smdata->sm_TasksWaiting++;
  73         }
  74
  75         entryid = DoMethod(smdata->tasklist, MUIM_List_InsertSingle, task, MUIV_List_Insert_Bottom);
  76         if (task == selected)
  77         {
  78             set(smdata->tasklist, MUIA_List_Active, entryid);
  79         }
  80     }
  81     UnLockTaskList(0);
  82
  83     if (XGET(smdata->tasklist, MUIA_List_Active) == 0)
  84         smdata->sm_TaskSelected = NULL;
  85
  86     /* Keep the "pre-refresh" view on List as much as possible */
  87     LONG v = (LONG)firstvis;
  88     if (firstvis + XGET(smdata->tasklist, MUIA_List_Visible) >= XGET(smdata->tasklist, MUIA_List_Entries))
  89     {
  90         v = XGET(smdata->tasklist, MUIA_List_Entries) - XGET(smdata->tasklist, MUIA_List_Visible);
  91         if (v < 0) v = 0;
  92     }
  93
  94     set(smdata->tasklist, MUIA_List_First, v);
  95
  96     __sprintf(smdata->tasklistinfobuf, (STRPTR)__(MSG_TASK_READY_AND_WAIT), smdata->sm_TasksReady, smdata->sm_TasksWaiting);
  97     set(smdata->tasklistinfo, MUIA_Text_Contents, smdata->tasklistinfobuf);
  98     set(smdata->tasklist, MUIA_List_Quiet, FALSE);
  99 }
 100
 101 AROS_UFH3(struct TaskInfo *, TasksListConstructFunction,
 102     AROS_UFHA(struct Hook *, h,  A0),
 103     AROS_UFHA(APTR, pool, A2),
 104     AROS_UFHA(struct Task *, curTask, A1))
 105 {
 106     AROS_USERFUNC_INIT
 107
 108     struct TaskInfo *ti = NULL;
 109
 110     if ((ti = AllocVecPooled(pool, sizeof(struct TaskInfo))) != NULL)
 111     {
 112         ti->Task = curTask;
 113
 114         /* Cache values we need incase something happens to the task .. */
 115         ti->TINode.ln_Type = curTask->tc_Node.ln_Type;
 116         ti->TINode.ln_Pri = (WORD)curTask->tc_Node.ln_Pri;
 117         ti->TINode.ln_Name = StrDup(curTask->tc_Node.ln_Name);
 118
 119         AddTail(&((struct SysMonData *)h->h_Data)->sm_TaskList, &ti->TINode);
 120     }
 121     return ti;
 122
 123     AROS_USERFUNC_EXIT
 124 }
 125
 126 AROS_UFH3(VOID, TasksListDestructFunction,
 127     AROS_UFHA(struct Hook *, h,  A0),
 128     AROS_UFHA(APTR, pool, A2),
 129     AROS_UFHA(struct TaskInfo *, ti, A1))
 130 {
 131     AROS_USERFUNC_INIT
 132
 133     Remove(&ti->TINode);
 134     FreeVec(ti->TINode.ln_Name);
 135     FreeVecPooled(pool, ti);
 136
 137     AROS_USERFUNC_EXIT
 138 }
 139
 140 AROS_UFH3(VOID, TaskSelectedFunction,
 141     AROS_UFHA(struct Hook *, h, A0),
 142     AROS_UFHA(Object *, obj, A2),
 143     AROS_UFHA(APTR, msg, A1))
 144 {
 145     AROS_USERFUNC_INIT
 146
 147     struct SysMonData *smdata = h->h_Data;
 148     struct TaskInfo *ti = NULL;
 149
 150     DoMethod(smdata->tasklist, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &ti);
 151
 152     if (ti != NULL)
 153     {
 154         smdata->sm_TaskSelected = ti->Task;
 155     }
 156     else
 157         smdata->sm_TaskSelected = NULL;
 158
 159     AROS_USERFUNC_EXIT
 160 }
 161
 162
 163 AROS_UFH3(VOID, TasksListDisplayFunction,
 164     AROS_UFHA(struct Hook *, h,  A0),
 165     AROS_UFHA(STRPTR *, strings, A2),
 166     AROS_UFHA(struct TaskInfo *, ti, A1))
 167 {
 168     AROS_USERFUNC_INIT
 169
 170     static TEXT bufprio[8];
 171
 172     if (ti)
 173     {
 174         __sprintf(bufprio, "%d", (LONG)ti->TINode.ln_Pri);
 175
 176         strings[0] = ti->TINode.ln_Name;
 177         strings[1] = bufprio;
 178         strings[2] = ti->TINode.ln_Type == NT_TASK ? (STRPTR)_(MSG_TASK) : (STRPTR)_(MSG_PROCESS);
 179     }
 180     else
 181     {
 182         strings[0] = (STRPTR)_(MSG_TASK_NAME);
 183         strings[1] = (STRPTR)_(MSG_TASK_PRIORITY);
 184         strings[2] = (STRPTR)_(MSG_TASK_TYPE);
 185     }
 186
 187     AROS_USERFUNC_EXIT
 188 }
 189
 190 static BOOL InitTasks(struct SysMonData *smdata)
 191 {
 192     TaskResBase = OpenResource("task.resource");
 193     if (TaskResBase == NULL)
 194     {
 195         FPuts(Output(), (STRPTR)_(MSG_CANT_OPEN_TASK_RESOURCE));
 196         return FALSE;
 197     }
 198
 199     smdata->sm_Task = FindTask(NULL);
 200     NewList(&smdata->sm_TaskList);
 201
 202     smdata->tasklistinfobuf = AllocVec(30, MEMF_PUBLIC);
 203
 204     smdata->sm_TaskSelected = NULL;
 205     smdata->sm_TaskTotalRuntime = 0;
 206
 207     return TRUE;
 208 }
 209
 210 static VOID DeInitTasks(struct SysMonData *smdata)
 211 {
 212 }
 213
 214 struct SysMonModule tasksmodule =
 215 {
 216     .Init = InitTasks,
 217     .DeInit = DeInitTasks,
 218 };
 219