tlist.c File Reference

#include <reactos/buildno.h>
#include <windows.h>
#include <ndk/ntndk.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <epsapi/epsapi.h>
#include <getopt.h>

Include dependency graph for tlist.c:

Go to the source code of this file.

Macros
#define	WIN32_NO_STATUS
#define	NTOS_MODE_USER
#define	PAGE_SIZE   4096
#define	ALREADY_PROCESSED   ((DWORD)-1)

Functions
void *	PsaiMalloc (SIZE_T size)
void	PsaiFree (void *ptr)
int WINAPI	PrintBanner (VOID)
int WINAPI	PrintSynopsys (int nRetVal)
int WINAPI	PrintLicense (VOID)
BOOL WINAPI	AcquirePrivileges (VOID)
int WINAPI	ProcessHasDescendants (HANDLE Pid, PSYSTEM_PROCESS_INFORMATION pInfo)
BOOL WINAPI	GetProcessInfo (PSYSTEM_PROCESS_INFORMATION pInfo, LPWSTR *Module, LPWSTR *Title)
int WINAPI	PrintProcessInfoDepth (PSYSTEM_PROCESS_INFORMATION pInfo, LONG Depth)
int WINAPI	PrintProcessAndDescendants (PSYSTEM_PROCESS_INFORMATION pInfo, PSYSTEM_PROCESS_INFORMATION pInfoBase, LONG Depth)
int WINAPI	PrintProcessList (BOOL DisplayTree)
int WINAPI	PrintThreads (PSYSTEM_PROCESS_INFORMATION pInfo)
int WINAPI	PrintModules (VOID)
PSYSTEM_PROCESS_INFORMATION WINAPI	GetProcessInfoPid (PSYSTEM_PROCESS_INFORMATION pInfoBase, HANDLE Pid)
int WINAPI	PrintProcess (char *PidStr)
int	main (int argc, char *argv [])

Variables
LPWSTR	ThreadStateName []

Macro Definition Documentation

ALREADY_PROCESSED

#define ALREADY_PROCESSED   ((DWORD)-1)

Definition at line 25 of file tlist.c.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 10 of file tlist.c.

PAGE_SIZE

#define PAGE_SIZE   4096

Definition at line 22 of file tlist.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 8 of file tlist.c.

Function Documentation

AcquirePrivileges()

BOOL WINAPI AcquirePrivileges

(

VOID

)

Definition at line 103 of file tlist.c.

{
  /* TODO: implement it */
  return TRUE;
}

Referenced by PrintProcess().

GetProcessInfo()

BOOL WINAPI GetProcessInfo	(	PSYSTEM_PROCESS_INFORMATION	pInfo,
		LPWSTR *	Module,
		LPWSTR *	Title
	)

Definition at line 136 of file tlist.c.

{
      *Module = (pInfo->ImageName.Length ? pInfo->ImageName.Buffer : L"System process");
      *Title = L""; /* TODO: check if the process has any window */
      return TRUE;
}

Referenced by PrintProcess(), PrintProcessInfoDepth(), and PrintProcessList().

GetProcessInfoPid()

PSYSTEM_PROCESS_INFORMATION WINAPI GetProcessInfoPid	(	PSYSTEM_PROCESS_INFORMATION	pInfoBase,
		HANDLE	Pid
	)

Definition at line 330 of file tlist.c.

{
  if (NULL == pInfoBase) return NULL;

  pInfoBase = PsaWalkFirstProcess(pInfoBase);

  while(pInfoBase)
  {
    if (Pid == pInfoBase->UniqueProcessId)
    {
      return pInfoBase;
    }

    pInfoBase = PsaWalkNextProcess(pInfoBase);
  }

  return NULL;
}

Referenced by PrintProcess().

main()

int main	(	int argc	,
		char *	argv[]
	)

hosttype.c Copyright (C) 2002 by Brian Palmer brian.nosp@m.p@sg.nosp@m.inet..nosp@m.com

Definition at line 442 of file tlist.c.

{
 int c;

 if(1 == argc) return PrintProcessList(FALSE);

 while((c = getopt(argc, argv, "tl")) != -1)
 {
  switch(c)
  {
   case 't': return PrintProcessList(TRUE);
   case 'l': return PrintLicense();
   default: return PrintSynopsys(EXIT_FAILURE);
  }
 }

 if(isdigit(argv[optind][0]))
  return PrintProcess (argv[1]);

 return PrintSynopsys(EXIT_SUCCESS);
}

