home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / ps.zip / ps.c < prev    next >
C/C++ Source or Header  |  1993-08-26  |  18KB  |  578 lines
  1. /****************************************************************
  2.  *
  3.  *  Dieses Programm ersetzt das von IBM mitgelieferte pstat.
  4.  *  Es ist aber möglich mehr Angaben auszugegeben bzw die Ausgaben
  5.  *  auf wesentlich Merkmale zu reduzieren.
  6.  *  Author: Ralf Seidel
  7.  *  email: rauh@wrcd1.uni-wuppertal.de
  8.  *  subject: fuer Ralf
  9.  *
  10.  *  This Program replaces pstat deliverd with the OS/2 package. 
  11.  *  It has some more options and alows the output to be more brief.
  12.  *  All comments are written in german, because I don't expect 
  13.  *  much interrest.
  14.  *  I developed it using EMX GCC but it may be possible to use other
  15.  *  compilers though I could not test this by myself.
  16.  *  Author: Ralf Seidel
  17.  *  email: rauh@wrcd1.uni-wuppertal.de
  18.  *  subject: for Ralf
  19.  ****************************************************************/
  20. #include <stdio.h>
  21. #include <strings.h>
  22. #include <malloc.h>
  23. #include <ctype.h>
  24. #define INCL_DOSERRORS
  25. #define INCL_DOSPROCESS
  26. #include <os2.h>
  27. #include "ps.h"
  28.  
  29. #define RC_OK 0                 /* return codes */
  30. #define RC_ERR 1
  31.  
  32. /*
  33. #define SHOW_UNKNOWN_HEADER 
  34. #define SHOW_UNKNOWN_PROCESS
  35. #define SHOW_UNKNOWN_THREAD  
  36. #define SHOW_UNKNOWN_SEM     
  37. #define SHOW_UNKNOWN_MODULS
  38. */
  39.  
  40. /* Funktionen */
  41.  
  42. #ifndef __EMX__
  43. /* Diese Funktion dubliziert den ihr übergebenen ASCIIZ String */
  44. /* Sie allociert dafür mittels malloc() den benötigten Platz und */
  45. /* kopiert dann bei Erfolg von malloc() den übergebenen String mit */
  46. /* den Befehl memcpy */
  47. char *strdup( char *string )
  48. {
  49.    char *p;
  50.    size_t n;
  51.    n = strlen( string ) + 1;
  52.    if ( p = (char*) malloc( n )) != NULL )
  53.       (char *)memcpy( p, string, n );
  54.    return p;
  55. }
  56. #endif
  57.  
  58.  
  59. /* Ausgabe einer kurzen Mitteilung bei falschen Parametern */
  60. void ShowUsage()
  61. {
  62.    fprintf( stderr, "Fehler bei den Komandooptionen\n" );
  63.    fprintf( stderr, "Gültige Optionen sind: ?ABCHMOT\n" );
  64.    exit( RC_ERR );
  65. }
  66.  
  67. /* Ausgabe der Hilfestellung */
  68. void ShowHelp()
  69. {
  70.    printf( "Optionen sind:\n" );
  71.    printf( "\tH : Anzeigen von allgemeinen Informationen\n" );
  72.    printf( "\tC : Anzeigen von Prozeßinformationen\n" );
  73.    printf( "\tT : Anzeigen von Prozeß- und Threadinformationen\n" );
  74.    printf( "\tO : Anzeigen von Modulen im System\n" );
  75.    printf( "\tM : Anzeigen von Informationen über 'shared Memory'\n" );
  76.    printf( "\tS : Anzeigen von Systemsemaphoren\n" );
  77.    printf( "\tA : Anzeigen aller Angaben (default)\n" );
  78.    printf( "\tB : Kurzanzeige\n" );
  79.    printf( "Bei der Verwendung der Option B werden die Angaben " \
  80.            "verkürzt ausgeben:\n" );
  81.    exit( RC_OK );
  82. }
  83.  
  84. /* Ausgabe der allgemeinen Angaben */
  85. void ShowSum( PBUFFHEADER pBufHead )
  86. {
  87.    PSUMMARY pProcSum;
  88.  
  89.    printf( "\nAllgemeine Angaben:\n" );
  90.    pProcSum = pBufHead->psumm;
  91.    printf( "Anzahl der Prozesse(?)\t: %.8x\n", pProcSum->ulProcCt );
  92.    printf( "Anzahl der Threads\t: %.8x\n",
  93.            pProcSum->ulThreadCt );
  94.    printf( "Geöffnete Dateien\t: %.8x\n", pProcSum->ulOpenFileCt );
  95. #ifdef SHOW_UNKNOWN_HEADER
  96.    printf( "Unknown1: %.8x\n", pBufHead->pUnknown1 );
  97.    printf( "Unknown2: %.8x\n", pBufHead->pUnknown2 );
  98.    printf( "Unknown3: %.8x\n", pBufHead->pUnknown3 );
  99. #endif /* SHOW_UNKNOWN_HEADER */
  100. } 
  101.  
  102. /* Ausgabe der Processinformationen */
  103. void ShowProc( PBUFFHEADER pBufHead, \
  104.                BOOL fShowThread, BOOL fShowBrief )
  105. {
  106.    typedef struct _MODLIST
  107.    {
  108.       struct _MODLIST *pNext;
  109.       USHORT   hMod;            /* Interne Kennung */
  110.       PSZ      pModName;        /* Name des Moduls */
  111.    } MODLIST, *PMODLIST;
  112.  
  113.    PPROCESSINFO pProcInfo;
  114.    PTHREADINFO pThreadInfo;
  115.    PMODINFO pModInfo;
  116.    PMODLIST pModList;
  117.    PMODLIST pmli;
  118. /*   PUSHORT pusi; */
  119.  
  120.    printf( "\n\t\tProzeßinformationen\n\n" );
  121.  
  122.    /* Erstellung der Liste mit den Modulnamen */
  123.  
  124.    if (( pModList = (PMODLIST) malloc( sizeof (MODLIST) )) == NULL )
  125.    {
  126.       fprintf(stderr, "malloc: memory exhausted in %s at %d\n", \
  127.               __FILE__, __LINE__ );
  128.       exit( RC_ERR );
  129.    }
  130.    pmli = pModList;
  131.    for ( pModInfo = pBufHead->pmi; pModInfo != NULL;
  132.          pModInfo = pModInfo->pNext )
  133.    {
  134.    if (( pmli->pModName = (CHAR *)strdup(pModInfo->szModName )) == NULL )
  135.    {
  136.       fprintf(stderr, "strdup: memory exhausted in %s at %d\n",
  137.               __FILE__, __LINE__ );
  138.       exit( RC_ERR );
  139.    } /* endif */
  140.       pmli->hMod = pModInfo->hMod;
  141.       if ( (pmli->pNext = (PMODLIST) malloc( sizeof (MODLIST) )) == NULL )
  142.       {
  143.          fprintf(stderr, "malloc: memory exhausted in %s at %d\n",
  144.                  __FILE__, __LINE__ );
  145.          exit( RC_ERR );
  146.       }
  147.       pmli = pmli->pNext;
  148.       pmli->pNext = NULL;
  149.    }
  150.  
  151.    /* Ausgabe der Prozeßinformationen */
  152.  
  153.    printf( "PID  (dez)\tModulname\n" );
  154.    if ( fShowBrief == FALSE )
  155.       printf( "\tPPID\tSID\tKennung\tSession Typ\n");
  156.    if ( fShowThread == TRUE )
  157.    {
  158.       printf( "Threadinfos:\n" );
  159.       printf( "\tProcID\tSysID\tBlockID\t\tPrio.\tZähler 1 & 2\t" );
  160.       printf( "Status\n" );
  161.    } /* endif fShowThread */
  162.    pProcInfo = pBufHead->ppi;
  163.    while ( pProcInfo->ulEndFlag != PROCINFO_ENDFLAG )
  164.    {
  165.       if ( pProcInfo->ulEndFlag != PROCINFO_CONTFLAG )
  166.       {
  167.          fprintf( stderr,
  168.                   "Unerwarteter Wert in der Prozessinfolist: %d\n",
  169.                   pProcInfo->ulEndFlag );
  170.          exit( RC_ERR );
  171.       } /* endif */
  172.  
  173.       /* Finden des zum Prozeß dazugehörigen Moduls */
  174.  
  175.       pmli = pModList;
  176.       while ( (pmli != NULL) && (pmli->hMod != pProcInfo->hModRef) )
  177.          pmli = pmli->pNext;
  178.       printf( "%.4x (%d)\t", pProcInfo->pid, pProcInfo->pid );
  179.       if ( pmli == NULL )
  180.          printf( "Name nicht gefunden!\n" );
  181.       else
  182.          printf( "%s\n", pmli->pModName );
  183.       if ( fShowBrief == FALSE )
  184.       {
  185.          printf( "\t%.2x\t", pProcInfo->pidParent );
  186.          printf( "%.2x\t", pProcInfo->sid );
  187.          printf( "%.4x\t", pProcInfo->hModRef );
  188.          printf( "%d : ",pProcInfo->usSessionType );
  189.          switch( pProcInfo->usSessionType )
  190.          {
  191.          case SSF_TYPE_DEFAULT:
  192.             printf("System\n");
  193.             break;
  194.          case SSF_TYPE_FULLSCREEN:
  195.             if ( pProcInfo->hModRef == 0 )
  196.                printf( "DOS\n" );
  197.             else
  198.                printf( "OS/2 FS\n" );
  199.             break;
  200.          case SSF_TYPE_WINDOWABLEVIO:
  201.             printf( "OS/2 Window\n" );
  202.             break;
  203.          case SSF_TYPE_PM:
  204.             printf( "PM\n" );
  205.             break;
  206.          case SSF_TYPE_VDM:
  207.             printf( "Detached\n" );
  208.             break;
  209. /* Folgende Typen werden noch in os.h deklariert aber nie benutzt */
  210. /*       case SSF_TYPE_GROUP:   
  211.             printf( "Gruppe\n" );
  212.             break;
  213.          case SSF_TYPE_DLL:
  214.             printf( "DLL\n" );
  215.             break;
  216.          case SSF_TYPE_WINDOWEDVDM:
  217.             printf( "Virtual DOS (Window)\n" );
  218.             break;
  219.          case SSF_TYPE_PDD:
  220.             printf( "PDD\n" );
  221.             break;
  222.          case SSF_TYPE_VDD:
  223.             printf( "VDD\n" );
  224.             break; */
  225.          default:
  226.             printf( "Unbekannt (Fehler ?)\n" );
  227.          } /* endswitch */
  228. #ifdef SHOW_UNKNOWN_PROCESS
  229.          printf( "Unknown1: %4x\n", pProcInfo->usUnknown1 );
  230.          printf( "Unknown2: %4x\n", pProcInfo->usUnknown2 );
  231.          printf( "Unknown3: %4x\n", pProcInfo->usUnknown3 );
  232.          printf( "Unknown4: %4x\n", pProcInfo->usUnknown4 );
  233.          printf( "Unknown5: %4x\n", pProcInfo->usUnknown5 );
  234.          printf( "Unknown6: %4x\n", pProcInfo->usUnknown6 );
  235.          printf( "Unknown7: %4x\n", pProcInfo->usUnknown7 );
  236.          printf( "Unknown8: %4x\n", pProcInfo->usUnknown8 );
  237.          printf( "Unknown9: %4x\n", pProcInfo->usUnknown9 );
  238. #endif
  239.       } /* endif fShowBrief */
  240.       /* Ausgabe der zugehörigen Thread Informationen */
  241.       if ( fShowThread == TRUE )
  242.       {
  243.          pThreadInfo = pProcInfo->ptiFirst;
  244.          for ( pThreadInfo = pProcInfo->ptiFirst;
  245.                pThreadInfo < pProcInfo->ptiFirst
  246.                              + pProcInfo->usThreadCt;
  247.                pThreadInfo++ )
  248.          {
  249.             printf( "\t%.2x\t", pThreadInfo->usProcTid );
  250.             printf( "%.2x\t", pThreadInfo->usSysTid );
  251.             printf( "%.8x\t", pThreadInfo->ulBlockId );
  252.             printf( "%.4x\t", pThreadInfo->usPriority );
  253.             printf( "%.4x\t", pThreadInfo->ulExecCt1 );
  254.             printf( "%.4x\t", pThreadInfo->ulExecCt2 );
  255.             printf( "%d : ", pThreadInfo->usThreadStat );
  256.             switch ( pThreadInfo->usThreadStat )
  257.             {
  258.             case 1:
  259.                printf( "ready\n" );
  260.                break;
  261.             case 2:
  262.                printf( "blocked\n" );
  263.                break;
  264.             case 5:
  265.                printf( "running\n" );
  266.                break;
  267.             case 9:
  268.                printf( "frozen\n" );
  269.                break;
  270.             default:
  271.                printf( "unbekannt\n" );
  272.             } /* endswitch */
  273. #ifdef SHOW_UNKNOWN_THREAD
  274.             printf( "Unknown1: %.4x\n", pThreadInfo->usUnknown1 );
  275.             printf( "Unknown2: %.4x\n", pThreadInfo->usUnknown2 );
  276.             printf( "Unknown3: %.4x\n", pThreadInfo->usUnknown3 );
  277.             printf( "Unknown4: %.4x\n", pThreadInfo->usUnknown4 );
  278. #endif
  279.          } /* endif fShowThread */
  280.       } /* endfor */
  281.       pProcInfo = (PPROCESSINFO)
  282.                   ( pProcInfo->ptiFirst + pProcInfo->usThreadCt );
  283.    } /* endwhile */
  284.    printf( "\n" );
  285. } /* end ShowProc */
  286.  
  287. /* Ausgabe der Informationen über Semaphoren */
  288. void ShowSem( PBUFFHEADER pBufHead, BOOL fShowBrief )
  289. {
  290.    PSEMINFO pSemInfo;
  291.  
  292.    printf( "\n\t\tSystemsemaphoren\n\n" );
  293.    printf( "Semaphorenname\n" );
  294.    if ( fShowBrief == FALSE )
  295.    {
  296.       printf( "\tEigner\t\tAnzahl\t\tAnzahl\n" );
  297.       printf( "\tThread" );
  298.       printf( "\tIndex" );
  299.       printf( "\tVerweise" );
  300.       printf( "\tAnforderungen" );
  301.       printf( "\tFlags\n" );
  302.    } /* endif fShowBrief */
  303.    for (pSemInfo = (PSEMINFO)((char*)pBufHead->psi + 0x10);
  304.         pSemInfo != NULL && pSemInfo->usIndex != 0;
  305.         pSemInfo = pSemInfo->pNext )
  306.    {
  307.       printf( "%s\n", pSemInfo->szSemName );
  308.       if ( fShowBrief == FALSE )
  309.       {
  310.          if ( pSemInfo->usOwner != 0 )
  311.             printf( "\t%.4x", pSemInfo->usOwner );
  312.          else
  313.             printf( "\t" );
  314.          printf( "\t%.4x", pSemInfo->usIndex );
  315.          printf( "\t%.2x\t", pSemInfo->uchRefCt );
  316.          printf( "\t%.2x\t", pSemInfo->uchRequestCt );
  317.          printf( "\t%.2x\n", pSemInfo->uchFlag );
  318. #ifdef SHOW_UNKNOWN_SEM
  319.          printf( "Unknown1: %.2x\t", pSemInfo->uchUnknown1 );
  320.          printf( "Unknown2: %.4x\t", pSemInfo->usUnknown2 );
  321.          printf( "Unknown3: %.4x\n", pSemInfo->usUnknown3 );
  322. #endif
  323.       } /* endif fShowBrief */
  324.    } /* endfor fShowBrief */
  325.    printf( "\n" );
  326. } /* end ShowSem */
  327.  
  328. /* Ausgabe der Informationen über shared memory */
  329. void ShowMem ( PBUFFHEADER pBufHead, BOOL fShowBrief )
  330. {
  331.    PSHRMEMINFO pShrMemInfo;
  332.  
  333.    printf( "\n\t\tGemeinsam benutzter Speicher\n\n" );
  334.    printf( "Name des Speichers\n" );
  335.    if ( fShowBrief == FALSE )
  336.    {
  337.       printf( "\tInterne Kennung\t\tAnzahl der Verweise\tSelektor\n" );
  338.    } /* endif fShowBrief */
  339.    for ( pShrMemInfo = pBufHead->psmi;
  340.          pShrMemInfo != NULL && pShrMemInfo->selMem != 0;
  341.          pShrMemInfo = pShrMemInfo->pNext )
  342.    {
  343.       printf( "%s\n", pShrMemInfo->szMemName );
  344.       if ( fShowBrief == FALSE )
  345.       {
  346.          printf( "\t%.4x\t\t", pShrMemInfo->usMemHandle);
  347.          printf( "\t%.4x\t\t", pShrMemInfo->usRefCt );
  348.          printf( "\t%.4x\n", pShrMemInfo->selMem );
  349.       } /* endif fShowBrief */
  350.    } /* endfor pShrMemInfo */
  351.    printf( "\n" );
  352. } /* end ShowMem */
  353.  
  354. /* Ausgabe der Informationen über geladene Module */
  355. void ShowMod( PBUFFHEADER pBufHead, BOOL fShowBrief )
  356. {
  357.    PMODINFO pModInfo;
  358.    USHORT *pModRef;
  359.    INT i;
  360.  
  361.    printf( "Geladene Module im System:\n\n" );
  362.    printf( "Modulname\n" );
  363.    if ( fShowBrief == FALSE )
  364.    {
  365.       printf( "\t\t\tInterne\t\tAnzahl\t\tAnzahl\n" );
  366.       printf( "\tModultyp\t" );
  367.       printf( "Kennung\t\t" );
  368.       printf( "Verweise\t" );
  369.       printf( "Segmente\n" );
  370.       printf( "Kennungen von referenzierten Modulen\n" );
  371.    } /* endif fShowBrief */
  372.    for ( pModInfo = pBufHead->pmi; pModInfo != NULL;
  373.          pModInfo = pModInfo->pNext )
  374.    {
  375.       printf( "%s\n", pModInfo->szModName );
  376.       if ( fShowBrief == FALSE )
  377.       {
  378.          printf( "\t%d = %s\t", pModInfo->usMemModel,
  379.                  (pModInfo->usMemModel == 0)?"16 Bit":"32 Bit");
  380.          printf( "%.4x\t\t", pModInfo->hMod );
  381.          printf( "%.4x\t\t", pModInfo->ulRefCt );
  382.          printf( "%.4x\n", pModInfo->ulSegCt );
  383.          pModRef = pModInfo-> usModRef;
  384.          for ( i = 0; i < pModInfo->ulRefCt; i++ )
  385.             printf( "%.4x\t", *pModRef++ );
  386.          printf( "\n" );
  387. #ifdef SHOW_UNKNOWN_MODULS
  388.             printf( "Unnkown1: %.8x\n", pModInfo->ulUnknown1 );
  389. #endif
  390.       } /* endif fShowBrief */
  391.    } /* endfor */
  392. } /* end ShowMod */
  393.  
  394.  
  395. /* HAUPTPROGRAMM */
  396.  
  397. int main(int argc, char *argv[], char *envp[])
  398. {
  399.    /* Variablen für die Systeminformationen */
  400.    PBUFFHEADER pBufHead;
  401.    USHORT usRetCode;
  402.    USHORT usBufSize = PROCINFO_BUF_SIZE;
  403.  
  404.    /* Variablen für die Ausgabeoptionen */
  405.    BOOL fShowSum = TRUE;
  406.    BOOL fShowProc = TRUE;
  407.    BOOL fShowThread = TRUE;
  408.    BOOL fShowSem = TRUE;
  409.    BOOL fShowMem = TRUE;
  410.    BOOL fShowMod = TRUE;
  411.    BOOL fShowBrief = FALSE;
  412.  
  413.    /* Variablen für die Parameterauswertung */
  414.    PSZ szParam;
  415.  
  416.    /* Sonstige Variablen */
  417.    INT i;
  418.  
  419.    /* Auswertung der Kommandozeile */
  420.  
  421.    /* Ausgabe des Programmnamens */
  422.    printf( "%s : (c) Ralf Seidel 2/93\n", argv[0] );
  423.    for (i = 1; i < argc; i++)
  424.    {
  425.       for ( szParam = argv[i]; *szParam != '\0'; szParam++ )
  426.       {
  427.          switch ( toupper( *szParam ))
  428.          {
  429.          case '-':
  430.          case '/':
  431.             break;
  432.          case '?':
  433.             ShowHelp();
  434.             break;
  435.          case 'B':
  436.             fShowBrief = TRUE;
  437.             break;
  438.          case 'C':
  439.             if ( fShowProc == TRUE )
  440.             {
  441.                fShowSum = FALSE;
  442.                fShowThread = FALSE;
  443.                fShowSem = FALSE;
  444.                fShowMem = FALSE;
  445.                fShowMod = FALSE;
  446.             }
  447.             else
  448.                fShowProc = TRUE;
  449.             /* endif */
  450.             break;
  451.          case 'T':
  452.             if ( fShowThread == TRUE )
  453.             {
  454.                fShowSum = FALSE;
  455.                fShowSem = FALSE;
  456.                fShowMem = FALSE;
  457.                fShowMod = FALSE;
  458.             }
  459.             else
  460.             {
  461.                fShowProc = TRUE;
  462.                fShowThread = TRUE;
  463.             } /* endif */
  464.             break;
  465.          case 'H':
  466.             if ( fShowSum == TRUE )
  467.             {
  468.                fShowProc = FALSE;
  469.                fShowThread = FALSE;
  470.                fShowSem = FALSE;
  471.                fShowMem = FALSE;
  472.                fShowMod = FALSE;
  473.             }
  474.             else
  475.                fShowSum = TRUE;
  476.             /* endif fShowSum */
  477.             break;
  478.          case 'S':
  479.             if ( fShowSem == TRUE )
  480.             {
  481.                fShowSum = FALSE;
  482.                fShowProc = FALSE;
  483.                fShowThread = FALSE;
  484.                fShowMem = FALSE;
  485.                fShowMod = FALSE;
  486.             }
  487.             else
  488.                fShowSem = TRUE;
  489.             /* endif fShowSem */
  490.             break;
  491.          case 'M':
  492.             if ( fShowMem == TRUE )
  493.             {
  494.                fShowSum = FALSE;
  495.                fShowProc = FALSE;
  496.                fShowThread = FALSE;
  497.                fShowSem = FALSE;
  498.                fShowMod = FALSE;
  499.             }
  500.             else
  501.                fShowMem = TRUE;
  502.             /* endif fShowMem */
  503.             break;
  504.          case 'L':
  505.          case 'O':
  506.             if ( fShowMod == TRUE )
  507.             {
  508.                fShowSum = FALSE;
  509.                fShowProc = FALSE;
  510.                fShowThread = FALSE;
  511.                fShowSem = FALSE;
  512.                fShowMem = FALSE;
  513.             }
  514.             else
  515.                fShowMod = TRUE;
  516.             /* endif */
  517.             break;
  518.          case 'A':
  519.             fShowSum = TRUE;
  520.             fShowProc = TRUE;
  521.             fShowThread = TRUE;
  522.             fShowSem = TRUE;
  523.             fShowMem = TRUE;
  524.             fShowMod = TRUE;
  525.             break;
  526. /*       case 'P':
  527.             break;*/
  528.          default: 
  529.             ShowUsage();
  530.          } /* endswitch */
  531.       } /* endfor szParam */
  532.    } /* endfor i */
  533.    if (( pBufHead = (PBUFFHEADER) malloc( (size_t)usBufSize)) == NULL )
  534.    {
  535.       fprintf(stderr, "malloc: memory exhausted in %s at %d\n", \
  536.                        __FILE__, __LINE__ );
  537.       exit(RC_ERR);
  538.    }
  539. #ifdef __EMX__
  540.    _THUNK_PROLOG(4 + 2);
  541.    _THUNK_FLAT(pBufHead);
  542.    _THUNK_SHORT(usBufSize);
  543.    usRetCode = (USHORT) _THUNK_CALL( DosQProcStatus );
  544. #else
  545.    usRetCode = DosQProcStatus( pBufHead, usBufSize );
  546. #endif
  547.    switch ( usRetCode )
  548.    {
  549.    case NO_ERROR:
  550.       break;
  551.    case ERROR_BUFFER_OVERFLOW:
  552.       fprintf( stderr, "DosQProcStatus: Datenbuffer zu klein\n" );
  553.       fprintf( stderr, "Buffergröße ändern und neu compilieren\n" );
  554.       exit( RC_ERR );
  555.    default:
  556.       fprintf( stderr, "DosQProcStatus: Errorcode %d", usRetCode );
  557.       exit( RC_ERR );
  558.    } /* endswitch */
  559.  
  560.    /* Ausgabe des Bufferheaders" */
  561.    if ( fShowSum == TRUE ) 
  562.       ShowSum( pBufHead );
  563.    /* Ausgabe der Prozeßinformationen */
  564.    if ( fShowProc == TRUE )
  565.       ShowProc( pBufHead, fShowThread, fShowBrief );
  566.    /* Ausgabe der Informationen über Semaphoren */
  567.    if ( fShowSem == TRUE )
  568.       ShowSem( pBufHead, fShowBrief );
  569.    /* Ausgabe der Informationen über "shared memory" */
  570.    if ( fShowMem == TRUE )
  571.       ShowMem( pBufHead, fShowBrief );
  572.    /* Ausgabe der Informationen über geladene Module */
  573.    if ( fShowMod == TRUE )
  574.       ShowMod( pBufHead, fShowBrief );
  575.    return RC_OK;
  576. }
  577.  
  578.