home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / rsyssrc.lha / RSysExecLists.c < prev    next >
C/C++ Source or Header  |  1993-09-19  |  12KB  |  539 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *      RSysExecLists.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    void MakeIntrList ( void );
  12. *    void MakeLibList ( void );
  13. *    void MakePortList ( void );
  14. *    void MakeResList ( void );
  15. *    void MakeTaskList ( void );
  16. *    void RSysMemoryAreaList ( void );
  17. *    void SysSemaphoreList ( void );
  18. *    void SysSoftDeviceList ( void );
  19. *    void SysVectorList ( void );
  20. *
  21. *      --- Lokale  Routinen ---
  22. *
  23. *    static void CopyTaskNode ( int entrynum , struct Node *node );
  24. *
  25. * Bemerkungen:
  26. *      Erzeugung von EXEC-Listen (Tasks, Ports, Libraries etc.).
  27. *
  28. * Erstellungsdatum:
  29. *      07-Jul-93     Rolf Böhme
  30. *
  31. * Änderungen:
  32. *      07-Jul-93     Rolf Böhme      Erstellung
  33. *
  34. ***************************************************************************
  35. */
  36.  
  37. #include "RSys.h"
  38.  
  39.     /*
  40.      * MakeLibList() erzeugt eine Liste aus allen im System
  41.      * angemeldeten Libraries.
  42.      */
  43. void
  44. MakeLibList(void)
  45. {
  46.     struct Node *node;
  47.     struct Library *lib;
  48.     int    i = 0;
  49.  
  50.     DPOS;
  51.  
  52.     countentries = CountNodes(&SysBase->LibList);
  53.  
  54.     if (NoEntries()) return;
  55.  
  56.     Entries = AllocScrollEntries(countentries);
  57.  
  58.     Forbid();
  59.  
  60.     for (node = SysBase->LibList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  61.     {
  62.         lib = (struct Library *) node;
  63.  
  64.         Entries[i].se_obj_id.address = lib;
  65.         savestrcpy(Entries[i].se_obj_id.fullname, node, MAXFULLNAME - 1, NT_LIBRARY);
  66.  
  67.         sprintf(Entries[i].se_Entry, EntryAttr[LIBRARIES].ea_dataformat,
  68.               Entries[i].se_obj_id.address,
  69.                   Entries[i].se_obj_id.fullname,
  70.                   lib->lib_Version,
  71.                   lib->lib_Revision,
  72.                   lib->lib_OpenCnt,
  73.                   (lib->lib_OpenCnt ? '*' : ' '));
  74.  
  75.         i++;
  76.     }
  77.  
  78.     countentries = i;
  79.  
  80.     Permit();
  81.  
  82.     CreateEntryList(SORT, 9);
  83.  
  84.     return;
  85. }
  86.  
  87.     /*
  88.      * MakeResList() erzeugt eine Liste der Ressourcen, die
  89.      * in der ExecBase eingetragen sind
  90.      */
  91. void
  92. MakeResList(void)
  93. {
  94.     struct Node *node;
  95.     struct Library *lib;
  96.     int    i;
  97.  
  98.     DPOS;
  99.  
  100.     countentries = CountNodes(&SysBase->ResourceList);
  101.  
  102.     if (NoEntries()) return;
  103.  
  104.     Entries = AllocScrollEntries(countentries);
  105.  
  106.     Forbid();
  107.  
  108.     i = 0;
  109.  
  110.     for (node = SysBase->ResourceList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  111.     {
  112.         lib = (struct Library *) node;
  113.  
  114.         Entries[i].se_obj_id.address = lib;
  115.         savestrcpy(Entries[i].se_obj_id.fullname, node, MAXFULLNAME - 1, NT_RESOURCE);
  116.  
  117.         sprintf(Entries[i].se_Entry, EntryAttr[RESOURCES].ea_dataformat,
  118.               Entries[i].se_obj_id.address,
  119.                   Entries[i].se_obj_id.fullname,
  120.                   lib->lib_Version,
  121.                   lib->lib_Revision,
  122.                   lib->lib_OpenCnt);
  123.  
  124.         i++;
  125.     }
  126.  
  127.     countentries = i;
  128.  
  129.     Permit();
  130.  
  131.     CreateEntryList(SORT, 9);
  132.  
  133.     return;
  134. }
  135.  
  136.     /*
  137.      * MakeIntrList() listet alle 16 Interrupts auf, die vom System
  138.      * verwaltet werden können
  139.      */
  140. void
  141. MakeIntrList(void)
  142. {
  143.     struct Node *node;
  144.     int    i;
  145.  
  146.     DPOS;
  147.  
  148.     countentries = 16;
  149.  
  150.     Entries = AllocScrollEntries(countentries);
  151.  
  152.     Disable();
  153.  
  154.     for (i = 0; i < countentries; i++)
  155.     {
  156.         node = SysBase->IntVects[i].iv_Node;
  157.  
  158.       Entries[i].se_obj_id.address = node;
  159.         if (node)
  160.         {
  161.             savestrcpy(Entries[i].se_obj_id.fullname, node, MAXFULLNAME - 1, NT_INTERRUPT);
  162.  
  163.             sprintf(Entries[i].se_Entry, EntryAttr[INTERRUPTS].ea_dataformat,
  164.                  Entries[i].se_obj_id.address,
  165.                       Entries[i].se_obj_id.fullname,
  166.                       node->ln_Pri,
  167.                       (long)((struct Interrupt *) node)->is_Data,
  168.                       (long)(((struct Interrupt *) node)->is_Code));
  169.         }
  170.         else sprintf(Entries[i].se_Entry, EntryAttr[INTERRUPTS].ea_dataformat,
  171.                       field[NO_NODE], 0, 0L, 0L);
  172.     }
  173.  
  174.     Enable();
  175.  
  176.     CreateEntryList(NO_SORT, 9);
  177.  
  178.     return;
  179. }
  180.  
  181.     /*
  182.      * MakePortList() erzeugt eine Liste der im System angemeldeten
  183.      * öffentlichen Ports
  184.      */
  185. void
  186. MakePortList(void)
  187. {
  188.     struct Node *node;
  189.     struct Task *task;
  190.     struct MsgPort *port;
  191.     char sigtask[16];
  192.     int    i = 0;
  193.  
  194.     DPOS;
  195.  
  196.     countentries = CountNodes(&SysBase->PortList);
  197.  
  198.     if (NoEntries()) return;
  199.  
  200.     Entries = AllocScrollEntries(countentries);
  201.  
  202.     Forbid();
  203.  
  204.     for (node = SysBase->PortList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  205.     {
  206.         Entries[i].se_obj_id.address = node;
  207.         savestrcpy(Entries[i].se_obj_id.fullname, node, MAXFULLNAME - 1, NT_MSGPORT);
  208.  
  209.         port = (struct MsgPort *)node;
  210.         task = (struct Task *) port->mp_SigTask;
  211.         if (task) savestrcpy(sigtask, &(task->tc_Node), 15, NT_TASK);
  212.         else
  213.             strcpy(sigtask, field[NO_TASK]);
  214.  
  215.         sprintf(Entries[i].se_Entry, EntryAttr[PORTS].ea_dataformat,
  216.               Entries[i].se_obj_id.address,
  217.                   Entries[i].se_obj_id.fullname,
  218.                   sigtask, node->ln_Pri);
  219.  
  220.         i++;
  221.     }
  222.  
  223.     countentries = i;
  224.  
  225.     Permit();
  226.  
  227.     CreateEntryList(SORT, 9);
  228.  
  229.     return;
  230. }
  231.  
  232.  
  233.     /*
  234.      * CopyTaskNode() kopiert die Daten eines Tasks in eine interne
  235.      * Listenstruktur
  236.      */
  237. static void
  238. CopyTaskNode(int entrynum, struct Node *node)
  239. {
  240.    struct CommandLineInterface *CLI;
  241.    struct Process *proc;
  242.     char *status[]=
  243.     {
  244.         "Inv", "Add", "Run", "Rdy", "Wait", "Excp", "Rem"
  245.     },
  246.     cli[5], buf[BUFSIZE], backtask[BUFSIZE], *backtaskstr = NULL;
  247.  
  248.     Entries[entrynum].se_obj_id.address = node;
  249.  
  250.     savestrcpy(Entries[entrynum].se_obj_id.fullname, node, MAXFULLNAME - 1, NT_TASK);
  251.  
  252.    if(!strcmp(Entries[entrynum].se_obj_id.fullname, "Background CLI") ||
  253.       !strcmp(Entries[entrynum].se_obj_id.fullname, "Shell Process"))
  254.    {
  255.       proc = (struct Process *) node;
  256.       CLI = (struct CommandLineInterface *) BADDR(proc->pr_CLI);
  257.  
  258.       backtaskstr = B2CStr(buf, CLI->cli_CommandName);
  259.       buf[15] = STRINGEND;
  260.  
  261.       if(strlen(backtaskstr) != 0) sprintf(backtask,"[%s]", buf);
  262.       else
  263.          strcpy(backtask,"[no command]");
  264.    }
  265.  
  266.     if ((node->ln_Type == NT_PROCESS) && ((struct Process *) node)->pr_CLI)
  267.         sprintf(cli, "%3ld", ((struct Process *) node)->pr_TaskNum);
  268.     else
  269.         strcpy(cli, field[NO_FIELD]);
  270.  
  271.     sprintf(Entries[entrynum].se_Entry, EntryAttr[TASKS].ea_dataformat,
  272.            Entries[entrynum].se_obj_id.address,
  273.               backtaskstr ? backtask : Entries[entrynum].se_obj_id.fullname,
  274.               (node->ln_Type == NT_PROCESS) ? (char *)"Proc" : (char *)"Task",
  275.               node->ln_Pri,
  276.               ((ULONG) ((struct Task *) node)->tc_SPUpper -
  277.                 (ULONG) ((struct Task *) node)->tc_SPLower),
  278.               status[((struct Task *) node)->tc_State],
  279.               cli);
  280.  
  281.     return;
  282. }
  283.  
  284.     /*
  285.      * MakeTaskList() erzeugt eine Liste der im System angemeldeten Tasks und
  286.      * Prozesse
  287.      */
  288. void
  289. MakeTaskList(void)
  290. {
  291.     struct Node *node, **membernode;
  292.     register int i = 0;
  293.  
  294.     DPOS;
  295.  
  296.     countentries = CountNodes(&SysBase->TaskWait);
  297.     countentries += CountNodes(&SysBase->TaskReady) + 1;
  298.  
  299.     if (NoEntries()) return;
  300.  
  301.     Entries = AllocScrollEntries(countentries);
  302.  
  303.     membernode = (struct Node **) MyAllocVec(countentries * sizeof(struct Node *),
  304.                                                           MEMF_ANY | MEMF_CLEAR, KILL);
  305.  
  306.     Forbid();
  307.     Disable();
  308.  
  309.     for (node = SysBase->TaskWait.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  310.         membernode[i++] = node;
  311.  
  312.     for (node = SysBase->TaskReady.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  313.         membernode[i++] = node;
  314.  
  315.     if (i < countentries) membernode[i++] = &SysBase->ThisTask->tc_Node;
  316.  
  317.     Enable();
  318.  
  319.     countentries = i;
  320.  
  321.     for (i = 0; i < countentries; i++) CopyTaskNode(i,membernode[i]);
  322.  
  323.     Permit();
  324.  
  325.     MyFreeVec(membernode);
  326.  
  327.     CreateEntryList(SORT, 9);
  328.  
  329.     return;
  330. }
  331.  
  332.     /*
  333.      * SysSemaphoreList() listet alle angemeldeten Semaphoren
  334.      * auf, die in der ExecBase eingetragen sind
  335.      */
  336. void
  337. SysSemaphoreList(void)
  338. {
  339.     struct Node *node;
  340.     int    i = 0;
  341.     struct SignalSemaphore *SigSem;
  342.     char name[23], sigtask[20];
  343.  
  344.     DPOS;
  345.  
  346.    HandleHelp(MN_SysSemaphoreList);
  347.  
  348.     PrintHeader(SEMAPHORES, NULL);
  349.  
  350.     EmptyListView();
  351.  
  352.     countentries = CountNodes(&SysBase->SemaphoreList);
  353.  
  354.     if (NoEntries()) return;
  355.  
  356.     Entries = AllocScrollEntries(countentries);
  357.  
  358.     Forbid();
  359.  
  360.     for (node = SysBase->SemaphoreList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  361.     {
  362.         SigSem = (struct SignalSemaphore *) node;
  363.  
  364.         savestrcpy(name, node, 22, NT_SEMAPHORE);
  365.  
  366.         if (SigSem->ss_Owner) savestrcpy(sigtask,&(SigSem->ss_Owner->tc_Node), 19, NT_TASK );
  367.         else
  368.             strcpy(sigtask, field[NO_TASK]);
  369.  
  370.       Entries[i].se_obj_id.address = node;
  371.  
  372.         sprintf(Entries[i].se_Entry, EntryAttr[SEMAPHORES].ea_dataformat,
  373.               Entries[i].se_obj_id.address,
  374.                   name, node->ln_Pri, sigtask);
  375.  
  376.         i++;
  377.     }
  378.  
  379.     countentries = i;
  380.  
  381.     Permit();
  382.  
  383.     CreateEntryList(SORT, 9);
  384.  
  385.     PrintStatistics();
  386.  
  387.     return;
  388. }
  389.  
  390.     /*
  391.      * SysVectorList() erzeugt eine Liste aller "kritischen"
  392.      * Systemvektoren. Ist eine von ihnen ungleich NULL,
  393.      * sollte dem nachgegangen werden, da diese eine beliebte
  394.      * Einsprungadresse für Viren darstellen
  395.      */
  396. void
  397. SysVectorList(void)
  398. {
  399.     struct ExecBase CopySysBase;
  400.     int    i = 0;
  401.  
  402.    HandleHelp(MN_SysVectorList);
  403.  
  404.     DPOS;
  405.  
  406.     PrintHeader(SYSVECTORS, NULL);
  407.  
  408.     EmptyListView();
  409.  
  410.     countentries = 14;
  411.  
  412.     Entries = AllocScrollEntries(countentries);
  413.  
  414.     Forbid();
  415.     CopyMem((APTR) SysBase, (APTR) &CopySysBase, sizeof(struct ExecBase));
  416.     Permit();
  417.  
  418.     strcpy(Entries[i].se_Entry, "----- Capture vectors");
  419.     AddNodeToList(i++, NO_SORT, 0);
  420.  
  421.     MakeHexEntry(&i, "ColdCapture", CopySysBase.ColdCapture);
  422.     MakeHexEntry(&i, "CoolCapture", CopySysBase.CoolCapture);
  423.     MakeHexEntry(&i, "WarmCapture", CopySysBase.WarmCapture);
  424.  
  425.  
  426.     MakeHeadEntry(&i, "----- Kick pointer");
  427.  
  428.     MakeHexEntry(&i, "KickMemPtr", CopySysBase.KickMemPtr);
  429.     MakeHexEntry(&i, "KickTagPtr", CopySysBase.KickTagPtr);
  430.     MakeHexEntry(&i, "KickCheckSum", CopySysBase.KickCheckSum);
  431.  
  432.     MakeHeadEntry(&i, "----- Exec special pointer");
  433.  
  434.     MakeHexEntry(&i, "Debug entry", CopySysBase.DebugEntry);
  435.     MakeHexEntry(&i, "ResModules", CopySysBase.ResModules);
  436.     MakeHexEntry(&i, "MMU-Lock", CopySysBase.ex_MMULock);
  437.  
  438.     PrintStatistics();
  439.  
  440.     return;
  441. }
  442.  
  443.     /*
  444.      * SysSoftDeviceList() listet alle *.device auf, die in
  445.      * der ExecBase angemeldet sind
  446.      */
  447. void
  448. SysSoftDeviceList(void)
  449. {
  450.     struct Node *node;
  451.     struct Library *device_lib;
  452.     int    i = 0;
  453.  
  454.    HandleHelp(MN_SysSoftDeviceList);
  455.  
  456.     DPOS;
  457.  
  458.     PrintHeader(SYSSOFTDEV, NULL);
  459.  
  460.     EmptyListView();
  461.  
  462.     countentries = CountNodes(&SysBase->DeviceList);
  463.  
  464.     if (NoEntries()) return;
  465.  
  466.     Entries = AllocScrollEntries(countentries);
  467.  
  468.     Forbid();
  469.  
  470.     for (node = SysBase->DeviceList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  471.     {
  472.         device_lib = &((struct Device *) node)->dd_Library;
  473.  
  474.         Entries[i].se_obj_id.address = device_lib;
  475.         savestrcpy(Entries[i].se_obj_id.fullname, node, MAXFULLNAME - 1, NT_DEVICE);
  476.  
  477.         sprintf(Entries[i].se_Entry, EntryAttr[RESOURCES].ea_dataformat,
  478.               Entries[i].se_obj_id.address,
  479.                   Entries[i].se_obj_id.fullname,
  480.                   device_lib->lib_Version,
  481.                   device_lib->lib_Revision,
  482.                   device_lib->lib_OpenCnt);
  483.         i++;
  484.     }
  485.  
  486.     countentries = i;
  487.  
  488.     Permit();
  489.  
  490.     CreateEntryList(SORT, 9);
  491.  
  492.     PrintStatistics();
  493.  
  494.     return;
  495. }
  496.  
  497. void
  498. RSysMemoryAreaList(void)
  499. {
  500.     struct Node *node;
  501.    ValidMemoryNode *vmnode;
  502.     int    i = 0;
  503.  
  504.     DPOS;
  505.  
  506.     PrintHeader(MEMORYAREAS, NULL);
  507.  
  508.     EmptyListView();
  509.  
  510.     if (!Flags.dummy4)   return;
  511.  
  512.     countentries = CountNodes(&ValidMemoryList);
  513.  
  514.     Entries = AllocScrollEntries(countentries);
  515.  
  516.     for (node = ValidMemoryList.lh_Head; node->ln_Succ && (i < countentries); node = node->ln_Succ)
  517.     {
  518.         vmnode = (ValidMemoryNode *) node;
  519.  
  520.         Entries[i].se_obj_id.address = (APTR)(vmnode->vm_startaddress);
  521.  
  522.         sprintf(Entries[i].se_Entry, EntryAttr[MEMORYAREAS].ea_dataformat,
  523.                   vmnode->vm_startaddress,
  524.                   vmnode->vm_endaddress,
  525.               (char *)(IsValid(vmnode)        ? "VAL" : "INV"),
  526.               (char *)(IsWriteProtect(vmnode) ? "R/O" : "WRI"),
  527.               (char *)(IsCacheable(vmnode)    ? "CAC" : "NCA"),
  528.               vmnode->vm_comment);
  529.         i++;
  530.     }
  531.  
  532.     CreateEntryList(SORT, 0);
  533.  
  534.     PrintStatistics();
  535.  
  536.     return;
  537. }
  538.  
  539.