PrintBanner()

int WINAPI PrintBanner

(

VOID

)

Definition at line 66 of file tlist.c.

{
  printf ("ReactOS "KERNEL_VERSION_STR" T(ask)List\n");
  printf ("Copyright (c) 2000,2001 Emanuele Aliberti\n\n");
  return EXIT_SUCCESS;
}

Referenced by PrintLicense(), and PrintSynopsys().

PrintLicense()

int WINAPI PrintLicense

(

VOID

)

Definition at line 83 of file tlist.c.

{
  PrintBanner ();
  printf (
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 2 of the License, or\n"
"(at your option) any later version.\n\n");
  printf (
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
"GNU General Public License for more details.\n\n");
  printf (
"You should have received a copy of the GNU General Public License\n"
"along with this program; if not, write to the Free Software\n"
"Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n\n");
  return EXIT_SUCCESS;
}

Referenced by main().

PrintModules()

int WINAPI PrintModules

(

VOID

)

Definition at line 323 of file tlist.c.

{
    /* TODO */
    return EXIT_SUCCESS;
}

Referenced by PrintProcess().

PrintProcess()

int WINAPI PrintProcess

(

char *

PidStr

)

Definition at line 352 of file tlist.c.

{
  NTSTATUS                    Status = 0;
  HANDLE                      hProcess = 0;
  OBJECT_ATTRIBUTES           Oa = {0};
  CLIENT_ID                   ClientId = {0, 0};


  ClientId.UniqueProcess = UlongToHandle(atol (PidStr));

  if (FALSE == AcquirePrivileges ())
  {
    return EXIT_FAILURE;
  }

  Status = NtOpenProcess (
             & hProcess,
             PROCESS_QUERY_INFORMATION,
             & Oa,
             & ClientId
             );
  if (NT_SUCCESS(Status))
  {
    ULONG                       ReturnLength = 0;
    PROCESS_BASIC_INFORMATION   PsBasic;
    VM_COUNTERS                 PsVm;
    PSYSTEM_PROCESS_INFORMATION pInfo = NULL;
    PSYSTEM_PROCESS_INFORMATION pInfoBase = NULL;
    LPWSTR                      Module = L"";
    LPWSTR                      Title = L"";

    Status = NtQueryInformationProcess (
               hProcess,
           ProcessBasicInformation,
           & PsBasic,
           sizeof (PsBasic),
           & ReturnLength
               );
    if (!NT_SUCCESS(Status))
    {
      return EXIT_FAILURE;
    }
    Status = NtQueryInformationProcess (
               hProcess,
           ProcessVmCounters,
           & PsVm,
           sizeof (PsVm),
           & ReturnLength
               );
    if (!NT_SUCCESS(Status))
    {
      return EXIT_FAILURE;
    }

    if (!NT_SUCCESS(PsaCaptureProcessesAndThreads (&pInfoBase)))
     return EXIT_FAILURE;

    pInfo = GetProcessInfoPid (pInfoBase, ClientId.UniqueProcess);
    if (NULL == pInfo) return EXIT_FAILURE;

    GetProcessInfo (pInfo, & Module, & Title);

    wprintf (L"%4d %s\n", HandleToUlong(ClientId.UniqueProcess), Module);
#if 0
    printf ("   CWD:     %s\n", ""); /* it won't appear if empty */
    printf ("   CmdLine: %s\n", ""); /* it won't appear if empty */
#endif
    printf ("   VirtualSize:     %5ld kb   PeakVirtualSize:     %5ld kb\n",
      ((LONG) PsVm.VirtualSize / 1024),
      ((LONG) PsVm.PeakVirtualSize / 1024)
      );
    printf ("   WorkingSetSize:  %5ld kb   PeakWorkingSetSize:  %5ld kb\n",
      ((LONG) PsVm.WorkingSetSize / 1024),
      ((LONG) PsVm.PeakWorkingSetSize / 1024)
      );

    PrintThreads (pInfo);

    PrintModules ();

    PsaFreeCapture(pInfoBase);

    NtClose (hProcess);

    return EXIT_SUCCESS;
  }
  return EXIT_FAILURE;
}

