Create the AHCI branch for Aman's work
[reactos.git] / sdk / lib / epsapi / enum / processes.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * LICENSE: See LGPL.txt in the top level directory
4 * PROJECT: ReactOS system libraries
5 * FILE: reactos/lib/epsapi/enum/processes.c
6 * PURPOSE: Enumerate processes and threads
7 * PROGRAMMER: KJK::Hyperion <noog@libero.it>
8 * UPDATE HISTORY:
9 * 10/06/2002: Created
10 * 29/08/2002: Generalized the interface to improve reusability,
11 * more efficient use of memory operations
12 * 12/02/2003: malloc and free renamed to PsaiMalloc and PsaiFree,
13 * for better reusability. PsaEnumerateProcesses now
14 * expanded into:
15 * - PsaCaptureProcessesAndThreads
16 * - PsaFreeCapture
17 * - PsaWalkProcessesAndThreads
18 * - PsaWalkProcesses
19 * - PsaWalkThreads
20 * - PsaWalkFirstProcess
21 * - PsaWalkNextProcess
22 * - PsaWalkFirstThread
23 * - PsaWalkNextThread
24 * - PsaEnumerateProcessesAndThreads
25 * - PsaEnumerateProcesses
26 * - PsaEnumerateThreads
27 * 12/04/2003: internal PSAPI renamed EPSAPI (Extended PSAPI) and
28 * isolated in its own library to clear the confusion
29 * and improve reusability
30 */
31
32 #include "precomp.h"
33
34 #define NDEBUG
35 #include <debug.h>
36
37 NTSTATUS NTAPI
38 PsaCaptureProcessesAndThreads(OUT PSYSTEM_PROCESS_INFORMATION *ProcessesAndThreads)
39 {
40 PSYSTEM_PROCESS_INFORMATION pInfoBuffer = NULL;
41 SIZE_T nSize = 0x8000;
42 NTSTATUS Status;
43
44 if(ProcessesAndThreads == NULL)
45 {
46 return STATUS_INVALID_PARAMETER_1;
47 }
48
49 /* FIXME: if the system has loaded several processes and threads, the buffer
50 could get really big. But if there's several processes and threads, the
51 system is already under stress, and a huge buffer could only make things
52 worse. The function should be profiled to see what's the average minimum
53 buffer size, to succeed on the first shot */
54 do
55 {
56 PVOID pTmp;
57
58 /* free the buffer, and reallocate it to the new size. RATIONALE: since we
59 ignore the buffer's contents at this point, there's no point in a realloc()
60 that could end up copying a large chunk of data we'd discard anyway */
61 PsaiFree(pInfoBuffer);
62 pTmp = PsaiMalloc(nSize);
63
64 if(pTmp == NULL)
65 {
66 DPRINT(FAILED_WITH_STATUS, "PsaiMalloc", STATUS_NO_MEMORY);
67 Status = STATUS_NO_MEMORY;
68 break;
69 }
70
71 pInfoBuffer = pTmp;
72
73 /* query the information */
74 Status = NtQuerySystemInformation(SystemProcessInformation,
75 pInfoBuffer,
76 nSize,
77 NULL);
78
79 /* double the buffer size */
80 nSize *= 2;
81 } while(Status == STATUS_INFO_LENGTH_MISMATCH);
82
83 if(!NT_SUCCESS(Status))
84 {
85 DPRINT(FAILED_WITH_STATUS, "NtQuerySystemInformation", Status);
86 return Status;
87 }
88
89 *ProcessesAndThreads = pInfoBuffer;
90 return STATUS_SUCCESS;
91 }
92
93 NTSTATUS NTAPI
94 PsaWalkProcessesAndThreads(IN PSYSTEM_PROCESS_INFORMATION ProcessesAndThreads,
95 IN PPROC_ENUM_ROUTINE ProcessCallback,
96 IN OUT PVOID ProcessCallbackContext,
97 IN PTHREAD_ENUM_ROUTINE ThreadCallback,
98 IN OUT PVOID ThreadCallbackContext)
99 {
100 NTSTATUS Status;
101
102 if(ProcessCallback == NULL && ThreadCallback == NULL)
103 {
104 return STATUS_INVALID_PARAMETER;
105 }
106
107 Status = STATUS_SUCCESS;
108
109 ProcessesAndThreads = PsaWalkFirstProcess(ProcessesAndThreads);
110
111 /* scan the process list */
112 do
113 {
114 if(ProcessCallback)
115 {
116 Status = ProcessCallback(ProcessesAndThreads, ProcessCallbackContext);
117
118 if(!NT_SUCCESS(Status))
119 {
120 break;
121 }
122 }
123
124 /* if the caller provided a thread callback */
125 if(ThreadCallback)
126 {
127 ULONG i;
128 PSYSTEM_THREAD_INFORMATION pCurThread;
129
130 /* scan the current process's thread list */
131 for(i = 0, pCurThread = PsaWalkFirstThread(ProcessesAndThreads);
132 i < ProcessesAndThreads->NumberOfThreads;
133 i++, pCurThread = PsaWalkNextThread(pCurThread))
134 {
135 Status = ThreadCallback(pCurThread, ThreadCallbackContext);
136
137 if(!NT_SUCCESS(Status))
138 {
139 goto Bail;
140 }
141 }
142 }
143
144 /* move to the next process */
145 ProcessesAndThreads = PsaWalkNextProcess(ProcessesAndThreads);
146 } while(ProcessesAndThreads);
147
148 Bail:
149 return Status;
150 }
151
152 NTSTATUS NTAPI
153 PsaEnumerateProcessesAndThreads(IN PPROC_ENUM_ROUTINE ProcessCallback,
154 IN OUT PVOID ProcessCallbackContext,
155 IN PTHREAD_ENUM_ROUTINE ThreadCallback,
156 IN OUT PVOID ThreadCallbackContext)
157 {
158 PSYSTEM_PROCESS_INFORMATION pInfoBuffer = NULL;
159 NTSTATUS Status;
160
161 if(ProcessCallback == NULL && ThreadCallback == NULL)
162 {
163 return STATUS_INVALID_PARAMETER;
164 }
165
166 /* get the processes and threads list */
167 Status = PsaCaptureProcessesAndThreads(&pInfoBuffer);
168
169 if(!NT_SUCCESS(Status))
170 {
171 goto Bail;
172 }
173
174 /* walk the processes and threads list */
175 Status = PsaWalkProcessesAndThreads(pInfoBuffer,
176 ProcessCallback,
177 ProcessCallbackContext,
178 ThreadCallback,
179 ThreadCallbackContext);
180
181 Bail:
182 PsaFreeCapture(pInfoBuffer);
183
184 return Status;
185 }
186
187 VOID NTAPI
188 PsaFreeCapture(IN PVOID Capture)
189 {
190 PsaiFree(Capture);
191 }
192
193 NTSTATUS NTAPI
194 PsaWalkProcesses(IN PSYSTEM_PROCESS_INFORMATION ProcessesAndThreads,
195 IN PPROC_ENUM_ROUTINE Callback,
196 IN OUT PVOID CallbackContext)
197 {
198 return PsaWalkProcessesAndThreads(ProcessesAndThreads,
199 Callback,
200 CallbackContext,
201 NULL,
202 NULL);
203 }
204
205 NTSTATUS NTAPI
206 PsaWalkThreads(IN PSYSTEM_PROCESS_INFORMATION ProcessesAndThreads,
207 IN PTHREAD_ENUM_ROUTINE Callback,
208 IN OUT PVOID CallbackContext)
209 {
210 return PsaWalkProcessesAndThreads(ProcessesAndThreads,
211 NULL,
212 NULL,
213 Callback,
214 CallbackContext);
215 }
216
217 NTSTATUS NTAPI
218 PsaEnumerateProcesses(IN PPROC_ENUM_ROUTINE Callback,
219 IN OUT PVOID CallbackContext)
220 {
221 return PsaEnumerateProcessesAndThreads(Callback,
222 CallbackContext,
223 NULL,
224 NULL);
225 }
226
227 NTSTATUS NTAPI
228 PsaEnumerateThreads(IN PTHREAD_ENUM_ROUTINE Callback,
229 IN OUT PVOID CallbackContext)
230 {
231 return PsaEnumerateProcessesAndThreads(NULL,
232 NULL,
233 Callback,
234 CallbackContext);
235 }
236
237 PSYSTEM_PROCESS_INFORMATION FASTCALL
238 PsaWalkFirstProcess(IN PSYSTEM_PROCESS_INFORMATION ProcessesAndThreads)
239 {
240 return ProcessesAndThreads;
241 }
242
243 PSYSTEM_PROCESS_INFORMATION FASTCALL
244 PsaWalkNextProcess(IN PSYSTEM_PROCESS_INFORMATION CurrentProcess)
245 {
246 if(CurrentProcess->NextEntryOffset == 0)
247 {
248 return NULL;
249 }
250 else
251 {
252 return (PSYSTEM_PROCESS_INFORMATION)((ULONG_PTR)CurrentProcess + CurrentProcess->NextEntryOffset);
253 }
254 }
255
256 PSYSTEM_THREAD_INFORMATION FASTCALL
257 PsaWalkFirstThread(IN PSYSTEM_PROCESS_INFORMATION CurrentProcess)
258 {
259 static SIZE_T nOffsetOfThreads = 0;
260
261 /* get the offset of the Threads field */
262 nOffsetOfThreads = sizeof(SYSTEM_PROCESS_INFORMATION);
263
264 return (PSYSTEM_THREAD_INFORMATION)((ULONG_PTR)CurrentProcess + nOffsetOfThreads);
265 }
266
267 PSYSTEM_THREAD_INFORMATION FASTCALL
268 PsaWalkNextThread(IN PSYSTEM_THREAD_INFORMATION CurrentThread)
269 {
270 return (PSYSTEM_THREAD_INFORMATION)((ULONG_PTR)CurrentThread +
271 ((sizeof(SYSTEM_PROCESS_INFORMATION) + sizeof(SYSTEM_THREAD_INFORMATION)) -
272 sizeof(SYSTEM_PROCESS_INFORMATION)));
273 }
274
275 /* EOF */