ps.c

Go to the documentation of this file.

/*
 *  ReactOS ps - process list console viewer
 *
 *  ps.c
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
/*
    Thanks to Filip Navara patch for fixing the Xp crash problem.
*/
 
#define NTOS_MODE_USER
#define WIN32_NO_STATUS
#include <windows.h>
#include <ndk/ntndk.h>
 
typedef struct _SYSTEM_THREADS
 {
    LARGE_INTEGER KernelTime;
    LARGE_INTEGER UserTime;
    LARGE_INTEGER CreateTime;
    ULONG WaitTime;
    PVOID StartAddress;
    CLIENT_ID ClientId;
    KPRIORITY Priority;
    LONG BasePriority;
    ULONG ContextSwitches;
    ULONG ThreadState;
    ULONG WaitReason;
 } SYSTEM_THREADS, *PSYSTEM_THREADS;
 
 typedef struct _SYSTEM_PROCESSES
 {
    ULONG NextEntryOffset;
    ULONG NumberOfThreads;
    LARGE_INTEGER SpareLi1;
    LARGE_INTEGER SpareLi2;
    LARGE_INTEGER SpareLi3;
    LARGE_INTEGER CreateTime;
    LARGE_INTEGER UserTime;
    LARGE_INTEGER KernelTime;
    UNICODE_STRING ImageName;
    KPRIORITY BasePriority;
    HANDLE UniqueProcessId;
    HANDLE InheritedFromUniqueProcessId;
    ULONG HandleCount;
    ULONG SessionId;
    ULONG PageDirectoryFrame;
 
    /*
     * This part corresponds to VM_COUNTERS_EX.
     * NOTE: *NOT* THE SAME AS VM_COUNTERS!
     */
    ULONG PeakVirtualSize;
    ULONG VirtualSize;
    ULONG PageFaultCount;
    ULONG PeakWorkingSetSize;
    ULONG WorkingSetSize;
    ULONG QuotaPeakPagedPoolUsage;
    ULONG QuotaPagedPoolUsage;
    ULONG QuotaPeakNonPagedPoolUsage;
    ULONG QuotaNonPagedPoolUsage;
    ULONG PagefileUsage;
    ULONG PeakPagefileUsage;
    ULONG PrivateUsage;
 
    /* This part corresponds to IO_COUNTERS */
    LARGE_INTEGER ReadOperationCount;
    LARGE_INTEGER WriteOperationCount;
    LARGE_INTEGER OtherOperationCount;
    LARGE_INTEGER ReadTransferCount;
    LARGE_INTEGER WriteTransferCount;
    LARGE_INTEGER OtherTransferCount;
 
         SYSTEM_THREADS       Threads [1];
 } SYSTEM_PROCESSES, *PSYSTEM_PROCESSES;
 
 
//                     x00000000 00000000 000:00:00  000:00:00 ()
static char title[]  = "P     PID     PPID     KTime      UTime   NAME\n";
static char title1[] = "t              TID     KTime      UTime   State      WaitResson\n";
static char title2[] = "w     PID     Hwnd  WndStile        TID   WndName\n";
 
 
struct status {
    DWORD state;
    const char  desc[10];
}   thread_stat[8 + 1] = {
    {0, "Init      "},
    {1, "Ready     "},
    {2, "Running   "},
    {3, "Standby   "},
    {4, "Terminated"},
    {5, "Wait      "},
    {6, "Transition"},
    {7, "Unknown   "},
    {-1,"    ?     "}
};
 
struct waitres {
    DWORD state;
    char  desc[17];
}   waitreason[44 + 1] = {
    {0, "Executive        "},
    {1, "FreePage         "},
    {2, "PageIn           "},
    {3, "PoolAllocation   "},
    {4, "DelayExecution   "},
    {5, "Suspended        "},
    {6, "UserRequest      "},
    {7, "WrExecutive      "},
    {8, "WrFreePage       "},
    {9, "WrPageIn         "},
    {10,"WrPoolAllocation "},
    {11,"WrDelayExecution "},
    {12,"WrSuspended      "},
    {13,"WrUserRequest    "},
    {14,"WrEventPair      "},
    {15,"WrQueue          "},
    {16,"WrLpcReceive     "},
    {17,"WrLpcReply       "},
    {18,"WrVirtualMemory  "},
    {19,"WrPageOut        "},
    {20,"WrRendezvous     "},
    {21,"WrKeyedEvent     "},
    {22,"WrTerminated     "},
    {23,"WrProcessInSwap  "},
    {24,"WrCpuRateControl "},
    {25,"WrCalloutStack   "},
    {26,"WrKernel         "},
    {27,"WrResource       "},
    {28,"WrPushLock       "},
    {29,"WrMutex          "},
    {30,"WrQuantumEnd     "},
    {31,"WrDispatchInt    "},
    {32,"WrPreempted      "},
    {33,"WrYieldExecution "},
    {34,"WrFastMutex      "},
    {35,"WrGuardedMutex   "},
    {36,"WrRundown        "},
    {37,"WrAlertByThreadId"},
    {38,"WrDeferredPreempt"},
    {39,"WrPhysicalFault  "},
    {40,"WrIoRing         "},
    {41,"WrMdlCache       "},
    {42,"WrRcu            "},
    {43,"MaximumWaitReason"},
    {-1,"       ?         "}
};
 