Referenced by main().

PrintProcessAndDescendants()

int WINAPI PrintProcessAndDescendants	(	PSYSTEM_PROCESS_INFORMATION	pInfo,
		PSYSTEM_PROCESS_INFORMATION	pInfoBase,
		LONG	Depth
	)

Definition at line 169 of file tlist.c.

{
  HANDLE   Pid = 0;

  if (NULL == pInfo) return EXIT_FAILURE;
  /* Print current pInfo process */
  PrintProcessInfoDepth (pInfo, Depth ++);
  pInfo->InheritedFromUniqueProcessId = UlongToHandle(ALREADY_PROCESSED);
  /* Save current process' PID */
  Pid = pInfo->UniqueProcessId;
  /* Scan and print possible children */
  do {

    if (ALREADY_PROCESSED != HandleToUlong(pInfo->InheritedFromUniqueProcessId))
    {
      if (Pid == pInfo->InheritedFromUniqueProcessId)
      {
        if (ProcessHasDescendants (Pid, pInfoBase))
        {
          PrintProcessAndDescendants (
            pInfo,
            pInfoBase,
            Depth
            );
        }
    else
    {
          PrintProcessInfoDepth (pInfo, Depth);
      pInfo->InheritedFromUniqueProcessId = UlongToHandle(ALREADY_PROCESSED);
    }
      }
    }
    pInfo = (PSYSTEM_PROCESS_INFORMATION)((PBYTE)pInfo + pInfo->NextEntryOffset);

  } while (0 != pInfo->NextEntryOffset);

  return EXIT_SUCCESS;
}

Referenced by PrintProcessList().

PrintProcessInfoDepth()

int WINAPI PrintProcessInfoDepth	(	PSYSTEM_PROCESS_INFORMATION	pInfo,
		LONG	Depth
	)

Definition at line 147 of file tlist.c.

{
  INT     d = 0;
  LPWSTR  Module = L"";
  LPWSTR  Title = L"";

  for (d = 0; d < Depth; d ++) printf ("  ");
  GetProcessInfo (pInfo, & Module, & Title);
  wprintf (
    L"%s (%d, %d) %s\n",
    Module,
    HandleToUlong(pInfo->UniqueProcessId),
    HandleToUlong(pInfo->InheritedFromUniqueProcessId),
    Title
    );
  return EXIT_SUCCESS;
}

Referenced by PrintProcessAndDescendants().

PrintProcessList()

int WINAPI PrintProcessList

(

BOOL

DisplayTree

)

Definition at line 212 of file tlist.c.

{
  PSYSTEM_PROCESS_INFORMATION pInfo = NULL;
  PSYSTEM_PROCESS_INFORMATION pInfoBase = NULL;
  LPWSTR                      Module = L"";
  LPWSTR                      Title = L"";

  if (!NT_SUCCESS(PsaCaptureProcessesAndThreads(&pInfoBase)))
   return EXIT_FAILURE;

  pInfo = PsaWalkFirstProcess(pInfoBase);

  while (pInfo)
  {
      if (FALSE == DisplayTree)
      {
        GetProcessInfo (pInfo, & Module, & Title);
        wprintf (
          L"%4d %-16s %s (%04d)\n",
      HandleToUlong(pInfo->UniqueProcessId),
      Module,
      Title,
      HandleToUlong(pInfo->InheritedFromUniqueProcessId)
      );
      }
      else
      {
    if (ALREADY_PROCESSED != HandleToUlong(pInfo->InheritedFromUniqueProcessId))
    {
      PrintProcessAndDescendants (pInfo, pInfoBase, 0);
    }
      }

      pInfo = PsaWalkNextProcess(pInfo);
    }

    PsaFreeCapture(pInfoBase);

    return EXIT_SUCCESS;
}

Referenced by main().

PrintSynopsys()

int WINAPI PrintSynopsys

(

int

nRetVal

)

Definition at line 73 of file tlist.c.

{
  PrintBanner ();
  printf ("Usage: tlist [-t | PID | -l]\n\n"
          "  -t   print the task list tree\n"
          "  PID  print module information for this ID\n"
          "  -l   print license information\n");
  return nRetVal;
}

Referenced by main().

PrintThreads()

int WINAPI PrintThreads

