ReactOS  r76032
tlist.c
Go to the documentation of this file.
1 /*
2  * ReactOS Project
3  * TList
4  *
5  * Copyright (c) 2000,2001 Emanuele Aliberti
6  */
7 #include <reactos/buildno.h>
8 #define WIN32_NO_STATUS
9 #include <windows.h>
10 #define NTOS_MODE_USER
11 #include <ndk/ntndk.h>
12 
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <ctype.h>
17 
18 #include <epsapi/epsapi.h>
19 #include <getopt.h>
20 
21 #ifndef PAGE_SIZE
22 #define PAGE_SIZE 4096
23 #endif
24 
25 #define ALREADY_PROCESSED ((DWORD)-1)
26 
28 {
29  L"Initialized",
30  L"Ready",
31  L"Running",
32  L"Standby",
33  L"Terminated",
34  L"Wait",
35  L"Transition",
36  L"Unknown",
37  NULL
38 };
39 
41 {
42  void * pBuf = NULL;
43  NTSTATUS nErrCode;
44 
45  nErrCode = NtAllocateVirtualMemory
46  (
48  &pBuf,
49  0,
50  (PULONG)&size,
51  MEM_COMMIT,
53  );
54 
55  if(NT_SUCCESS(nErrCode)) return pBuf;
56  else return NULL;
57 }
58 
59 void PsaiFree(void *ptr)
60 {
61  ULONG nSize = 0;
62 
64 }
65 
67 {
68  printf ("ReactOS "KERNEL_VERSION_STR" T(ask)List\n");
69  printf ("Copyright (c) 2000,2001 Emanuele Aliberti\n\n");
70  return EXIT_SUCCESS;
71 }
72 
73 int WINAPI PrintSynopsys (int nRetVal)
74 {
75  PrintBanner ();
76  printf ("Usage: tlist [-t | PID | -l]\n\n"
77  " -t print the task list tree\n"
78  " PID print module information for this ID\n"
79  " -l print license information\n");
80  return nRetVal;
81 }
82 
84 {
85  PrintBanner ();
86  printf (
87 "This program is free software; you can redistribute it and/or modify\n"
88 "it under the terms of the GNU General Public License as published by\n"
89 "the Free Software Foundation; either version 2 of the License, or\n"
90 "(at your option) any later version.\n\n");
91  printf (
92 "This program is distributed in the hope that it will be useful,\n"
93 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
94 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
95 "GNU General Public License for more details.\n\n");
96  printf (
97 "You should have received a copy of the GNU General Public License\n"
98 "along with this program; if not, write to the Free Software\n"
99 "Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n\n");
100  return EXIT_SUCCESS;
101 }
102 
104 {
105  /* TODO: implement it */
106  return TRUE;
107 }
108 
109 int WINAPI
111  HANDLE Pid,
113  )
114 {
115  LONG Count = 0;
116 
117  if (NULL == pInfo) return 0;
118  do {
119 
121  {
122  if ((Pid != (HANDLE)pInfo->UniqueProcessId) && (Pid == (HANDLE)pInfo->InheritedFromUniqueProcessId))
123  {
124  ++ Count;
125  }
126  }
127  pInfo = (PSYSTEM_PROCESS_INFORMATION)((PBYTE)pInfo + pInfo->NextEntryOffset);
128 
129  } while (0 != pInfo->NextEntryOffset);
130 
131  return Count;
132 }
133 
134 
135 BOOL WINAPI
138  LPWSTR * Module,
139  LPWSTR * Title
140  )
141 {
142  *Module = (pInfo->ImageName.Length ? pInfo->ImageName.Buffer : L"System process");
143  *Title = L""; /* TODO: check if the process has any window */
144  return TRUE;
145 }
146 
149  LONG Depth
150  )
151 {
152  INT d = 0;
153  LPWSTR Module = L"";
154  LPWSTR Title = L"";
155 
156  for (d = 0; d < Depth; d ++) printf (" ");
157  GetProcessInfo (pInfo, & Module, & Title);
158  wprintf (
159  L"%s (%d, %d) %s\n",
160  Module,
161  pInfo->UniqueProcessId,
163  Title
164  );
165  return EXIT_SUCCESS;
166 }
167 
168 int WINAPI
171  PSYSTEM_PROCESS_INFORMATION pInfoBase,
172  LONG Depth
173  )
174 {
175  HANDLE Pid = 0;
176 
177  if (NULL == pInfo) return EXIT_FAILURE;
178  /* Print current pInfo process */
179  PrintProcessInfoDepth (pInfo, Depth ++);
181  /* Save current process' PID */
182  Pid = pInfo->UniqueProcessId;
183  /* Scan and print possible children */
184  do {
185 
187  {
188  if (Pid == pInfo->InheritedFromUniqueProcessId)
189  {
190  if (ProcessHasDescendants (Pid, pInfoBase))
191  {
193  pInfo,
194  pInfoBase,
195  Depth
196  );
197  }
198  else
199  {
200  PrintProcessInfoDepth (pInfo, Depth);
202  }
203  }
204  }
205  pInfo = (PSYSTEM_PROCESS_INFORMATION)((PBYTE)pInfo + pInfo->NextEntryOffset);
206 
207  } while (0 != pInfo->NextEntryOffset);
208 
209  return EXIT_SUCCESS;
210 }
211 
212 int WINAPI PrintProcessList (BOOL DisplayTree)
213 {
215  PSYSTEM_PROCESS_INFORMATION pInfoBase = NULL;
216  LPWSTR Module = L"";
217  LPWSTR Title = L"";
218 
219  if (!NT_SUCCESS(PsaCaptureProcessesAndThreads(&pInfoBase)))
220  return EXIT_FAILURE;
221 
222  pInfo = PsaWalkFirstProcess(pInfoBase);
223 
224  while (pInfo)
225  {
226  if (FALSE == DisplayTree)
227  {
228  GetProcessInfo (pInfo, & Module, & Title);
229  wprintf (
230  L"%4d %-16s %s\n",
231  pInfo->UniqueProcessId,
232  Module,
233  Title,
235  );
236  }
237  else
238  {
240  {
241  PrintProcessAndDescendants (pInfo, pInfoBase, 0);
242  }
243  }
244 
245  pInfo = PsaWalkNextProcess(pInfo);
246  }
247 
248  PsaFreeCapture(pInfoBase);
249 
250  return EXIT_SUCCESS;
251 }
252 
253 
255 {
256  ULONG i = 0;
259  OBJECT_ATTRIBUTES Oa = {0};
260  PVOID Win32StartAddress = NULL;
261  THREAD_BASIC_INFORMATION tInfo = {0};
262  ULONG ReturnLength = 0;
263  PSYSTEM_THREAD_INFORMATION CurThread;
264 
265  if (NULL == pInfo) return EXIT_FAILURE;
266 
267  CurThread = PsaWalkFirstThread(pInfo);
268 
269  wprintf (L" NumberOfThreads: %d\n", pInfo->NumberOfThreads);
270 
271  for (i = 0; i < pInfo->NumberOfThreads; i ++, CurThread = PsaWalkNextThread(CurThread))
272  {
273  Status = NtOpenThread (
274  & hThread,
276  & Oa,
277  & CurThread->ClientId
278  );
279  if (!NT_SUCCESS(Status))
280  {
281  continue;
282  }
283 
284  Status = NtQueryInformationThread (
285  hThread,
287  (PVOID) & tInfo,
288  sizeof tInfo,
289  & ReturnLength
290  );
291  if (!NT_SUCCESS(Status))
292  {
293  NtClose (hThread);
294  continue;
295  }
296 
297  Status = NtQueryInformationThread (
298  hThread,
300  (PVOID) & Win32StartAddress,
301  sizeof Win32StartAddress,
302  & ReturnLength
303  );
304  if (!NT_SUCCESS(Status))
305  {
306  NtClose (hThread);
307  continue;
308  }
309 
310  NtClose (hThread);
311 
312  /* Now print the collected information */
313  wprintf (L" %4d Win32StartAddr:0x%08x LastErr:0x%08x State:%s\n",
314  CurThread->ClientId.UniqueThread,
315  Win32StartAddress,
316  0 /* FIXME: ((PTEB) tInfo.TebBaseAddress)->LastErrorValue */,
317  ThreadStateName[CurThread->ThreadState]
318  );
319  }
320  return EXIT_SUCCESS;
321 }
322 
324 {
325  /* TODO */
326  return EXIT_SUCCESS;
327 }
328 
331  PSYSTEM_PROCESS_INFORMATION pInfoBase,
332  HANDLE Pid
333  )
334 {
335  if (NULL == pInfoBase) return NULL;
336 
337  pInfoBase = PsaWalkFirstProcess(pInfoBase);
338 
339  while(pInfoBase)
340  {
341  if (Pid == pInfoBase->UniqueProcessId)
342  {
343  return pInfoBase;
344  }
345 
346  pInfoBase = PsaWalkNextProcess(pInfoBase);
347  }
348 
349  return NULL;
350 }
351 
352 int WINAPI PrintProcess (char * PidStr)
353 {
354  NTSTATUS Status = 0;
355  HANDLE hProcess = 0;
356  OBJECT_ATTRIBUTES Oa = {0};
357  CLIENT_ID ClientId = {0, 0};
358 
359 
360  ClientId.UniqueProcess = (PVOID) atol (PidStr);
361 
362  if (FALSE == AcquirePrivileges ())
363  {
364  return EXIT_FAILURE;
365  }
366 
367  Status = NtOpenProcess (
368  & hProcess,
370  & Oa,
371  & ClientId
372  );
373  if (NT_SUCCESS(Status))
374  {
375  ULONG ReturnLength = 0;
377  VM_COUNTERS PsVm;
379  PSYSTEM_PROCESS_INFORMATION pInfoBase = NULL;
380  LPWSTR Module = L"";
381  LPWSTR Title = L"";
382 
383  Status = NtQueryInformationProcess (
384  hProcess,
386  & PsBasic,
387  sizeof (PsBasic),
388  & ReturnLength
389  );
390  if (!NT_SUCCESS(Status))
391  {
392  return EXIT_FAILURE;
393  }
394  Status = NtQueryInformationProcess (
395  hProcess,
397  & PsVm,
398  sizeof (PsVm),
399  & ReturnLength
400  );
401  if (!NT_SUCCESS(Status))
402  {
403  return EXIT_FAILURE;
404  }
405 
406  if (!NT_SUCCESS(PsaCaptureProcessesAndThreads (&pInfoBase)))
407  return EXIT_FAILURE;
408 
409  pInfo = GetProcessInfoPid (pInfoBase, ClientId.UniqueProcess);
410  if (NULL == pInfo) return EXIT_FAILURE;
411 
412  GetProcessInfo (pInfo, & Module, & Title);
413 
414  wprintf (L"%4d %s\n", ClientId.UniqueProcess, Module);
415 #if 0
416  printf (" CWD: %s\n", ""); /* it won't appear if empty */
417  printf (" CmdLine: %s\n", ""); /* it won't appear if empty */
418 #endif
419  printf (" VirtualSize: %5ld kb PeakVirtualSize: %5ld kb\n",
420  ((LONG) PsVm.VirtualSize / 1024),
421  ((LONG) PsVm.PeakVirtualSize / 1024)
422  );
423  printf (" WorkingSetSize: %5ld kb PeakWorkingSetSize: %5ld kb\n",
424  ((LONG) PsVm.WorkingSetSize / 1024),
425  ((LONG) PsVm.PeakWorkingSetSize / 1024)
426  );
427 
428  PrintThreads (pInfo);
429 
430  PrintModules ();
431 
432  PsaFreeCapture(pInfoBase);
433 
434  NtClose (hProcess);
435 
436  return EXIT_SUCCESS;
437  }
438  return EXIT_FAILURE;
439 }
440 
441 
442 int main (int argc, char * argv [])
443 {
444  int c;
445 
446  if(1 == argc) return PrintProcessList(FALSE);
447 
448  while((c = getopt(argc, argv, "tl")) != -1)
449  {
450  switch(c)
451  {
452  case 't': return PrintProcessList(TRUE);
453  case 'l': return PrintLicense();
454  default: return PrintSynopsys(EXIT_FAILURE);
455  }
456  }
457 
458  if(isdigit(argv[optind][0]))
459  return PrintProcess (argv[1]);
460 
461  return PrintSynopsys(EXIT_SUCCESS);
462 }
463 
464 /* EOF */
DWORD *typedef PVOID
Definition: winlogon.h:52
BOOL WINAPI GetProcessInfo(PSYSTEM_PROCESS_INFORMATION pInfo, LPWSTR *Module, LPWSTR *Title)
Definition: tlist.c:136
LPWSTR ThreadStateName[]
Definition: tlist.c:27
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
static int argc
Definition: ServiceArgs.c:15
SIZE_T PeakVirtualSize
Definition: winternl.h:1563
_In_opt_ PALLOCATE_FUNCTION _In_opt_ PFREE_FUNCTION _In_ ULONG _In_ SIZE_T _In_ ULONG _In_ USHORT Depth
Definition: exfuncs.h:656
#define TRUE
Definition: types.h:120
NTSTATUS NTAPI NtOpenThread(OUT PHANDLE ThreadHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN PCLIENT_ID ClientId OPTIONAL)
Definition: thread.c:1013
Definition: bidi.c:75
PSYSTEM_PROCESS_INFORMATION WINAPI GetProcessInfoPid(PSYSTEM_PROCESS_INFORMATION pInfoBase, HANDLE Pid)
Definition: tlist.c:330
return STATUS_SUCCESS
Definition: btrfs.c:2664
int optind
Definition: getopt.c:47
*nSize LPSTR _Inout_ LPDWORD nSize
Definition: winbase.h:1973
NTSTATUS NTAPI NtQueryInformationProcess(IN HANDLE ProcessHandle, IN PROCESSINFOCLASS ProcessInformationClass, OUT PVOID ProcessInformation, IN ULONG ProcessInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: query.c:56
#define THREAD_QUERY_INFORMATION
Definition: pstypes.h:142
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
int WINAPI PrintProcess(char *PidStr)
Definition: tlist.c:352
int WINAPI PrintModules(VOID)
Definition: tlist.c:323
SIZE_T VirtualSize
Definition: winternl.h:1564
#define ALREADY_PROCESSED
Definition: tlist.c:25
PSYSTEM_PROCESSES FASTCALL PsaWalkNextProcess(IN PSYSTEM_PROCESSES CurrentProcess)
#define wprintf(...)
Definition: whoami.c:18
HANDLE UniqueProcess
Definition: compat.h:474
PSYSTEM_THREADS FASTCALL PsaWalkNextThread(IN PSYSTEM_THREADS CurrentThread)
#define MEM_COMMIT
Definition: nt_native.h:1313
int main(int argc, char *argv[])
Definition: tlist.c:442
NTSTATUS NTAPI NtOpenProcess(OUT PHANDLE ProcessHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN PCLIENT_ID ClientId)
Definition: process.c:1440
int32_t INT
Definition: typedefs.h:56
DWORD DWORD
Definition: winlogon.h:75
static char ** argv
Definition: ServiceArgs.c:14
int WINAPI PrintLicense(VOID)
Definition: tlist.c:83
#define EXIT_SUCCESS
Definition: rdjpgcom.c:55
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:159
GLenum GLclampf GLint i
Definition: glfuncs.h:14
PSYSTEM_THREADS FASTCALL PsaWalkFirstThread(IN PSYSTEM_PROCESSES CurrentProcess)
#define FALSE
Definition: types.h:117
void PsaiFree(void *ptr)
Definition: tlist.c:59
long LONG
Definition: pedump.c:60
static PVOID ptr
Definition: dispmode.c:30
smooth NULL
Definition: ftsmooth.c:557
#define isdigit(c)
Definition: acclib.h:68
#define NtCurrentProcess()
Definition: nt_native.h:1657
PSYSTEM_PROCESSES FASTCALL PsaWalkFirstProcess(IN PSYSTEM_PROCESSES ProcessesAndThreads)
BOOL WINAPI AcquirePrivileges(VOID)
Definition: tlist.c:103
void * PsaiMalloc(SIZE_T size)
Definition: tlist.c:40
unsigned int BOOL
Definition: ntddk_ex.h:94
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1176
static const WCHAR Title[]
Definition: oid.c:1079
#define d
Definition: ke_i.h:81
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:24
int WINAPI PrintProcessInfoDepth(PSYSTEM_PROCESS_INFORMATION pInfo, LONG Depth)
Definition: tlist.c:147
VOID NTAPI PsaFreeCapture(IN PVOID Capture)
Definition: processes.c:188
#define EXIT_FAILURE
Definition: jerror.c:33
int getopt(int nargc, char *const *nargv, const char *ostr)
Definition: getopt.c:55
_Check_return_ long __cdecl atol(_In_z_ const char *_Str)
NTSTATUS NTAPI NtQueryInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, OUT PVOID ThreadInformation, IN ULONG ThreadInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: query.c:2436
NTSTATUS NTAPI PsaCaptureProcessesAndThreads(OUT PSYSTEM_PROCESSES *ProcessesAndThreads)
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3392
UNICODE_STRING ImageName
Definition: extypes.h:890
int WINAPI PrintSynopsys(int nRetVal)
Definition: tlist.c:73
HANDLE InheritedFromUniqueProcessId
Definition: extypes.h:893
int WINAPI ProcessHasDescendants(HANDLE Pid, PSYSTEM_PROCESS_INFORMATION pInfo)
Definition: tlist.c:110
#define WINAPI
Definition: msvc.h:20
int WINAPI PrintProcessList(BOOL DisplayTree)
Definition: tlist.c:212
int WINAPI PrintProcessAndDescendants(PSYSTEM_PROCESS_INFORMATION pInfo, PSYSTEM_PROCESS_INFORMATION pInfoBase, LONG Depth)
Definition: tlist.c:169
Status
Definition: gdiplustypes.h:24
struct _SYSTEM_PROCESS_INFORMATION * PSYSTEM_PROCESS_INFORMATION
ULONG_PTR SIZE_T
Definition: typedefs.h:78
SIZE_T WorkingSetSize
Definition: winternl.h:1567
DWORD *typedef HANDLE
Definition: winlogon.h:52
NTSTATUS NTAPI NtAllocateVirtualMemory(IN HANDLE ProcessHandle, IN OUT PVOID *UBaseAddress, IN ULONG_PTR ZeroBits, IN OUT PSIZE_T URegionSize, IN ULONG AllocationType, IN ULONG Protect)
Definition: virtual.c:4367
LONG NTSTATUS
Definition: DriverTester.h:11
GLsizeiptr size
Definition: glext.h:5919
unsigned int * PULONG
Definition: retypes.h:1
HANDLE hThread
Definition: wizard.c:27
int WINAPI PrintBanner(VOID)
Definition: tlist.c:66
#define MEM_RELEASE
Definition: nt_native.h:1316
int WINAPI PrintThreads(PSYSTEM_PROCESS_INFORMATION pInfo)
Definition: tlist.c:254
#define c
Definition: ke_i.h:80
unsigned int ULONG
Definition: retypes.h:1
SIZE_T PeakWorkingSetSize
Definition: winternl.h:1566
WCHAR * LPWSTR
Definition: xmlstorage.h:184
BYTE * PBYTE
Definition: pedump.c:66
#define printf
Definition: config.h:203
#define PAGE_READWRITE
Definition: nt_native.h:1304
NTSTATUS NTAPI NtFreeVirtualMemory(IN HANDLE ProcessHandle, IN PVOID *UBaseAddress, IN PSIZE_T URegionSize, IN ULONG FreeType)
Definition: virtual.c:5089