home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / rsyssrc.lha / RSysSummaryLists.c < prev    next >
C/C++ Source or Header  |  1993-09-19  |  14KB  |  540 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *      RSysSummaryLists.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    void MakeHardwareList ( void );
  12. *    void MakeMemoryList ( void );
  13. *    void MakeSystemList ( void );
  14. *
  15. *      --- Lokale  Routinen ---
  16. *
  17. *    static struct _hardwareentry *allocentry ( struct _hardwareentry *prev , char *title , char *info );
  18. *    static struct _hardwareentry *allochardwareentry ( struct _hardwareentry *prev , char *title , char *info );
  19. *    static struct _hardwareentry *allocnumhardwareentry ( struct _hardwareentry *prev , char *title , unsigned long num , int hex );
  20. *    static void CheckProcessors ( char *cpu , char *fpu , char *mmu );
  21. *    static void extract_comp ( UWORD manufactnr , UWORD prodnr , char *name , char *company , int type );
  22. *
  23. * Bemerkungen:
  24. *      Listen für Hardwarekonfiguration, Speicherlisten und Systemliste.
  25. *
  26. * Erstellungsdatum:
  27. *      25-Jun-93     Rolf Böhme
  28. *
  29. * Änderungen:
  30. *      25-Jun-93     Rolf Böhme      Erstellung
  31. *
  32. ***************************************************************************
  33. */
  34.  
  35. #include "RSys.h"
  36.  
  37. static struct _hardwareentry
  38. {
  39.     char    title[TITLELEN];
  40.     char    info[MAXSTRLEN];
  41.     struct _hardwareentry *next;
  42. }        firsthardwareentry =
  43.  
  44. {
  45.     "", "", NULL
  46. };
  47.  
  48. static struct Remember *Key = NULL;
  49.  
  50.     /*
  51.      * allochardwareentry() erzeugt einen Eintrag für die
  52.      * Hardwareliste
  53.      */
  54. static struct _hardwareentry *
  55. allochardwareentry(struct _hardwareentry *prev, char *title, char *info)
  56. {
  57.     struct _hardwareentry *new;
  58.  
  59.     if (new = (struct _hardwareentry *) AllocRemember((struct Remember **) & Key,
  60.                                                                       sizeof(struct _hardwareentry),
  61.                                                                       MEMF_CLEAR))
  62.     {
  63.         if (title) strncpy(new->title, title, TITLELEN);
  64.         else
  65.             strcpy(new->title, field[BLANK_FIELD]);
  66.  
  67.         if (info) strncpy(new->info, info, MAXSTRLEN);
  68.         else
  69.             new->info[0] = STRINGEND;
  70.  
  71.         prev->next = new;
  72.  
  73.         new->next = NULL;
  74.     }
  75.     else ErrorHandle(title, MEMORY_ERR, ALLOC_FAIL, KILL);
  76.  
  77.     return new;
  78. }
  79.  
  80.     /*
  81.      * allochardwareentry() erzeugt einen Eintrag für die
  82.      * Hardwareliste
  83.      */
  84. static struct _hardwareentry *
  85. allocentry(struct _hardwareentry *prev, char *title, char *info)
  86. {
  87.     struct _hardwareentry *new;
  88.  
  89.     if (new = (struct _hardwareentry *) AllocRemember((struct Remember **) & Key,
  90.                                                                       sizeof(struct _hardwareentry),
  91.                                                                       MEMF_CLEAR))
  92.     {
  93.         strncpy(new->title, title, TITLELEN);
  94.  
  95.         if (info) strncpy(new->info, info, MAXSTRLEN);
  96.         else
  97.             strcpy(new->info, "-");
  98.  
  99.         prev->next = new;
  100.  
  101.         new->next = NULL;
  102.     }
  103.     else ErrorHandle(title, MEMORY_ERR, ALLOC_FAIL, KILL);
  104.  
  105.     return new;
  106. }
  107.  
  108.     /*
  109.      * allocnumhardwareentry() erzeugt einen Zahleneintrag für die
  110.      * Hardwareliste
  111.      */
  112. static struct _hardwareentry *
  113. allocnumhardwareentry(struct _hardwareentry *prev, char *title,
  114.                              unsigned long num, int hex)
  115. {
  116.     struct _hardwareentry *new;
  117.  
  118.     if (new = (struct _hardwareentry *)AllocRemember((struct Remember **) & Key,
  119.                                                                      sizeof(struct _hardwareentry),
  120.                                                                      MEMF_CLEAR))
  121.     {
  122.         strncpy(new->title, title, TITLELEN);
  123.  
  124.         if (hex) sprintf(new->info, "0x%08lx", num);
  125.         else
  126.             sprintf(new->info, "%lD", num);
  127.  
  128.         prev->next = new;
  129.  
  130.         new->next = NULL;
  131.     }
  132.     else ErrorHandle(title, MEMORY_ERR, ALLOC_FAIL, KILL);
  133.  
  134.     return new;
  135. }
  136.  
  137. extern char **company_str;
  138. extern struct Manufacturer *manu;
  139.  
  140.     /*
  141.      * extract_comp() ermittelt einen Company-Namen und einen
  142.      * Produktnamen aus dem Manufacturer-Eintrag in der
  143.      * ExpansionBase
  144.      */
  145. static void
  146. extract_comp(UWORD manufactnr,UWORD prodnr,char *name,char *company, int type)
  147. {
  148.     register int i,j;
  149.    extern int hardwarecnt;
  150.  
  151.      strcpy(company,field[UNKNOWN_FIELD]);
  152.    strcpy(name,field[UNKNOWN_FIELD]);
  153.    type = -1;
  154.  
  155.    if(Flags.dummy1 == 0) return;
  156.  
  157.     for (i = 0; i < hardwarecnt; i++)
  158.         if (manu[i].manu_nr == manufactnr)
  159.         {
  160.             strncpy(company,company_str[ manu[i].company ],BUFSIZE);
  161.  
  162.             j = i;
  163.             while((manu[j].prod_nr != prodnr) && (manu[j].manu_nr == manufactnr)) j++;
  164.  
  165.             if((manu[j].prod_nr == prodnr) && (manu[j].manu_nr == manufactnr))
  166.          {
  167.             type = manu[j].type_nr;
  168.                 strncpy(name,manu[j].name,BUFSIZE);
  169.          }
  170.  
  171.             break;
  172.         }
  173.  
  174.     return;
  175. }
  176.  
  177. extern ULONG GetCPUType(void),GetFPUType(void),GetMMUType(void);
  178.  
  179.     /*
  180.      * CheckProcessors() prüft den Type der CPU, MMU und der FPU
  181.      * mit ein paar kleinen Assemblerroutinen, die ich aus dem
  182.      * Quelltext des Programmes SetCPU von D. Haynie geratzt habe
  183.      */
  184. static void
  185. CheckProcessors(char *cpu,char *fpu,char *mmu)
  186. {
  187.     ULONG _cpu = GetCPUType(),_fpu = GetFPUType(),_mmu = GetMMUType();
  188.  
  189.     sprintf(cpu,"CPU %ld",_cpu);
  190.  
  191.     if(_fpu != 0L) sprintf(fpu,"FPU %ld",_fpu);
  192.     else
  193.         strcpy(fpu,"None");
  194.  
  195.     if(_mmu != 0L) sprintf(mmu,"MMU %ld",_mmu);
  196.     else
  197.         strcpy(mmu,"None");
  198.  
  199.     return;
  200. }
  201.  
  202.     /*
  203.      * MakeHardwareList() erzeugt eine Anzeigeliste mit den
  204.      * Daten der Hardware-Ausstattung des Rechners, auf dem RSys
  205.      * läuft
  206.      */
  207. void
  208. MakeHardwareList(void)
  209. {
  210.     struct _hardwareentry *loop;
  211.     int    count = 0,
  212.             i;
  213.     UWORD type = SysBase->AttnFlags;
  214.     char    out[BUFSIZE],comp[BUFSIZE],name[BUFSIZE],
  215.           *titles[]=
  216.     {
  217.         /* 0 */ "Processor",
  218.         /* 1 */ "Coprocessor",
  219.         /* 2 */ "Memory Unit",
  220.         /* 3 */ "Denise",
  221.         /* 4 */ "Agnus",
  222.         /* 5 */ "Type",
  223.         /* 6 */ "Company",
  224.         /* 7 */ "Name",
  225.         /* 8 */ "Init Action",
  226.         /* 9 */ "Driver",
  227.         /* 10 */ "Priority",
  228.         /* 11 */ "Diagnosis",
  229.         /* 12 */ "Manuf.nr.",
  230.         /* 13 */ "Prod.nr.",
  231.         /* 14 */ "Serial",
  232.         /* 15 */ "Boardaddr.",
  233.         /* 16 */ "Boardsize",
  234.         /* 17 */ "Slotaddr.",
  235.         /* 18 */ "Slotsize",
  236.         /* 19 */ "           >",
  237.         /* 20 */ "Alice",
  238.         /* 21 */ "Lisa",
  239.         /* 22 */ "MLisa",
  240.         /* 23 */ "Chipset",
  241.       /* 24 */ "Manuf. type"
  242.     },cpu[3][10];
  243.     struct ConfigDev *lastboard = NULL;
  244.     struct ExpansionRom *expansionrom;
  245.    int manutype;
  246.     struct Node *devnode;
  247.  
  248.     DPOS;
  249.  
  250.     loop = allochardwareentry(&firsthardwareentry, "----- Hardware", NULL);
  251.  
  252.     CheckProcessors(cpu[0],cpu[1],cpu[2]);
  253.  
  254.     for(i = 0; i < 3; i++) loop = allochardwareentry(loop, titles[i], cpu[i]);
  255.  
  256.     if(GfxBase->ChipRevBits0 & GFXF_HR_DENISE)
  257.         loop = allochardwareentry(loop, titles[3], "ECS-Denise (8373)");
  258.     else
  259.         loop = allochardwareentry(loop, titles[3], "Normal Denise (8362)");
  260.  
  261.     if(GfxBase->ChipRevBits0 & GFXF_HR_AGNUS)
  262.         loop = allochardwareentry(loop, titles[4], "ECS-Agnus (8372)");
  263.     else
  264.         loop = allochardwareentry(loop, titles[4], "Normal Agnus");
  265.  
  266.     count += 6;
  267.  
  268.     if(GfxBase->ChipRevBits0 & (GFXF_AA_ALICE | GFXF_AA_LISA | GFXF_AA_MLISA))
  269.     {
  270.         if(GfxBase->ChipRevBits0 & GFXF_AA_ALICE)
  271.             loop = allochardwareentry(loop, titles[20], "AA-Alice");
  272.         else
  273.             loop = allochardwareentry(loop, titles[20], "Non AA-Alice");
  274.  
  275.         if(GfxBase->ChipRevBits0 & GFXF_AA_LISA)
  276.             loop = allochardwareentry(loop, titles[21], "AA-Lisa");
  277.         else
  278.             loop = allochardwareentry(loop, titles[21], "Non AA-Lisa");
  279.  
  280.         if(GfxBase->ChipRevBits0 & GFXF_AA_MLISA)
  281.             loop = allochardwareentry(loop, titles[22], "AA-MLisa");
  282.         else
  283.             loop = allochardwareentry(loop, titles[22], "Non AA-MLisa");
  284.  
  285.         count += 3;
  286.     }
  287.     else
  288.     {
  289.         loop = allochardwareentry(loop, titles[23], "No AA-Chipset");
  290.         count++;
  291.     }
  292.  
  293.     loop = allochardwareentry(loop, (char *)field[BLANK_FIELD], NULL);
  294.     loop = allochardwareentry(loop, "----- Expansion", NULL);
  295.  
  296.     count += 2;
  297.  
  298.     if (ExpansionBase = (struct ExpansionBase *) OpenLibrary((UBYTE *) "expansion.library", NULL))
  299.     {
  300.         int cnt = 0;
  301.  
  302.         while (lastboard = FindConfigDev(lastboard, -1L, -1L))
  303.         {
  304.             expansionrom = &(lastboard->cd_Rom);
  305.             if (expansionrom->er_Type & ERTF_MEMLIST)
  306.                 loop = allochardwareentry(loop, titles[5], "RAM Expansion");
  307.             else
  308.                 loop = allochardwareentry(loop, titles[5], "Other Expansion");
  309.  
  310.             extract_comp(expansionrom->er_Manufacturer, expansionrom->er_Product, name,comp, manutype);
  311.             loop = allochardwareentry(loop, titles[6], comp);
  312.             loop = allochardwareentry(loop, titles[7], name);
  313.  
  314.             count += 3;
  315.  
  316.             if (lastboard->cd_Flags & CDF_SHUTUP)
  317.             {
  318.                 loop = allochardwareentry(loop, titles[8], "No active");
  319.                 count++;
  320.             }
  321.  
  322.             if (lastboard->cd_Flags & CDF_CONFIGME)
  323.             {
  324.                 loop = allochardwareentry(loop, titles[8], "Need Driver");
  325.                 count++;
  326.             }
  327.  
  328.             if (lastboard->cd_Flags & CDF_BADMEMORY)
  329.             {
  330.                 loop = allochardwareentry(loop,titles[19], "Contains bad memory");
  331.                 count++;
  332.             }
  333.  
  334.             if (lastboard->cd_Flags & CDF_PROCESSED)
  335.             {
  336.                 loop = allochardwareentry(loop, titles[19], "Private processed");
  337.                 count++;
  338.             }
  339.  
  340.             if (devnode = (struct Node *) lastboard->cd_Driver)
  341.             {
  342.                 loop = allochardwareentry(loop, titles[9], devnode->ln_Name);
  343.                 loop = allocnumhardwareentry(loop, titles[10],
  344.                                                       (unsigned long)devnode->ln_Pri,
  345.                                                       FALSE);
  346.                 count += 2;
  347.             }
  348.  
  349.             if (expansionrom->er_Flags & ERTF_DIAGVALID)
  350.                 loop = allochardwareentry(loop, titles[11], "Action attached");
  351.             else
  352.                 loop = allochardwareentry(loop, titles[11], "No action attached");
  353.  
  354.             loop = allocnumhardwareentry(loop, titles[12],
  355.                                     (unsigned long)expansionrom->er_Manufacturer, FALSE);
  356.             loop = allocnumhardwareentry(loop, titles[13],
  357.                                     (unsigned long)expansionrom->er_Product, FALSE);
  358.             loop = allocnumhardwareentry(loop, titles[14],
  359.                                     (unsigned long)expansionrom->er_SerialNumber,TRUE);
  360.             loop = allocnumhardwareentry(loop, titles[24],
  361.                            (unsigned long)manutype,FALSE);
  362.             loop = allocnumhardwareentry(loop, titles[15],
  363.                                     (unsigned long)lastboard->cd_BoardAddr, TRUE);
  364.             loop = allocnumhardwareentry(loop, titles[16],
  365.                                     (unsigned long)lastboard->cd_BoardSize, FALSE);
  366.             loop = allocnumhardwareentry(loop, titles[17],
  367.                                     (unsigned long)lastboard->cd_SlotAddr, TRUE);
  368.             loop = allocnumhardwareentry(loop, titles[18],
  369.                                     (unsigned long)lastboard->cd_SlotSize, FALSE);
  370.  
  371.             loop = allochardwareentry(loop, (char *)field[BLANK_FIELD], NULL);
  372.  
  373.             count += 10;
  374.  
  375.             cnt++;
  376.         }
  377.  
  378.         sprintf(out,"%ld expansions found",cnt);
  379.         loop = allochardwareentry(loop, "Summary", out);
  380.         count++;
  381.  
  382.         CloseLibrary((struct Library *) ExpansionBase);
  383.     }
  384.     else ErrorHandle("expansion.library", LIBRARY_ERR, OPEN_FAIL, NO_KILL);
  385.  
  386.     countentries = count;
  387.  
  388.     Entries = AllocScrollEntries(countentries);
  389.  
  390.     loop = firsthardwareentry.next;
  391.     i = 0;
  392.  
  393.     while (loop && (i < countentries))
  394.     {
  395.         if (loop->info[0]) sprintf(Entries[i].se_Entry, "%-13s : %s", loop->title, loop->info);
  396.         else
  397.             strncpy(Entries[i].se_Entry, loop->title, BUFSIZE);
  398.  
  399.         i++;
  400.  
  401.         loop = loop->next;
  402.     }
  403.  
  404.     FreeRemember((struct Remember **) & Key, TRUE);
  405.  
  406.     CreateEntryList(NO_SORT, 0);
  407.  
  408.     PrintInfo("Hardwarelist read", SPEAK, 0);
  409.  
  410.     return;
  411. }
  412.  
  413.     /*
  414.      * MakeMemoryList() erzeugt eine Liste der Speichereinträge mit
  415.      * allen Fragmentierungen
  416.      */
  417. void
  418. MakeMemoryList(void)
  419. {
  420.     register int i = 3;
  421.     register struct MemChunk *Loop;
  422.     register struct MemHeader *MemHeader;
  423.     char    cattype[MEMTYPELEN],type[5];
  424.     ULONG BlockSize = 0L, MemSize;
  425.  
  426.     DPOS;
  427.  
  428.     countentries = CountMemory() + 3;
  429.  
  430.     if (NoEntries()) return;
  431.  
  432.     Entries = AllocScrollEntries(countentries);
  433.  
  434.     Forbid();
  435.  
  436.     for (MemHeader = (struct MemHeader *) SysBase->MemList.lh_Head;
  437.           MemHeader->mh_Node.ln_Succ && (i < countentries);
  438.           MemHeader = (struct MemHeader *) MemHeader->mh_Node.ln_Succ)
  439.     {
  440.         MemSize = ((ULONG) MemHeader->mh_Upper - (ULONG)MemHeader->mh_Lower);
  441.         BlockSize += MemSize;
  442.  
  443.         if (MemHeader->mh_Attributes & MEMF_CHIP) strcpy(type, "CHIP");
  444.         else if (MemHeader->mh_Attributes & MEMF_FAST) strcpy(type, "FAST");
  445.         else
  446.             strcpy(type, field[NO_TYPE]);
  447.  
  448.         strncpy(cattype, type, MEMTYPELEN);
  449.  
  450.       Entries[i].se_obj_id.address = MemHeader;
  451.         sprintf(Entries[i].se_Entry, EntryAttr[MEMORY].ea_dataformat,
  452.                   (ULONG) MemHeader, MemSize, type);
  453.  
  454.         i++;
  455.  
  456.         for (Loop = MemHeader->mh_First; Loop && (i < countentries);
  457.               Loop = Loop->mc_Next)
  458.         {
  459.             strncpy(cattype, type, MEMTYPELEN);
  460.             strcat(cattype, "-CHUNK");
  461.  
  462.          Entries[i].se_obj_id.address = Loop;
  463.             sprintf(Entries[i].se_Entry, EntryAttr[MEMORY].ea_dataformat,
  464.                       (ULONG) Loop, Loop->mc_Bytes, cattype);
  465.             i++;
  466.         }
  467.     }
  468.  
  469.     Permit();
  470.  
  471.     sprintf(Entries[0].se_Entry, "Total  : %8ld C:%8ld F:%8ld",
  472.               BlockSize, AvailMem(MEMF_CHIP), AvailMem(MEMF_FAST));
  473.  
  474.     sprintf(Entries[1].se_Entry, "Largest: %8s C:%8ld F:%8ld",
  475.               field[BLANK_FIELD], AvailMem(MEMF_CHIP | MEMF_LARGEST),
  476.               AvailMem(MEMF_FAST | MEMF_LARGEST));
  477.  
  478.     strcpy(Entries[2].se_Entry,"-------------- Fragmentation --------------");
  479.  
  480.     CreateEntryList(NO_SORT, 0);
  481.  
  482.     return;
  483. }
  484.  
  485.     /*
  486.      * MakeSystemList() gibt eine Kurzinfo über das laufende System
  487.      */
  488. void
  489. MakeSystemList(void)
  490. {
  491.     int    count = 0;
  492.     long timeptr;
  493.     struct tm tm, *tmhelp = &tm;
  494.  
  495.     DPOS;
  496.  
  497.     countentries = 10;
  498.     Entries = AllocScrollEntries(countentries);
  499.  
  500.     timeptr = time(NULL);
  501.     tmhelp = localtime((time_t *) & timeptr);
  502.  
  503.     sprintf(Entries[count++].se_Entry, "%02ld.%02ld.%ld, %3ld. day, %2ld. week",
  504.               tmhelp->tm_mday, tmhelp->tm_mon + 1, (1900 + tmhelp->tm_year),
  505.               tmhelp->tm_yday + 1, (int)((tmhelp->tm_yday + 1) / 7) + 1);
  506.  
  507.     sprintf(Entries[count++].se_Entry, "Tasks       : %ld",
  508.               CountNodes(&SysBase->TaskWait) + CountNodes(&SysBase->TaskReady) + 1);
  509.  
  510.     sprintf(Entries[count++].se_Entry, "Libraries   : %ld",
  511.               CountNodes(&SysBase->LibList));
  512.  
  513.     sprintf(Entries[count++].se_Entry, "Ports       : %ld",
  514.               CountNodes(&SysBase->PortList));
  515.  
  516.     sprintf(Entries[count++].se_Entry, "Volumes     : %ld",
  517.               CountDevices(LDF_VOLUMES));
  518.  
  519.     sprintf(Entries[count++].se_Entry, "Assigns     : %ld",
  520.               CountDevices(LDF_ASSIGNS));
  521.  
  522.     sprintf(Entries[count++].se_Entry, "Fonts       : %ld",
  523.               CountNodes(&GfxBase->TextFonts));
  524.  
  525.     sprintf(Entries[count++].se_Entry, "Resources   : %ld",
  526.               CountNodes(&SysBase->ResourceList));
  527.  
  528.     sprintf(Entries[count++].se_Entry, "Windows     : %ld",
  529.               CountIntuiObjects((int)WINDOWS));
  530.  
  531.     sprintf(Entries[count++].se_Entry, "Screens     : %ld",
  532.               CountIntuiObjects((int)SCREENS));
  533.  
  534.     CreateEntryList(NO_SORT, 0);
  535.  
  536.     PrintInfo("Systeminfo read", SPEAK, 0);
  537.  
  538.     return;
  539. }
  540.