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