(

PSYSTEM_PROCESS_INFORMATION

pInfo

)

Definition at line 254 of file tlist.c.

{
  ULONG                               i = 0;
  NTSTATUS                            Status = STATUS_SUCCESS;
  HANDLE                              hThread = INVALID_HANDLE_VALUE;
  OBJECT_ATTRIBUTES                   Oa = {0};
  PVOID                               Win32StartAddress = NULL;
  THREAD_BASIC_INFORMATION            tInfo = {0};
  ULONG                               ReturnLength = 0;
  PSYSTEM_THREAD_INFORMATION          CurThread;

  if (NULL == pInfo) return EXIT_FAILURE;

  CurThread = PsaWalkFirstThread(pInfo);

  wprintf (L"   NumberOfThreads: %d\n", pInfo->NumberOfThreads);

  for (i = 0; i < pInfo->NumberOfThreads; i ++, CurThread = PsaWalkNextThread(CurThread))
  {
    Status = NtOpenThread (
           & hThread,
           THREAD_QUERY_INFORMATION,
           & Oa,
           & CurThread->ClientId
               );
    if (!NT_SUCCESS(Status))
    {
      continue;
    }

    Status = NtQueryInformationThread (
               hThread,
           ThreadBasicInformation,
           (PVOID) & tInfo,
           sizeof tInfo,
           & ReturnLength
               );
    if (!NT_SUCCESS(Status))
    {
      NtClose (hThread);
      continue;
    }

    Status = NtQueryInformationThread (
               hThread,
           ThreadQuerySetWin32StartAddress,
           (PVOID) & Win32StartAddress,
           sizeof Win32StartAddress,
           & ReturnLength
               );
    if (!NT_SUCCESS(Status))
    {
      NtClose (hThread);
      continue;
    }

    NtClose (hThread);

    /* Now print the collected information */
    wprintf (L"   %4d Win32StartAddr:0x%p LastErr:0x%08x State:%s\n",
      HandleToUlong(CurThread->ClientId.UniqueThread),
      Win32StartAddress,
      0 /* FIXME: ((PTEB) tInfo.TebBaseAddress)->LastErrorValue */,
      ThreadStateName[CurThread->ThreadState]
      );
  }
  return EXIT_SUCCESS;
}

Referenced by PrintProcess().

ProcessHasDescendants()

int WINAPI ProcessHasDescendants	(	HANDLE	Pid,
		PSYSTEM_PROCESS_INFORMATION	pInfo
	)

Definition at line 110 of file tlist.c.

{
  LONG Count = 0;

  if (NULL == pInfo) return 0;
  do {

      if (ALREADY_PROCESSED != HandleToUlong(pInfo->InheritedFromUniqueProcessId))
      {
        if ((Pid != (HANDLE)pInfo->UniqueProcessId) && (Pid == (HANDLE)pInfo->InheritedFromUniqueProcessId))
        {
          ++ Count;
        }
      }
      pInfo = (PSYSTEM_PROCESS_INFORMATION)((PBYTE)pInfo + pInfo->NextEntryOffset);

  } while (0 != pInfo->NextEntryOffset);

  return Count;
}

Referenced by PrintProcessAndDescendants().

PsaiFree()

void PsaiFree

(

void *

ptr

)

Definition at line 59 of file tlist.c.

{
 SIZE_T nSize = 0;

 NtFreeVirtualMemory(NtCurrentProcess(), &ptr, &nSize, MEM_RELEASE);
}

PsaiMalloc()

void* PsaiMalloc

(

SIZE_T

size

)

Definition at line 40 of file tlist.c.

{
 void * pBuf = NULL;
 NTSTATUS nErrCode;

 nErrCode = NtAllocateVirtualMemory
 (
  NtCurrentProcess(),
  &pBuf,
  0,
  &size,
  MEM_COMMIT,
  PAGE_READWRITE
 );

 if(NT_SUCCESS(nErrCode)) return pBuf;
 else return NULL;
}

Variable Documentation

ThreadStateName

LPWSTR ThreadStateName[]

Initial value:

=
{
  L"Initialized",
  L"Ready",
  L"Running",
  L"Standby",
  L"Terminated",
  L"Wait",
  L"Transition",
  L"Unknown",
  NULL
}

Definition at line 27 of file tlist.c.

Referenced by PrintThreads().