static BOOL CALLBACK
EnumThreadProc(HWND hwnd, LPARAM lp)
{
    DWORD r, pid, tid;
    LONG style;
    char buf[256];
    HANDLE Stdout = GetStdHandle(STD_OUTPUT_HANDLE);
 
    GetWindowText(hwnd, (LPTSTR)lp, 30);
 
    if(hwnd != 0)
    {
    style = GetWindowLong(hwnd, GWL_STYLE);
 
    tid = GetWindowThreadProcessId(hwnd, &pid);
 
    wsprintf (buf,"w%8d %8x  %08x   %8d   %s\n",pid, hwnd , style, tid, lp );
        WriteFile(Stdout, buf, lstrlen(buf), &r, NULL);
        }
    return (TRUE);
}
 
int main()
{
    DWORD r;
    ANSI_STRING astring;
    HANDLE Stdout = GetStdHandle(STD_OUTPUT_HANDLE);
    PSYSTEM_PROCESSES SystemProcesses = NULL;
    PSYSTEM_PROCESSES CurrentProcess;
    ULONG BufferSize, ReturnSize;
    NTSTATUS Status;
    char buf[256];
    char buf1[256];
 
    WriteFile(Stdout, title, lstrlen(title), &r, NULL);
    WriteFile(Stdout, title1, lstrlen(title1), &r, NULL);
    WriteFile(Stdout, title2, lstrlen(title2), &r, NULL);
 
    /* Get process information. */
    BufferSize = 0;
    do
    {
        BufferSize += 0x10000;
        SystemProcesses = HeapAlloc(GetProcessHeap(), 0, BufferSize);
        Status = NtQuerySystemInformation(SystemProcessInformation,
                                          SystemProcesses, BufferSize,
                                          &ReturnSize);
        if (Status == STATUS_INFO_LENGTH_MISMATCH)
            HeapFree(GetProcessHeap(), 0, SystemProcesses);
    } while (Status == STATUS_INFO_LENGTH_MISMATCH);
 
    /* If querying system information failed, bail out. */
    if (!NT_SUCCESS(Status))
        return 1;
 
    /* For every process print the information. */
    CurrentProcess = SystemProcesses;
    while (CurrentProcess->NextEntryOffset != 0)
    {
        int hour, hour1, thour, thour1;
        unsigned char minute, minute1, tmin, tmin1;
        unsigned char  seconds, seconds1, tsec, tsec1;
 
    unsigned int ti;
    LARGE_INTEGER ptime;
 
    ptime.QuadPart = CurrentProcess->KernelTime.QuadPart;
    hour    = (ptime.QuadPart / (10000000LL * 3600LL));
    minute  = (ptime.QuadPart / (10000000LL * 60LL)) % 60LL;
    seconds = (ptime.QuadPart / 10000000LL) % 60LL;
 
    ptime.QuadPart = CurrentProcess->UserTime.QuadPart;
    hour1    = (ptime.QuadPart / (10000000LL * 3600LL));
    minute1  = (ptime.QuadPart / (10000000LL * 60LL)) % 60LL;
    seconds1 = (ptime.QuadPart / 10000000LL) % 60LL;
 
    RtlUnicodeStringToAnsiString(&astring, &CurrentProcess->ImageName, TRUE);
 
        wsprintf(buf,"P%8d %8d %3d:%02d:%02d  %3d:%02d:%02d   ProcName: %s\n",
                 CurrentProcess->UniqueProcessId, CurrentProcess->InheritedFromUniqueProcessId,
                 hour, minute, seconds, hour1, minute1, seconds1,
                 astring.Buffer);
        WriteFile(stdout, buf, lstrlen(buf), &r, NULL);
 
        RtlFreeAnsiString(&astring);
 
    for (ti = 0; ti < CurrentProcess->NumberOfThreads; ti++)
       {
        struct status *statt;
        struct waitres *waitt;
        char szWindowName[30] = {" "};
 
        ptime = CurrentProcess->Threads[ti].KernelTime;
        thour = (ptime.QuadPart / (10000000LL * 3600LL));
        tmin  = (ptime.QuadPart / (10000000LL * 60LL)) % 60LL;
        tsec  = (ptime.QuadPart / 10000000LL) % 60LL;
 
        ptime = CurrentProcess->Threads[ti].UserTime;
        thour1 = (ptime.QuadPart / (10000000LL * 3600LL));
        tmin1  = (ptime.QuadPart / (10000000LL * 60LL)) % 60LL;
        tsec1  = (ptime.QuadPart / 10000000LL) % 60LL;
 
        statt = thread_stat;
                while (statt->state != CurrentProcess->Threads[ti].ThreadState  && statt->state >= 0)
                    statt++;
 
        waitt = waitreason;
                while (waitt->state != CurrentProcess->Threads[ti].WaitReason  && waitt->state >= 0)
                        waitt++;
 
        wsprintf (buf1,
                  "t%         %8d %3d:%02d:%02d  %3d:%02d:%02d   %s %s\n",
                  CurrentProcess->Threads[ti].ClientId.UniqueThread,
                  thour, tmin, tsec, thour1, tmin1, tsec1,
                  statt->desc , waitt->desc);
            WriteFile(stdout, buf1, lstrlen(buf1), &r, NULL);
 
        EnumThreadWindows(PtrToUlong(CurrentProcess->Threads[ti].ClientId.UniqueThread),
                          (WNDENUMPROC) EnumThreadProc,
                          (LPARAM)(LPTSTR) szWindowName );
       }
 
       CurrentProcess = (PSYSTEM_PROCESSES)((ULONG_PTR)CurrentProcess +
                         (ULONG_PTR)CurrentProcess->NextEntryOffset);
    }
    return (0);
}