disable defining ntstatus codes in windows.h/winnt.h when using ndk
[reactos.git] / rosapps / sysutils / tlist / tlist.c
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
27 LPWSTR ThreadStateName [] =
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
40 void *PsaiMalloc(SIZE_T size)
41 {
42 void * pBuf = NULL;
43 NTSTATUS nErrCode;
44
45 nErrCode = NtAllocateVirtualMemory
46 (
47 NtCurrentProcess(),
48 &pBuf,
49 0,
50 (PULONG)&size,
51 MEM_COMMIT,
52 PAGE_READWRITE
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
63 NtFreeVirtualMemory(NtCurrentProcess(), &ptr, &nSize, MEM_RELEASE);
64 }
65
66 int STDCALL PrintBanner (VOID)
67 {
68 printf ("ReactOS "KERNEL_RELEASE_STR" T(ask)List\n");
69 printf ("Copyright (c) 2000,2001 Emanuele Aliberti\n\n");
70 return EXIT_SUCCESS;
71 }
72
73 int STDCALL 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
83 int STDCALL PrintLicense (VOID)
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
103 BOOL STDCALL AcquirePrivileges (VOID)
104 {
105 /* TODO: implement it */
106 return TRUE;
107 }
108
109 int STDCALL
110 ProcessHasDescendants (
111 HANDLE Pid,
112 PSYSTEM_PROCESS_INFORMATION pInfo
113 )
114 {
115 LONG Count = 0;
116
117 if (NULL == pInfo) return 0;
118 do {
119
120 if (ALREADY_PROCESSED != (DWORD)pInfo->InheritedFromUniqueProcessId)
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 STDCALL
136 GetProcessInfo (
137 PSYSTEM_PROCESS_INFORMATION pInfo,
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
147 int STDCALL PrintProcessInfoDepth (
148 PSYSTEM_PROCESS_INFORMATION pInfo,
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,
162 pInfo->InheritedFromUniqueProcessId,
163 Title
164 );
165 return EXIT_SUCCESS;
166 }
167
168 int STDCALL
169 PrintProcessAndDescendants (
170 PSYSTEM_PROCESS_INFORMATION pInfo,
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 ++);
180 pInfo->InheritedFromUniqueProcessId = (HANDLE)ALREADY_PROCESSED;
181 /* Save current process' PID */
182 Pid = pInfo->UniqueProcessId;
183 /* Scan and print possible children */
184 do {
185
186 if (ALREADY_PROCESSED != (DWORD)pInfo->InheritedFromUniqueProcessId)
187 {
188 if (Pid == pInfo->InheritedFromUniqueProcessId)
189 {
190 if (ProcessHasDescendants (Pid, pInfoBase))
191 {
192 PrintProcessAndDescendants (
193 pInfo,
194 pInfoBase,
195 Depth
196 );
197 }
198 else
199 {
200 PrintProcessInfoDepth (pInfo, Depth);
201 pInfo->InheritedFromUniqueProcessId = (HANDLE)ALREADY_PROCESSED;
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 STDCALL PrintProcessList (BOOL DisplayTree)
213 {
214 PSYSTEM_PROCESS_INFORMATION pInfo = NULL;
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,
234 pInfo->InheritedFromUniqueProcessId
235 );
236 }
237 else
238 {
239 if (ALREADY_PROCESSED != (DWORD)pInfo->InheritedFromUniqueProcessId)
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
254 int STDCALL PrintThreads (PSYSTEM_PROCESS_INFORMATION pInfo)
255 {
256 ULONG i = 0;
257 NTSTATUS Status = STATUS_SUCCESS;
258 HANDLE hThread = INVALID_HANDLE_VALUE;
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,
275 THREAD_QUERY_INFORMATION,
276 & Oa,
277 & CurThread->ClientId
278 );
279 if (!NT_SUCCESS(Status))
280 {
281 continue;
282 }
283
284 Status = NtQueryInformationThread (
285 hThread,
286 ThreadBasicInformation,
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,
299 ThreadQuerySetWin32StartAddress,
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
323 int STDCALL PrintModules (VOID)
324 {
325 /* TODO */
326 return EXIT_SUCCESS;
327 }
328
329 PSYSTEM_PROCESS_INFORMATION STDCALL
330 GetProcessInfoPid (
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 STDCALL 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,
369 PROCESS_QUERY_INFORMATION,
370 & Oa,
371 & ClientId
372 );
373 if (NT_SUCCESS(Status))
374 {
375 ULONG ReturnLength = 0;
376 PROCESS_BASIC_INFORMATION PsBasic;
377 VM_COUNTERS PsVm;
378 PSYSTEM_PROCESS_INFORMATION pInfo = NULL;
379 PSYSTEM_PROCESS_INFORMATION pInfoBase = NULL;
380 LPWSTR Module = L"";
381 LPWSTR Title = L"";
382
383 Status = NtQueryInformationProcess (
384 hProcess,
385 ProcessBasicInformation,
386 & PsBasic,
387 sizeof (PsBasic),
388 & ReturnLength
389 );
390 if (!NT_SUCCESS(Status))
391 {
392 return EXIT_FAILURE;
393 }
394 Status = NtQueryInformationProcess (
395 hProcess,
396 ProcessVmCounters,
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 */