5fff490868386d080b1b06d5f138bc43b454ada4
[reactos.git] / rostests / winetests / ntdll / info.c
1 /* Unit test suite for *Information* Registry API functions
2 *
3 * Copyright 2005 Paul Vriens
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 *
19 */
20
21 #include "ntdll_test.h"
22 #include <winnls.h>
23 #include <stdio.h>
24
25 static NTSTATUS (WINAPI * pNtQuerySystemInformation)(SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG);
26 static NTSTATUS (WINAPI * pNtPowerInformation)(POWER_INFORMATION_LEVEL, PVOID, ULONG, PVOID, ULONG);
27 static NTSTATUS (WINAPI * pNtQueryInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG);
28 static NTSTATUS (WINAPI * pNtQueryInformationThread)(HANDLE, THREADINFOCLASS, PVOID, ULONG, PULONG);
29 static NTSTATUS (WINAPI * pNtSetInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG);
30 static NTSTATUS (WINAPI * pNtSetInformationThread)(HANDLE, THREADINFOCLASS, PVOID, ULONG);
31 static NTSTATUS (WINAPI * pNtReadVirtualMemory)(HANDLE, const void*, void*, SIZE_T, SIZE_T*);
32 static NTSTATUS (WINAPI * pNtQueryVirtualMemory)(HANDLE, LPCVOID, MEMORY_INFORMATION_CLASS , PVOID , SIZE_T , SIZE_T *);
33 static NTSTATUS (WINAPI * pNtCreateSection)(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const LARGE_INTEGER*,ULONG,ULONG,HANDLE);
34 static NTSTATUS (WINAPI * pNtMapViewOfSection)(HANDLE,HANDLE,PVOID*,ULONG,SIZE_T,const LARGE_INTEGER*,SIZE_T*,SECTION_INHERIT,ULONG,ULONG);
35 static NTSTATUS (WINAPI * pNtUnmapViewOfSection)(HANDLE,PVOID);
36 static NTSTATUS (WINAPI * pNtClose)(HANDLE);
37 static ULONG (WINAPI * pNtGetCurrentProcessorNumber)(void);
38 static BOOL (WINAPI * pIsWow64Process)(HANDLE, PBOOL);
39
40 static BOOL is_wow64;
41
42 /* one_before_last_pid is used to be able to compare values of a still running process
43 with the output of the test_query_process_times and test_query_process_handlecount tests.
44 */
45 static DWORD one_before_last_pid = 0;
46
47 #define NTDLL_GET_PROC(func) do { \
48 p ## func = (void*)GetProcAddress(hntdll, #func); \
49 if(!p ## func) { \
50 trace("GetProcAddress(%s) failed\n", #func); \
51 return FALSE; \
52 } \
53 } while(0)
54
55 static BOOL InitFunctionPtrs(void)
56 {
57 /* All needed functions are NT based, so using GetModuleHandle is a good check */
58 HMODULE hntdll = GetModuleHandleA("ntdll");
59 if (!hntdll)
60 {
61 win_skip("Not running on NT\n");
62 return FALSE;
63 }
64
65 NTDLL_GET_PROC(NtQuerySystemInformation);
66 NTDLL_GET_PROC(NtPowerInformation);
67 NTDLL_GET_PROC(NtQueryInformationProcess);
68 NTDLL_GET_PROC(NtQueryInformationThread);
69 NTDLL_GET_PROC(NtSetInformationProcess);
70 NTDLL_GET_PROC(NtSetInformationThread);
71 NTDLL_GET_PROC(NtReadVirtualMemory);
72 NTDLL_GET_PROC(NtQueryVirtualMemory);
73 NTDLL_GET_PROC(NtClose);
74 NTDLL_GET_PROC(NtCreateSection);
75 NTDLL_GET_PROC(NtMapViewOfSection);
76 NTDLL_GET_PROC(NtUnmapViewOfSection);
77
78 /* not present before XP */
79 pNtGetCurrentProcessorNumber = (void *) GetProcAddress(hntdll, "NtGetCurrentProcessorNumber");
80
81 pIsWow64Process = (void *)GetProcAddress(GetModuleHandleA("kernel32.dll"), "IsWow64Process");
82 if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 )) is_wow64 = FALSE;
83 return TRUE;
84 }
85
86 static void test_query_basic(void)
87 {
88 NTSTATUS status;
89 ULONG ReturnLength;
90 SYSTEM_BASIC_INFORMATION sbi;
91
92 /* This test also covers some basic parameter testing that should be the same for
93 * every information class
94 */
95
96 /* Use a nonexistent info class */
97 trace("Check nonexistent info class\n");
98 status = pNtQuerySystemInformation(-1, NULL, 0, NULL);
99 ok( status == STATUS_INVALID_INFO_CLASS || status == STATUS_NOT_IMPLEMENTED /* vista */,
100 "Expected STATUS_INVALID_INFO_CLASS or STATUS_NOT_IMPLEMENTED, got %08x\n", status);
101
102 /* Use an existing class but with a zero-length buffer */
103 trace("Check zero-length buffer\n");
104 status = pNtQuerySystemInformation(SystemBasicInformation, NULL, 0, NULL);
105 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
106
107 /* Use an existing class, correct length but no SystemInformation buffer */
108 trace("Check no SystemInformation buffer\n");
109 status = pNtQuerySystemInformation(SystemBasicInformation, NULL, sizeof(sbi), NULL);
110 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER /* vista */,
111 "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER, got %08x\n", status);
112
113 /* Use an existing class, correct length, a pointer to a buffer but no ReturnLength pointer */
114 trace("Check no ReturnLength pointer\n");
115 status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), NULL);
116 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
117
118 /* Check a too large buffer size */
119 trace("Check a too large buffer size\n");
120 status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi) * 2, &ReturnLength);
121 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
122
123 /* Finally some correct calls */
124 trace("Check with correct parameters\n");
125 status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
126 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
127 ok( sizeof(sbi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
128
129 /* Check if we have some return values */
130 trace("Number of Processors : %d\n", sbi.NumberOfProcessors);
131 ok( sbi.NumberOfProcessors > 0, "Expected more than 0 processors, got %d\n", sbi.NumberOfProcessors);
132 }
133
134 static void test_query_cpu(void)
135 {
136 DWORD status;
137 ULONG ReturnLength;
138 SYSTEM_CPU_INFORMATION sci;
139
140 status = pNtQuerySystemInformation(SystemCpuInformation, &sci, sizeof(sci), &ReturnLength);
141 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
142 ok( sizeof(sci) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
143
144 /* Check if we have some return values */
145 trace("Processor FeatureSet : %08x\n", sci.FeatureSet);
146 ok( sci.FeatureSet != 0, "Expected some features for this processor, got %08x\n", sci.FeatureSet);
147 }
148
149 static void test_query_performance(void)
150 {
151 NTSTATUS status;
152 ULONG ReturnLength;
153 ULONGLONG buffer[sizeof(SYSTEM_PERFORMANCE_INFORMATION)/sizeof(ULONGLONG) + 5];
154 DWORD size = sizeof(SYSTEM_PERFORMANCE_INFORMATION);
155
156 status = pNtQuerySystemInformation(SystemPerformanceInformation, buffer, 0, &ReturnLength);
157 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
158
159 status = pNtQuerySystemInformation(SystemPerformanceInformation, buffer, size, &ReturnLength);
160 if (status == STATUS_INFO_LENGTH_MISMATCH && is_wow64)
161 {
162 /* size is larger on wow64 under w2k8/win7 */
163 size += 16;
164 status = pNtQuerySystemInformation(SystemPerformanceInformation, buffer, size, &ReturnLength);
165 }
166 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
167 ok( ReturnLength == size, "Inconsistent length %d\n", ReturnLength);
168
169 status = pNtQuerySystemInformation(SystemPerformanceInformation, buffer, size + 2, &ReturnLength);
170 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
171 ok( ReturnLength == size || ReturnLength == size + 2,
172 "Inconsistent length %d\n", ReturnLength);
173
174 /* Not return values yet, as struct members are unknown */
175 }
176
177 static void test_query_timeofday(void)
178 {
179 NTSTATUS status;
180 ULONG ReturnLength;
181
182 /* Copy of our winternl.h structure turned into a private one */
183 typedef struct _SYSTEM_TIMEOFDAY_INFORMATION_PRIVATE {
184 LARGE_INTEGER liKeBootTime;
185 LARGE_INTEGER liKeSystemTime;
186 LARGE_INTEGER liExpTimeZoneBias;
187 ULONG uCurrentTimeZoneId;
188 DWORD dwUnknown1[5];
189 } SYSTEM_TIMEOFDAY_INFORMATION_PRIVATE;
190
191 SYSTEM_TIMEOFDAY_INFORMATION_PRIVATE sti;
192
193 /* The struct size for NT (32 bytes) and Win2K/XP (48 bytes) differ.
194 *
195 * Windows 2000 and XP return STATUS_INFO_LENGTH_MISMATCH if the given buffer size is greater
196 * then 48 and 0 otherwise
197 * Windows NT returns STATUS_INFO_LENGTH_MISMATCH when the given buffer size is not correct
198 * and 0 otherwise
199 *
200 * Windows 2000 and XP copy the given buffer size into the provided buffer, if the return code is STATUS_SUCCESS
201 * NT only fills the buffer if the return code is STATUS_SUCCESS
202 *
203 */
204
205 status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, sizeof(sti), &ReturnLength);
206
207 if (status == STATUS_INFO_LENGTH_MISMATCH)
208 {
209 trace("Windows version is NT, we have to cater for differences with W2K/WinXP\n");
210
211 status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 0, &ReturnLength);
212 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
213 ok( 0 == ReturnLength, "ReturnLength should be 0, it is (%d)\n", ReturnLength);
214
215 sti.uCurrentTimeZoneId = 0xdeadbeef;
216 status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 28, &ReturnLength);
217 ok(status == STATUS_SUCCESS || broken(status == STATUS_INFO_LENGTH_MISMATCH /* NT4 */), "Expected STATUS_SUCCESS, got %08x\n", status);
218 ok( 0xdeadbeef == sti.uCurrentTimeZoneId, "This part of the buffer should not have been filled\n");
219
220 status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 32, &ReturnLength);
221 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
222 ok( 32 == ReturnLength, "ReturnLength should be 0, it is (%d)\n", ReturnLength);
223 }
224 else
225 {
226 status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 0, &ReturnLength);
227 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
228 ok( 0 == ReturnLength, "ReturnLength should be 0, it is (%d)\n", ReturnLength);
229
230 sti.uCurrentTimeZoneId = 0xdeadbeef;
231 status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 24, &ReturnLength);
232 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
233 ok( 24 == ReturnLength, "ReturnLength should be 24, it is (%d)\n", ReturnLength);
234 ok( 0xdeadbeef == sti.uCurrentTimeZoneId, "This part of the buffer should not have been filled\n");
235
236 sti.uCurrentTimeZoneId = 0xdeadbeef;
237 status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 32, &ReturnLength);
238 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
239 ok( 32 == ReturnLength, "ReturnLength should be 32, it is (%d)\n", ReturnLength);
240 ok( 0xdeadbeef != sti.uCurrentTimeZoneId, "Buffer should have been partially filled\n");
241
242 status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 49, &ReturnLength);
243 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
244 ok( ReturnLength == 0 || ReturnLength == sizeof(sti) /* vista */,
245 "ReturnLength should be 0, it is (%d)\n", ReturnLength);
246
247 status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, sizeof(sti), &ReturnLength);
248 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
249 ok( sizeof(sti) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
250 }
251
252 /* Check if we have some return values */
253 trace("uCurrentTimeZoneId : (%d)\n", sti.uCurrentTimeZoneId);
254 }
255
256 static void test_query_process(void)
257 {
258 NTSTATUS status;
259 DWORD last_pid;
260 ULONG ReturnLength;
261 int i = 0, k = 0;
262 BOOL is_nt = FALSE;
263 SYSTEM_BASIC_INFORMATION sbi;
264
265 /* Copy of our winternl.h structure turned into a private one */
266 typedef struct _SYSTEM_PROCESS_INFORMATION_PRIVATE {
267 ULONG NextEntryOffset;
268 DWORD dwThreadCount;
269 DWORD dwUnknown1[6];
270 FILETIME ftCreationTime;
271 FILETIME ftUserTime;
272 FILETIME ftKernelTime;
273 UNICODE_STRING ProcessName;
274 DWORD dwBasePriority;
275 HANDLE UniqueProcessId;
276 HANDLE ParentProcessId;
277 ULONG HandleCount;
278 DWORD dwUnknown3;
279 DWORD dwUnknown4;
280 VM_COUNTERS vmCounters;
281 IO_COUNTERS ioCounters;
282 SYSTEM_THREAD_INFORMATION ti[1];
283 } SYSTEM_PROCESS_INFORMATION_PRIVATE;
284
285 ULONG SystemInformationLength = sizeof(SYSTEM_PROCESS_INFORMATION_PRIVATE);
286 SYSTEM_PROCESS_INFORMATION_PRIVATE *spi, *spi_buf = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
287
288 /* test ReturnLength */
289 ReturnLength = 0;
290 status = pNtQuerySystemInformation(SystemProcessInformation, NULL, 0, &ReturnLength);
291 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_LENGTH_MISMATCH got %08x\n", status);
292 ok( ReturnLength > 0 || broken(ReturnLength == 0) /* NT4, Win2K */,
293 "Expected a ReturnLength to show the needed length\n");
294
295 /* W2K3 and later returns the needed length, the rest returns 0, so we have to loop */
296 for (;;)
297 {
298 status = pNtQuerySystemInformation(SystemProcessInformation, spi_buf, SystemInformationLength, &ReturnLength);
299
300 if (status != STATUS_INFO_LENGTH_MISMATCH) break;
301
302 spi_buf = HeapReAlloc(GetProcessHeap(), 0, spi_buf , SystemInformationLength *= 2);
303 }
304 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
305 spi = spi_buf;
306
307 /* Get the first NextEntryOffset, from this we can deduce the OS version we're running
308 *
309 * W2K/WinXP/W2K3:
310 * NextEntryOffset for a process is 184 + (no. of threads) * sizeof(SYSTEM_THREAD_INFORMATION)
311 * NT:
312 * NextEntryOffset for a process is 136 + (no. of threads) * sizeof(SYSTEM_THREAD_INFORMATION)
313 * Wine (with every windows version):
314 * NextEntryOffset for a process is 0 if just this test is running
315 * NextEntryOffset for a process is 184 + (no. of threads) * sizeof(SYSTEM_THREAD_INFORMATION) +
316 * ProcessName.MaximumLength
317 * if more wine processes are running
318 *
319 * Note : On windows the first process is in fact the Idle 'process' with a thread for every processor
320 */
321
322 pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
323
324 is_nt = ( spi->NextEntryOffset - (sbi.NumberOfProcessors * sizeof(SYSTEM_THREAD_INFORMATION)) == 136);
325
326 if (is_nt) win_skip("Windows version is NT, we will skip thread tests\n");
327
328 /* Check if we have some return values
329 *
330 * On windows there will be several processes running (Including the always present Idle and System)
331 * On wine we only have one (if this test is the only wine process running)
332 */
333
334 /* Loop through the processes */
335
336 for (;;)
337 {
338 i++;
339
340 last_pid = (DWORD_PTR)spi->UniqueProcessId;
341
342 ok( spi->dwThreadCount > 0, "Expected some threads for this process, got 0\n");
343
344 /* Loop through the threads, skip NT4 for now */
345
346 if (!is_nt)
347 {
348 DWORD j;
349 for ( j = 0; j < spi->dwThreadCount; j++)
350 {
351 k++;
352 ok ( spi->ti[j].ClientId.UniqueProcess == spi->UniqueProcessId,
353 "The owning pid of the thread (%p) doesn't equal the pid (%p) of the process\n",
354 spi->ti[j].ClientId.UniqueProcess, spi->UniqueProcessId);
355 }
356 }
357
358 if (!spi->NextEntryOffset) break;
359
360 one_before_last_pid = last_pid;
361
362 spi = (SYSTEM_PROCESS_INFORMATION_PRIVATE*)((char*)spi + spi->NextEntryOffset);
363 }
364 trace("Total number of running processes : %d\n", i);
365 if (!is_nt) trace("Total number of running threads : %d\n", k);
366
367 if (one_before_last_pid == 0) one_before_last_pid = last_pid;
368
369 HeapFree( GetProcessHeap(), 0, spi_buf);
370 }
371
372 static void test_query_procperf(void)
373 {
374 NTSTATUS status;
375 ULONG ReturnLength;
376 ULONG NeededLength;
377 SYSTEM_BASIC_INFORMATION sbi;
378 SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* sppi;
379
380 /* Find out the number of processors */
381 status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
382 ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
383 NeededLength = sbi.NumberOfProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
384
385 sppi = HeapAlloc(GetProcessHeap(), 0, NeededLength);
386
387 status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, 0, &ReturnLength);
388 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
389
390 /* Try it for 1 processor */
391 sppi->KernelTime.QuadPart = 0xdeaddead;
392 sppi->UserTime.QuadPart = 0xdeaddead;
393 sppi->IdleTime.QuadPart = 0xdeaddead;
394 status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi,
395 sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION), &ReturnLength);
396 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
397 ok( sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) == ReturnLength,
398 "Inconsistent length %d\n", ReturnLength);
399 ok (sppi->KernelTime.QuadPart != 0xdeaddead, "KernelTime unchanged\n");
400 ok (sppi->UserTime.QuadPart != 0xdeaddead, "UserTime unchanged\n");
401 ok (sppi->IdleTime.QuadPart != 0xdeaddead, "IdleTime unchanged\n");
402
403 /* Try it for all processors */
404 sppi->KernelTime.QuadPart = 0xdeaddead;
405 sppi->UserTime.QuadPart = 0xdeaddead;
406 sppi->IdleTime.QuadPart = 0xdeaddead;
407 status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, NeededLength, &ReturnLength);
408 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
409 ok( NeededLength == ReturnLength, "Inconsistent length (%d) <-> (%d)\n", NeededLength, ReturnLength);
410 ok (sppi->KernelTime.QuadPart != 0xdeaddead, "KernelTime unchanged\n");
411 ok (sppi->UserTime.QuadPart != 0xdeaddead, "UserTime unchanged\n");
412 ok (sppi->IdleTime.QuadPart != 0xdeaddead, "IdleTime unchanged\n");
413
414 /* A too large given buffer size */
415 sppi = HeapReAlloc(GetProcessHeap(), 0, sppi , NeededLength + 2);
416 sppi->KernelTime.QuadPart = 0xdeaddead;
417 sppi->UserTime.QuadPart = 0xdeaddead;
418 sppi->IdleTime.QuadPart = 0xdeaddead;
419 status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, NeededLength + 2, &ReturnLength);
420 ok( status == STATUS_SUCCESS || status == STATUS_INFO_LENGTH_MISMATCH /* vista */,
421 "Expected STATUS_SUCCESS or STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
422 ok( NeededLength == ReturnLength, "Inconsistent length (%d) <-> (%d)\n", NeededLength, ReturnLength);
423 if (status == STATUS_SUCCESS)
424 {
425 ok (sppi->KernelTime.QuadPart != 0xdeaddead, "KernelTime unchanged\n");
426 ok (sppi->UserTime.QuadPart != 0xdeaddead, "UserTime unchanged\n");
427 ok (sppi->IdleTime.QuadPart != 0xdeaddead, "IdleTime unchanged\n");
428 }
429 else /* vista and 2008 */
430 {
431 ok (sppi->KernelTime.QuadPart == 0xdeaddead, "KernelTime changed\n");
432 ok (sppi->UserTime.QuadPart == 0xdeaddead, "UserTime changed\n");
433 ok (sppi->IdleTime.QuadPart == 0xdeaddead, "IdleTime changed\n");
434 }
435
436 HeapFree( GetProcessHeap(), 0, sppi);
437 }
438
439 static void test_query_module(void)
440 {
441 NTSTATUS status;
442 ULONG ReturnLength;
443 ULONG ModuleCount, i;
444
445 ULONG SystemInformationLength = sizeof(SYSTEM_MODULE_INFORMATION);
446 SYSTEM_MODULE_INFORMATION* smi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
447 SYSTEM_MODULE* sm;
448
449 /* Request the needed length */
450 status = pNtQuerySystemInformation(SystemModuleInformation, smi, 0, &ReturnLength);
451 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
452 ok( ReturnLength > 0, "Expected a ReturnLength to show the needed length\n");
453
454 SystemInformationLength = ReturnLength;
455 smi = HeapReAlloc(GetProcessHeap(), 0, smi , SystemInformationLength);
456 status = pNtQuerySystemInformation(SystemModuleInformation, smi, SystemInformationLength, &ReturnLength);
457 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
458
459 ModuleCount = smi->ModulesCount;
460 sm = &smi->Modules[0];
461 /* our implementation is a stub for now */
462 ok( ModuleCount > 0, "Expected some modules to be loaded\n");
463
464 /* Loop through all the modules/drivers, Wine doesn't get here (yet) */
465 for (i = 0; i < ModuleCount ; i++)
466 {
467 ok( i == sm->Id, "Id (%d) should have matched %u\n", sm->Id, i);
468 sm++;
469 }
470
471 HeapFree( GetProcessHeap(), 0, smi);
472 }
473
474 static void test_query_handle(void)
475 {
476 NTSTATUS status;
477 ULONG ReturnLength;
478 ULONG SystemInformationLength = sizeof(SYSTEM_HANDLE_INFORMATION);
479 SYSTEM_HANDLE_INFORMATION* shi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
480
481 /* Request the needed length : a SystemInformationLength greater than one struct sets ReturnLength */
482 status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength);
483 todo_wine ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
484
485 SystemInformationLength = ReturnLength;
486 shi = HeapReAlloc(GetProcessHeap(), 0, shi , SystemInformationLength);
487 status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength);
488 if (status != STATUS_INFO_LENGTH_MISMATCH) /* vista */
489 {
490 ok( status == STATUS_SUCCESS,
491 "Expected STATUS_SUCCESS, got %08x\n", status);
492
493 /* Check if we have some return values */
494 trace("Number of Handles : %d\n", shi->Count);
495 todo_wine
496 {
497 /* our implementation is a stub for now */
498 ok( shi->Count > 1, "Expected more than 1 handles, got (%d)\n", shi->Count);
499 }
500 }
501 HeapFree( GetProcessHeap(), 0, shi);
502 }
503
504 static void test_query_cache(void)
505 {
506 NTSTATUS status;
507 ULONG ReturnLength;
508 BYTE buffer[128];
509 SYSTEM_CACHE_INFORMATION *sci = (SYSTEM_CACHE_INFORMATION *) buffer;
510 ULONG expected;
511 INT i;
512
513 /* the large SYSTEM_CACHE_INFORMATION on WIN64 is not documented */
514 expected = sizeof(SYSTEM_CACHE_INFORMATION);
515 for (i = sizeof(buffer); i>= expected; i--)
516 {
517 ReturnLength = 0xdeadbeef;
518 status = pNtQuerySystemInformation(SystemCacheInformation, sci, i, &ReturnLength);
519 ok(!status && (ReturnLength == expected),
520 "%d: got 0x%x and %u (expected STATUS_SUCCESS and %u)\n", i, status, ReturnLength, expected);
521 }
522
523 /* buffer too small for the full result.
524 Up to win7, the function succeeds with a partial result. */
525 status = pNtQuerySystemInformation(SystemCacheInformation, sci, i, &ReturnLength);
526 if (!status)
527 {
528 expected = offsetof(SYSTEM_CACHE_INFORMATION, MinimumWorkingSet);
529 for (; i>= expected; i--)
530 {
531 ReturnLength = 0xdeadbeef;
532 status = pNtQuerySystemInformation(SystemCacheInformation, sci, i, &ReturnLength);
533 ok(!status && (ReturnLength == expected),
534 "%d: got 0x%x and %u (expected STATUS_SUCCESS and %u)\n", i, status, ReturnLength, expected);
535 }
536 }
537
538 /* buffer too small for the result, this call will always fail */
539 ReturnLength = 0xdeadbeef;
540 status = pNtQuerySystemInformation(SystemCacheInformation, sci, i, &ReturnLength);
541 ok( status == STATUS_INFO_LENGTH_MISMATCH &&
542 ((ReturnLength == expected) || broken(!ReturnLength) || broken(ReturnLength == 0xfffffff0)),
543 "%d: got 0x%x and %u (expected STATUS_INFO_LENGTH_MISMATCH and %u)\n", i, status, ReturnLength, expected);
544
545 if (0) {
546 /* this crashes on some vista / win7 machines */
547 ReturnLength = 0xdeadbeef;
548 status = pNtQuerySystemInformation(SystemCacheInformation, sci, 0, &ReturnLength);
549 ok( status == STATUS_INFO_LENGTH_MISMATCH &&
550 ((ReturnLength == expected) || broken(!ReturnLength) || broken(ReturnLength == 0xfffffff0)),
551 "0: got 0x%x and %u (expected STATUS_INFO_LENGTH_MISMATCH and %u)\n", status, ReturnLength, expected);
552 }
553 }
554
555 static void test_query_interrupt(void)
556 {
557 NTSTATUS status;
558 ULONG ReturnLength;
559 ULONG NeededLength;
560 SYSTEM_BASIC_INFORMATION sbi;
561 SYSTEM_INTERRUPT_INFORMATION* sii;
562
563 /* Find out the number of processors */
564 status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
565 ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
566 NeededLength = sbi.NumberOfProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION);
567
568 sii = HeapAlloc(GetProcessHeap(), 0, NeededLength);
569
570 status = pNtQuerySystemInformation(SystemInterruptInformation, sii, 0, &ReturnLength);
571 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
572
573 /* Try it for all processors */
574 status = pNtQuerySystemInformation(SystemInterruptInformation, sii, NeededLength, &ReturnLength);
575 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
576
577 /* Windows XP and W2K3 (and others?) always return 0 for the ReturnLength
578 * No test added for this as it's highly unlikely that an app depends on this
579 */
580
581 HeapFree( GetProcessHeap(), 0, sii);
582 }
583
584 static void test_query_kerndebug(void)
585 {
586 NTSTATUS status;
587 ULONG ReturnLength;
588 SYSTEM_KERNEL_DEBUGGER_INFORMATION skdi;
589
590 status = pNtQuerySystemInformation(SystemKernelDebuggerInformation, &skdi, 0, &ReturnLength);
591 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
592
593 status = pNtQuerySystemInformation(SystemKernelDebuggerInformation, &skdi, sizeof(skdi), &ReturnLength);
594 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
595 ok( sizeof(skdi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
596
597 status = pNtQuerySystemInformation(SystemKernelDebuggerInformation, &skdi, sizeof(skdi) + 2, &ReturnLength);
598 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
599 ok( sizeof(skdi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
600 }
601
602 static void test_query_regquota(void)
603 {
604 NTSTATUS status;
605 ULONG ReturnLength;
606 SYSTEM_REGISTRY_QUOTA_INFORMATION srqi;
607
608 status = pNtQuerySystemInformation(SystemRegistryQuotaInformation, &srqi, 0, &ReturnLength);
609 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
610
611 status = pNtQuerySystemInformation(SystemRegistryQuotaInformation, &srqi, sizeof(srqi), &ReturnLength);
612 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
613 ok( sizeof(srqi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
614
615 status = pNtQuerySystemInformation(SystemRegistryQuotaInformation, &srqi, sizeof(srqi) + 2, &ReturnLength);
616 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
617 ok( sizeof(srqi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
618 }
619
620 static void test_query_logicalproc(void)
621 {
622 NTSTATUS status;
623 ULONG len, i, proc_no;
624 SYSTEM_LOGICAL_PROCESSOR_INFORMATION *slpi;
625 SYSTEM_INFO si;
626
627 GetSystemInfo(&si);
628
629 status = pNtQuerySystemInformation(SystemLogicalProcessorInformation, NULL, 0, &len);
630 if(status == STATUS_INVALID_INFO_CLASS)
631 {
632 win_skip("SystemLogicalProcessorInformation is not supported\n");
633 return;
634 }
635 if(status == STATUS_NOT_IMPLEMENTED)
636 {
637 todo_wine ok(0, "SystemLogicalProcessorInformation is not implemented\n");
638 return;
639 }
640 ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
641 ok(len%sizeof(*slpi) == 0, "Incorrect length %d\n", len);
642
643 slpi = HeapAlloc(GetProcessHeap(), 0, len);
644 status = pNtQuerySystemInformation(SystemLogicalProcessorInformation, slpi, len, &len);
645 ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
646
647 proc_no = 0;
648 for(i=0; i<len/sizeof(*slpi); i++) {
649 switch(slpi[i].Relationship) {
650 case RelationProcessorCore:
651 /* Get number of logical processors */
652 for(; slpi[i].ProcessorMask; slpi[i].ProcessorMask /= 2)
653 proc_no += slpi[i].ProcessorMask%2;
654 break;
655 default:
656 break;
657 }
658 }
659 ok(proc_no > 0, "No processors were found\n");
660 if(si.dwNumberOfProcessors <= 32)
661 ok(proc_no == si.dwNumberOfProcessors, "Incorrect number of logical processors: %d, expected %d\n",
662 proc_no, si.dwNumberOfProcessors);
663
664 HeapFree(GetProcessHeap(), 0, slpi);
665 }
666
667 static void test_query_processor_power_info(void)
668 {
669 NTSTATUS status;
670 PROCESSOR_POWER_INFORMATION* ppi;
671 ULONG size;
672 SYSTEM_INFO si;
673 int i;
674
675 GetSystemInfo(&si);
676 size = si.dwNumberOfProcessors * sizeof(PROCESSOR_POWER_INFORMATION);
677 ppi = HeapAlloc(GetProcessHeap(), 0, size);
678
679 /* If size < (sizeof(PROCESSOR_POWER_INFORMATION) * NumberOfProcessors), Win7 returns
680 * STATUS_BUFFER_TOO_SMALL. WinXP returns STATUS_SUCCESS for any value of size. It copies as
681 * many whole PROCESSOR_POWER_INFORMATION structures that there is room for. Even if there is
682 * not enough room for one structure, WinXP still returns STATUS_SUCCESS having done nothing.
683 *
684 * If ppi == NULL, Win7 returns STATUS_INVALID_PARAMETER while WinXP returns STATUS_SUCCESS
685 * and does nothing.
686 *
687 * The same behavior is seen with CallNtPowerInformation (in powrprof.dll).
688 */
689
690 if (si.dwNumberOfProcessors > 1)
691 {
692 for(i = 0; i < si.dwNumberOfProcessors; i++)
693 ppi[i].Number = 0xDEADBEEF;
694
695 /* Call with a buffer size that is large enough to hold at least one but not large
696 * enough to hold them all. This will be STATUS_SUCCESS on WinXP but not on Win7 */
697 status = pNtPowerInformation(ProcessorInformation, 0, 0, ppi, size - sizeof(PROCESSOR_POWER_INFORMATION));
698 if (status == STATUS_SUCCESS)
699 {
700 /* lax version found on older Windows like WinXP */
701 ok( (ppi[si.dwNumberOfProcessors - 2].Number != 0xDEADBEEF) &&
702 (ppi[si.dwNumberOfProcessors - 1].Number == 0xDEADBEEF),
703 "Expected all but the last record to be overwritten.\n");
704
705 status = pNtPowerInformation(ProcessorInformation, 0, 0, 0, size);
706 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
707
708 for(i = 0; i < si.dwNumberOfProcessors; i++)
709 ppi[i].Number = 0xDEADBEEF;
710 status = pNtPowerInformation(ProcessorInformation, 0, 0, ppi, sizeof(PROCESSOR_POWER_INFORMATION) - 1);
711 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
712 for(i = 0; i < si.dwNumberOfProcessors; i++)
713 if (ppi[i].Number != 0xDEADBEEF) break;
714 ok( i == si.dwNumberOfProcessors, "Expected untouched buffer\n");
715 }
716 else
717 {
718 /* picky version found on newer Windows like Win7 */
719 ok( ppi[1].Number == 0xDEADBEEF, "Expected untouched buffer.\n");
720 ok( status == STATUS_BUFFER_TOO_SMALL, "Expected STATUS_BUFFER_TOO_SMALL, got %08x\n", status);
721
722 status = pNtPowerInformation(ProcessorInformation, 0, 0, 0, size);
723 ok( status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER, "Got %08x\n", status);
724
725 status = pNtPowerInformation(ProcessorInformation, 0, 0, ppi, 0);
726 ok( status == STATUS_BUFFER_TOO_SMALL || status == STATUS_INVALID_PARAMETER, "Got %08x\n", status);
727 }
728 }
729 else
730 {
731 skip("Test needs more than one processor.\n");
732 }
733
734 status = pNtPowerInformation(ProcessorInformation, 0, 0, ppi, size);
735 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
736
737 HeapFree(GetProcessHeap(), 0, ppi);
738 }
739
740 static void test_query_process_wow64(void)
741 {
742 NTSTATUS status;
743 ULONG ReturnLength;
744 ULONG_PTR pbi[2], dummy;
745
746 memset(&dummy, 0xcc, sizeof(dummy));
747
748 /* Do not give a handle and buffer */
749 status = pNtQueryInformationProcess(NULL, ProcessWow64Information, NULL, 0, NULL);
750 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
751
752 /* Use a correct info class and buffer size, but still no handle and buffer */
753 status = pNtQueryInformationProcess(NULL, ProcessWow64Information, NULL, sizeof(ULONG_PTR), NULL);
754 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
755 "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE, got %08x\n", status);
756
757 /* Use a correct info class, buffer size and handle, but no buffer */
758 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, NULL, sizeof(ULONG_PTR), NULL);
759 ok( status == STATUS_ACCESS_VIOLATION , "Expected STATUS_ACCESS_VIOLATION, got %08x\n", status);
760
761 /* Use a correct info class, buffer and buffer size, but no handle */
762 pbi[0] = pbi[1] = dummy;
763 status = pNtQueryInformationProcess(NULL, ProcessWow64Information, pbi, sizeof(ULONG_PTR), NULL);
764 ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
765 ok( pbi[0] == dummy, "pbi[0] changed to %lx\n", pbi[0]);
766 ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
767
768 /* Use a greater buffer size */
769 pbi[0] = pbi[1] = dummy;
770 status = pNtQueryInformationProcess(NULL, ProcessWow64Information, pbi, sizeof(ULONG_PTR) + 1, NULL);
771 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
772 ok( pbi[0] == dummy, "pbi[0] changed to %lx\n", pbi[0]);
773 ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
774
775 /* Use no ReturnLength */
776 pbi[0] = pbi[1] = dummy;
777 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, pbi, sizeof(ULONG_PTR), NULL);
778 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
779 trace( "Platform is_wow64 %d, ProcessInformation of ProcessWow64Information %lx\n", is_wow64, pbi[0]);
780 ok( is_wow64 == (pbi[0] != 0), "is_wow64 %x, pbi[0] %lx\n", is_wow64, pbi[0]);
781 ok( pbi[0] != dummy, "pbi[0] %lx\n", pbi[0]);
782 ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
783 /* Test written size on 64 bit by checking high 32 bit buffer */
784 if (sizeof(ULONG_PTR) > sizeof(DWORD))
785 {
786 DWORD *ptr = (DWORD *)pbi;
787 ok( ptr[1] != (DWORD)dummy, "ptr[1] unchanged!\n");
788 }
789
790 /* Finally some correct calls */
791 pbi[0] = pbi[1] = dummy;
792 ReturnLength = 0xdeadbeef;
793 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, pbi, sizeof(ULONG_PTR), &ReturnLength);
794 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
795 ok( is_wow64 == (pbi[0] != 0), "is_wow64 %x, pbi[0] %lx\n", is_wow64, pbi[0]);
796 ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
797 ok( ReturnLength == sizeof(ULONG_PTR), "Inconsistent length %d\n", ReturnLength);
798
799 /* Everything is correct except a too small buffer size */
800 pbi[0] = pbi[1] = dummy;
801 ReturnLength = 0xdeadbeef;
802 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, pbi, sizeof(ULONG_PTR) - 1, &ReturnLength);
803 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
804 ok( pbi[0] == dummy, "pbi[0] changed to %lx\n", pbi[0]);
805 ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
806 todo_wine ok( ReturnLength == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", ReturnLength);
807
808 /* Everything is correct except a too large buffer size */
809 pbi[0] = pbi[1] = dummy;
810 ReturnLength = 0xdeadbeef;
811 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, pbi, sizeof(ULONG_PTR) + 1, &ReturnLength);
812 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
813 ok( pbi[0] == dummy, "pbi[0] changed to %lx\n", pbi[0]);
814 ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
815 todo_wine ok( ReturnLength == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", ReturnLength);
816 }
817
818 static void test_query_process_basic(void)
819 {
820 NTSTATUS status;
821 ULONG ReturnLength;
822
823 typedef struct _PROCESS_BASIC_INFORMATION_PRIVATE {
824 DWORD_PTR ExitStatus;
825 PPEB PebBaseAddress;
826 DWORD_PTR AffinityMask;
827 DWORD_PTR BasePriority;
828 ULONG_PTR UniqueProcessId;
829 ULONG_PTR InheritedFromUniqueProcessId;
830 } PROCESS_BASIC_INFORMATION_PRIVATE;
831
832 PROCESS_BASIC_INFORMATION_PRIVATE pbi;
833
834 /* This test also covers some basic parameter testing that should be the same for
835 * every information class
836 */
837
838 /* Use a nonexistent info class */
839 trace("Check nonexistent info class\n");
840 status = pNtQueryInformationProcess(NULL, -1, NULL, 0, NULL);
841 ok( status == STATUS_INVALID_INFO_CLASS || status == STATUS_NOT_IMPLEMENTED /* vista */,
842 "Expected STATUS_INVALID_INFO_CLASS or STATUS_NOT_IMPLEMENTED, got %08x\n", status);
843
844 /* Do not give a handle and buffer */
845 trace("Check NULL handle and buffer and zero-length buffersize\n");
846 status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, NULL, 0, NULL);
847 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
848
849 /* Use a correct info class and buffer size, but still no handle and buffer */
850 trace("Check NULL handle and buffer\n");
851 status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, NULL, sizeof(pbi), NULL);
852 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
853 "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08x\n", status);
854
855 /* Use a correct info class and buffer size, but still no handle */
856 trace("Check NULL handle\n");
857 status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
858 ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
859
860 /* Use a greater buffer size */
861 trace("Check NULL handle and too large buffersize\n");
862 status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, &pbi, sizeof(pbi) * 2, NULL);
863 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
864
865 /* Use no ReturnLength */
866 trace("Check NULL ReturnLength\n");
867 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
868 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
869
870 /* Finally some correct calls */
871 trace("Check with correct parameters\n");
872 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), &ReturnLength);
873 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
874 ok( sizeof(pbi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
875
876 /* Everything is correct except a too large buffersize */
877 trace("Too large buffersize\n");
878 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi) * 2, &ReturnLength);
879 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
880 ok( sizeof(pbi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
881
882 /* Check if we have some return values */
883 trace("ProcessID : %lx\n", pbi.UniqueProcessId);
884 ok( pbi.UniqueProcessId > 0, "Expected a ProcessID > 0, got 0\n");
885 }
886
887 static void test_query_process_vm(void)
888 {
889 NTSTATUS status;
890 ULONG ReturnLength;
891 VM_COUNTERS pvi;
892 ULONG old_size = FIELD_OFFSET(VM_COUNTERS,PrivatePageCount);
893
894 status = pNtQueryInformationProcess(NULL, ProcessVmCounters, NULL, sizeof(pvi), NULL);
895 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
896 "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08x\n", status);
897
898 status = pNtQueryInformationProcess(NULL, ProcessVmCounters, &pvi, old_size, NULL);
899 ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
900
901 /* Windows XP and W2K3 will report success for a size of 44 AND 48 !
902 Windows W2K will only report success for 44.
903 For now we only care for 44, which is FIELD_OFFSET(VM_COUNTERS,PrivatePageCount))
904 */
905
906 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &pvi, 24, &ReturnLength);
907 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
908
909 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &pvi, old_size, &ReturnLength);
910 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
911 ok( old_size == ReturnLength, "Inconsistent length %d\n", ReturnLength);
912
913 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &pvi, 46, &ReturnLength);
914 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
915 ok( ReturnLength == old_size || ReturnLength == sizeof(pvi), "Inconsistent length %d\n", ReturnLength);
916
917 /* Check if we have some return values */
918 trace("WorkingSetSize : %ld\n", pvi.WorkingSetSize);
919 todo_wine
920 {
921 ok( pvi.WorkingSetSize > 0, "Expected a WorkingSetSize > 0\n");
922 }
923 }
924
925 static void test_query_process_io(void)
926 {
927 NTSTATUS status;
928 ULONG ReturnLength;
929 IO_COUNTERS pii;
930
931 /* NT4 doesn't support this information class, so check for it */
932 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, sizeof(pii), &ReturnLength);
933 if (status == STATUS_NOT_SUPPORTED)
934 {
935 win_skip("ProcessIoCounters information class is not supported\n");
936 return;
937 }
938
939 status = pNtQueryInformationProcess(NULL, ProcessIoCounters, NULL, sizeof(pii), NULL);
940 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
941 "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08x\n", status);
942
943 status = pNtQueryInformationProcess(NULL, ProcessIoCounters, &pii, sizeof(pii), NULL);
944 ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
945
946 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, 24, &ReturnLength);
947 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
948
949 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, sizeof(pii), &ReturnLength);
950 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
951 ok( sizeof(pii) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
952
953 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, sizeof(pii) * 2, &ReturnLength);
954 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
955 ok( sizeof(pii) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
956
957 /* Check if we have some return values */
958 trace("OtherOperationCount : 0x%x%08x\n", (DWORD)(pii.OtherOperationCount >> 32), (DWORD)pii.OtherOperationCount);
959 todo_wine
960 {
961 ok( pii.OtherOperationCount > 0, "Expected an OtherOperationCount > 0\n");
962 }
963 }
964
965 static void test_query_process_times(void)
966 {
967 NTSTATUS status;
968 ULONG ReturnLength;
969 HANDLE process;
970 SYSTEMTIME UTC, Local;
971 KERNEL_USER_TIMES spti;
972
973 status = pNtQueryInformationProcess(NULL, ProcessTimes, NULL, sizeof(spti), NULL);
974 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
975 "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08x\n", status);
976
977 status = pNtQueryInformationProcess(NULL, ProcessTimes, &spti, sizeof(spti), NULL);
978 ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
979
980 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessTimes, &spti, 24, &ReturnLength);
981 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
982
983 process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, one_before_last_pid);
984 if (!process)
985 {
986 trace("Could not open process with ID : %d, error : %u. Going to use current one.\n", one_before_last_pid, GetLastError());
987 process = GetCurrentProcess();
988 trace("ProcessTimes for current process\n");
989 }
990 else
991 trace("ProcessTimes for process with ID : %d\n", one_before_last_pid);
992
993 status = pNtQueryInformationProcess( process, ProcessTimes, &spti, sizeof(spti), &ReturnLength);
994 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
995 ok( sizeof(spti) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
996 CloseHandle(process);
997
998 FileTimeToSystemTime((const FILETIME *)&spti.CreateTime, &UTC);
999 SystemTimeToTzSpecificLocalTime(NULL, &UTC, &Local);
1000 trace("CreateTime : %02d/%02d/%04d %02d:%02d:%02d\n", Local.wMonth, Local.wDay, Local.wYear,
1001 Local.wHour, Local.wMinute, Local.wSecond);
1002
1003 FileTimeToSystemTime((const FILETIME *)&spti.ExitTime, &UTC);
1004 SystemTimeToTzSpecificLocalTime(NULL, &UTC, &Local);
1005 trace("ExitTime : %02d/%02d/%04d %02d:%02d:%02d\n", Local.wMonth, Local.wDay, Local.wYear,
1006 Local.wHour, Local.wMinute, Local.wSecond);
1007
1008 FileTimeToSystemTime((const FILETIME *)&spti.KernelTime, &Local);
1009 trace("KernelTime : %02d:%02d:%02d.%03d\n", Local.wHour, Local.wMinute, Local.wSecond, Local.wMilliseconds);
1010
1011 FileTimeToSystemTime((const FILETIME *)&spti.UserTime, &Local);
1012 trace("UserTime : %02d:%02d:%02d.%03d\n", Local.wHour, Local.wMinute, Local.wSecond, Local.wMilliseconds);
1013
1014 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessTimes, &spti, sizeof(spti) * 2, &ReturnLength);
1015 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1016 ok( sizeof(spti) == ReturnLength ||
1017 ReturnLength == 0 /* vista */ ||
1018 broken(is_wow64), /* returns garbage on wow64 */
1019 "Inconsistent length %d\n", ReturnLength);
1020 }
1021
1022 static void test_query_process_debug_port(int argc, char **argv)
1023 {
1024 DWORD_PTR debug_port = 0xdeadbeef;
1025 char cmdline[MAX_PATH];
1026 PROCESS_INFORMATION pi;
1027 STARTUPINFOA si = { 0 };
1028 NTSTATUS status;
1029 BOOL ret;
1030
1031 sprintf(cmdline, "%s %s %s", argv[0], argv[1], "debuggee");
1032
1033 si.cb = sizeof(si);
1034 ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, DEBUG_PROCESS, NULL, NULL, &si, &pi);
1035 ok(ret, "CreateProcess failed, last error %#x.\n", GetLastError());
1036 if (!ret) return;
1037
1038 status = pNtQueryInformationProcess(NULL, ProcessDebugPort,
1039 NULL, 0, NULL);
1040 ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1041
1042 status = pNtQueryInformationProcess(NULL, ProcessDebugPort,
1043 NULL, sizeof(debug_port), NULL);
1044 ok(status == STATUS_INVALID_HANDLE || status == STATUS_ACCESS_VIOLATION,
1045 "Expected STATUS_INVALID_HANDLE, got %#x.\n", status);
1046
1047 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
1048 NULL, sizeof(debug_port), NULL);
1049 ok(status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got %#x.\n", status);
1050
1051 status = pNtQueryInformationProcess(NULL, ProcessDebugPort,
1052 &debug_port, sizeof(debug_port), NULL);
1053 ok(status == STATUS_INVALID_HANDLE, "Expected STATUS_ACCESS_VIOLATION, got %#x.\n", status);
1054
1055 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
1056 &debug_port, sizeof(debug_port) - 1, NULL);
1057 ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1058
1059 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
1060 &debug_port, sizeof(debug_port) + 1, NULL);
1061 ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1062
1063 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
1064 &debug_port, sizeof(debug_port), NULL);
1065 ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status);
1066 ok(debug_port == 0, "Expected port 0, got %#lx.\n", debug_port);
1067
1068 status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugPort,
1069 &debug_port, sizeof(debug_port), NULL);
1070 ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status);
1071 ok(debug_port == ~(DWORD_PTR)0, "Expected port %#lx, got %#lx.\n", ~(DWORD_PTR)0, debug_port);
1072
1073 for (;;)
1074 {
1075 DEBUG_EVENT ev;
1076
1077 ret = WaitForDebugEvent(&ev, INFINITE);
1078 ok(ret, "WaitForDebugEvent failed, last error %#x.\n", GetLastError());
1079 if (!ret) break;
1080
1081 if (ev.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) break;
1082
1083 ret = ContinueDebugEvent(ev.dwProcessId, ev.dwThreadId, DBG_CONTINUE);
1084 ok(ret, "ContinueDebugEvent failed, last error %#x.\n", GetLastError());
1085 if (!ret) break;
1086 }
1087
1088 ret = CloseHandle(pi.hThread);
1089 ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError());
1090 ret = CloseHandle(pi.hProcess);
1091 ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError());
1092 }
1093
1094 static void test_query_process_handlecount(void)
1095 {
1096 NTSTATUS status;
1097 ULONG ReturnLength;
1098 DWORD handlecount;
1099 BYTE buffer[2 * sizeof(DWORD)];
1100 HANDLE process;
1101
1102 status = pNtQueryInformationProcess(NULL, ProcessHandleCount, NULL, sizeof(handlecount), NULL);
1103 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
1104 "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08x\n", status);
1105
1106 status = pNtQueryInformationProcess(NULL, ProcessHandleCount, &handlecount, sizeof(handlecount), NULL);
1107 ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
1108
1109 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessHandleCount, &handlecount, 2, &ReturnLength);
1110 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1111
1112 process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, one_before_last_pid);
1113 if (!process)
1114 {
1115 trace("Could not open process with ID : %d, error : %u. Going to use current one.\n", one_before_last_pid, GetLastError());
1116 process = GetCurrentProcess();
1117 trace("ProcessHandleCount for current process\n");
1118 }
1119 else
1120 trace("ProcessHandleCount for process with ID : %d\n", one_before_last_pid);
1121
1122 status = pNtQueryInformationProcess( process, ProcessHandleCount, &handlecount, sizeof(handlecount), &ReturnLength);
1123 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1124 ok( sizeof(handlecount) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
1125 CloseHandle(process);
1126
1127 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessHandleCount, buffer, sizeof(buffer), &ReturnLength);
1128 ok( status == STATUS_INFO_LENGTH_MISMATCH || status == STATUS_SUCCESS,
1129 "Expected STATUS_INFO_LENGTH_MISMATCH or STATUS_SUCCESS, got %08x\n", status);
1130 ok( sizeof(handlecount) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
1131
1132 /* Check if we have some return values */
1133 trace("HandleCount : %d\n", handlecount);
1134 todo_wine
1135 {
1136 ok( handlecount > 0, "Expected some handles, got 0\n");
1137 }
1138 }
1139
1140 static void test_query_process_image_file_name(void)
1141 {
1142 NTSTATUS status;
1143 ULONG ReturnLength;
1144 UNICODE_STRING image_file_name;
1145 void *buffer;
1146 char *file_nameA;
1147 INT len;
1148
1149 status = pNtQueryInformationProcess(NULL, ProcessImageFileName, &image_file_name, sizeof(image_file_name), NULL);
1150 if (status == STATUS_INVALID_INFO_CLASS)
1151 {
1152 win_skip("ProcessImageFileName is not supported\n");
1153 return;
1154 }
1155 ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
1156
1157 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessImageFileName, &image_file_name, 2, &ReturnLength);
1158 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1159
1160 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessImageFileName, &image_file_name, sizeof(image_file_name), &ReturnLength);
1161 ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1162
1163 buffer = HeapAlloc(GetProcessHeap(), 0, ReturnLength);
1164 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessImageFileName, buffer, ReturnLength, &ReturnLength);
1165 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1166 memcpy(&image_file_name, buffer, sizeof(image_file_name));
1167 len = WideCharToMultiByte(CP_ACP, 0, image_file_name.Buffer, image_file_name.Length/sizeof(WCHAR), NULL, 0, NULL, NULL);
1168 file_nameA = HeapAlloc(GetProcessHeap(), 0, len + 1);
1169 WideCharToMultiByte(CP_ACP, 0, image_file_name.Buffer, image_file_name.Length/sizeof(WCHAR), file_nameA, len, NULL, NULL);
1170 file_nameA[len] = '\0';
1171 HeapFree(GetProcessHeap(), 0, buffer);
1172 trace("process image file name: %s\n", file_nameA);
1173 todo_wine ok(strncmp(file_nameA, "\\Device\\", 8) == 0, "Process image name should be an NT path beginning with \\Device\\ (is %s)\n", file_nameA);
1174 HeapFree(GetProcessHeap(), 0, file_nameA);
1175 }
1176
1177 static void test_query_process_debug_object_handle(int argc, char **argv)
1178 {
1179 char cmdline[MAX_PATH];
1180 STARTUPINFOA si = {0};
1181 PROCESS_INFORMATION pi;
1182 BOOL ret;
1183 HANDLE debug_object;
1184 NTSTATUS status;
1185
1186 sprintf(cmdline, "%s %s %s", argv[0], argv[1], "debuggee");
1187
1188 si.cb = sizeof(si);
1189 ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, DEBUG_PROCESS, NULL,
1190 NULL, &si, &pi);
1191 ok(ret, "CreateProcess failed with last error %u\n", GetLastError());
1192 if (!ret) return;
1193
1194 status = pNtQueryInformationProcess(NULL, ProcessDebugObjectHandle, NULL,
1195 0, NULL);
1196 if (status == STATUS_INVALID_INFO_CLASS || status == STATUS_NOT_IMPLEMENTED)
1197 {
1198 win_skip("ProcessDebugObjectHandle is not supported\n");
1199 return;
1200 }
1201 ok(status == STATUS_INFO_LENGTH_MISMATCH,
1202 "Expected NtQueryInformationProcess to return STATUS_INFO_LENGTH_MISMATCH, got 0x%08x\n",
1203 status);
1204
1205 status = pNtQueryInformationProcess(NULL, ProcessDebugObjectHandle, NULL,
1206 sizeof(debug_object), NULL);
1207 ok(status == STATUS_INVALID_HANDLE ||
1208 status == STATUS_ACCESS_VIOLATION, /* XP */
1209 "Expected NtQueryInformationProcess to return STATUS_INVALID_HANDLE, got 0x%08x\n", status);
1210
1211 status = pNtQueryInformationProcess(GetCurrentProcess(),
1212 ProcessDebugObjectHandle, NULL, sizeof(debug_object), NULL);
1213 ok(status == STATUS_ACCESS_VIOLATION,
1214 "Expected NtQueryInformationProcess to return STATUS_ACCESS_VIOLATION, got 0x%08x\n", status);
1215
1216 status = pNtQueryInformationProcess(NULL, ProcessDebugObjectHandle,
1217 &debug_object, sizeof(debug_object), NULL);
1218 ok(status == STATUS_INVALID_HANDLE,
1219 "Expected NtQueryInformationProcess to return STATUS_ACCESS_VIOLATION, got 0x%08x\n", status);
1220
1221 status = pNtQueryInformationProcess(GetCurrentProcess(),
1222 ProcessDebugObjectHandle, &debug_object,
1223 sizeof(debug_object) - 1, NULL);
1224 ok(status == STATUS_INFO_LENGTH_MISMATCH,
1225 "Expected NtQueryInformationProcess to return STATUS_INFO_LENGTH_MISMATCH, got 0x%08x\n", status);
1226
1227 status = pNtQueryInformationProcess(GetCurrentProcess(),
1228 ProcessDebugObjectHandle, &debug_object,
1229 sizeof(debug_object) + 1, NULL);
1230 ok(status == STATUS_INFO_LENGTH_MISMATCH,
1231 "Expected NtQueryInformationProcess to return STATUS_INFO_LENGTH_MISMATCH, got 0x%08x\n", status);
1232
1233 debug_object = (HANDLE)0xdeadbeef;
1234 status = pNtQueryInformationProcess(GetCurrentProcess(),
1235 ProcessDebugObjectHandle, &debug_object,
1236 sizeof(debug_object), NULL);
1237 ok(status == STATUS_PORT_NOT_SET,
1238 "Expected NtQueryInformationProcess to return STATUS_PORT_NOT_SET, got 0x%08x\n", status);
1239 ok(debug_object == NULL ||
1240 broken(debug_object == (HANDLE)0xdeadbeef), /* Wow64 */
1241 "Expected debug object handle to be NULL, got %p\n", debug_object);
1242
1243 debug_object = (HANDLE)0xdeadbeef;
1244 status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugObjectHandle,
1245 &debug_object, sizeof(debug_object), NULL);
1246 todo_wine
1247 ok(status == STATUS_SUCCESS,
1248 "Expected NtQueryInformationProcess to return STATUS_SUCCESS, got 0x%08x\n", status);
1249 todo_wine
1250 ok(debug_object != NULL,
1251 "Expected debug object handle to be non-NULL, got %p\n", debug_object);
1252
1253 for (;;)
1254 {
1255 DEBUG_EVENT ev;
1256
1257 ret = WaitForDebugEvent(&ev, INFINITE);
1258 ok(ret, "WaitForDebugEvent failed with last error %u\n", GetLastError());
1259 if (!ret) break;
1260
1261 if (ev.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) break;
1262
1263 ret = ContinueDebugEvent(ev.dwProcessId, ev.dwThreadId, DBG_CONTINUE);
1264 ok(ret, "ContinueDebugEvent failed with last error %u\n", GetLastError());
1265 if (!ret) break;
1266 }
1267
1268 ret = CloseHandle(pi.hThread);
1269 ok(ret, "CloseHandle failed with last error %u\n", GetLastError());
1270 ret = CloseHandle(pi.hProcess);
1271 ok(ret, "CloseHandle failed with last error %u\n", GetLastError());
1272 }
1273
1274 static void test_query_process_debug_flags(int argc, char **argv)
1275 {
1276 DWORD debug_flags = 0xdeadbeef;
1277 char cmdline[MAX_PATH];
1278 PROCESS_INFORMATION pi;
1279 STARTUPINFOA si = { 0 };
1280 NTSTATUS status;
1281 BOOL ret;
1282
1283 sprintf(cmdline, "%s %s %s", argv[0], argv[1], "debuggee");
1284
1285 si.cb = sizeof(si);
1286 ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS, NULL, NULL, &si, &pi);
1287 ok(ret, "CreateProcess failed, last error %#x.\n", GetLastError());
1288 if (!ret) return;
1289
1290 status = pNtQueryInformationProcess(NULL, ProcessDebugFlags,
1291 NULL, 0, NULL);
1292 ok(status == STATUS_INFO_LENGTH_MISMATCH || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1293
1294 status = pNtQueryInformationProcess(NULL, ProcessDebugFlags,
1295 NULL, sizeof(debug_flags), NULL);
1296 ok(status == STATUS_INVALID_HANDLE || status == STATUS_ACCESS_VIOLATION || broken(status == STATUS_INVALID_INFO_CLASS) /* W7PROX64 (32-bit) */,
1297 "Expected STATUS_INVALID_HANDLE, got %#x.\n", status);
1298
1299 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags,
1300 NULL, sizeof(debug_flags), NULL);
1301 ok(status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got %#x.\n", status);
1302
1303 status = pNtQueryInformationProcess(NULL, ProcessDebugFlags,
1304 &debug_flags, sizeof(debug_flags), NULL);
1305 ok(status == STATUS_INVALID_HANDLE || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected STATUS_ACCESS_VIOLATION, got %#x.\n", status);
1306
1307 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags,
1308 &debug_flags, sizeof(debug_flags) - 1, NULL);
1309 ok(status == STATUS_INFO_LENGTH_MISMATCH || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1310
1311 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags,
1312 &debug_flags, sizeof(debug_flags) + 1, NULL);
1313 ok(status == STATUS_INFO_LENGTH_MISMATCH || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1314
1315 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags,
1316 &debug_flags, sizeof(debug_flags), NULL);
1317 ok(!status || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "NtQueryInformationProcess failed, status %#x.\n", status);
1318 ok(debug_flags == TRUE|| broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected flag TRUE, got %x.\n", debug_flags);
1319
1320 status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags,
1321 &debug_flags, sizeof(debug_flags), NULL);
1322 ok(!status || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "NtQueryInformationProcess failed, status %#x.\n", status);
1323 ok(debug_flags == FALSE || broken(status == STATUS_INVALID_INFO_CLASS) /* NT4 */, "Expected flag FALSE, got %x.\n", debug_flags);
1324
1325 for (;;)
1326 {
1327 DEBUG_EVENT ev;
1328
1329 ret = WaitForDebugEvent(&ev, INFINITE);
1330 ok(ret, "WaitForDebugEvent failed, last error %#x.\n", GetLastError());
1331 if (!ret) break;
1332
1333 if (ev.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) break;
1334
1335 ret = ContinueDebugEvent(ev.dwProcessId, ev.dwThreadId, DBG_CONTINUE);
1336 ok(ret, "ContinueDebugEvent failed, last error %#x.\n", GetLastError());
1337 if (!ret) break;
1338 }
1339
1340 ret = CloseHandle(pi.hThread);
1341 ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError());
1342 ret = CloseHandle(pi.hProcess);
1343 ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError());
1344 }
1345
1346 static void test_readvirtualmemory(void)
1347 {
1348 HANDLE process;
1349 NTSTATUS status;
1350 SIZE_T readcount;
1351 static const char teststring[] = "test string";
1352 char buffer[12];
1353
1354 process = OpenProcess(PROCESS_VM_READ, FALSE, GetCurrentProcessId());
1355 ok(process != 0, "Expected to be able to open own process for reading memory\n");
1356
1357 /* normal operation */
1358 status = pNtReadVirtualMemory(process, teststring, buffer, 12, &readcount);
1359 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1360 ok( readcount == 12, "Expected to read 12 bytes, got %ld\n",readcount);
1361 ok( strcmp(teststring, buffer) == 0, "Expected read memory to be the same as original memory\n");
1362
1363 /* no number of bytes */
1364 memset(buffer, 0, 12);
1365 status = pNtReadVirtualMemory(process, teststring, buffer, 12, NULL);
1366 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1367 ok( strcmp(teststring, buffer) == 0, "Expected read memory to be the same as original memory\n");
1368
1369 /* illegal remote address */
1370 todo_wine{
1371 status = pNtReadVirtualMemory(process, (void *) 0x1234, buffer, 12, &readcount);
1372 ok( status == STATUS_PARTIAL_COPY || broken(status == STATUS_ACCESS_VIOLATION), "Expected STATUS_PARTIAL_COPY, got %08x\n", status);
1373 if (status == STATUS_PARTIAL_COPY)
1374 ok( readcount == 0, "Expected to read 0 bytes, got %ld\n",readcount);
1375 }
1376
1377 /* 0 handle */
1378 status = pNtReadVirtualMemory(0, teststring, buffer, 12, &readcount);
1379 ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
1380 ok( readcount == 0, "Expected to read 0 bytes, got %ld\n",readcount);
1381
1382 /* pseudo handle for current process*/
1383 memset(buffer, 0, 12);
1384 status = pNtReadVirtualMemory((HANDLE)-1, teststring, buffer, 12, &readcount);
1385 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1386 ok( readcount == 12, "Expected to read 12 bytes, got %ld\n",readcount);
1387 ok( strcmp(teststring, buffer) == 0, "Expected read memory to be the same as original memory\n");
1388
1389 /* illegal local address */
1390 status = pNtReadVirtualMemory(process, teststring, (void *)0x1234, 12, &readcount);
1391 ok( status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got %08x\n", status);
1392 ok( readcount == 0, "Expected to read 0 bytes, got %ld\n",readcount);
1393
1394 CloseHandle(process);
1395 }
1396
1397 static void test_mapprotection(void)
1398 {
1399 HANDLE h;
1400 void* addr;
1401 MEMORY_BASIC_INFORMATION info;
1402 ULONG oldflags, flagsize, flags = MEM_EXECUTE_OPTION_ENABLE;
1403 LARGE_INTEGER size, offset;
1404 NTSTATUS status;
1405 SIZE_T retlen, count;
1406 void (*f)(void);
1407
1408 if (!pNtClose) {
1409 skip("No NtClose ... Win98\n");
1410 return;
1411 }
1412 /* Switch to being a noexec unaware process */
1413 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessExecuteFlags, &oldflags, sizeof (oldflags), &flagsize);
1414 if (status == STATUS_INVALID_PARAMETER) {
1415 skip("Invalid Parameter on ProcessExecuteFlags query?\n");
1416 return;
1417 }
1418 ok( (status == STATUS_SUCCESS) || (status == STATUS_INVALID_INFO_CLASS), "Expected STATUS_SUCCESS, got %08x\n", status);
1419 status = pNtSetInformationProcess( GetCurrentProcess(), ProcessExecuteFlags, &flags, sizeof(flags) );
1420 ok( (status == STATUS_SUCCESS) || (status == STATUS_INVALID_INFO_CLASS), "Expected STATUS_SUCCESS, got %08x\n", status);
1421
1422 size.u.LowPart = 0x1000;
1423 size.u.HighPart = 0;
1424 status = pNtCreateSection ( &h,
1425 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ | SECTION_MAP_WRITE | SECTION_MAP_EXECUTE,
1426 NULL,
1427 &size,
1428 PAGE_READWRITE,
1429 SEC_COMMIT | SEC_NOCACHE,
1430 0
1431 );
1432 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1433
1434 offset.u.LowPart = 0;
1435 offset.u.HighPart = 0;
1436 count = 0x1000;
1437 addr = NULL;
1438 status = pNtMapViewOfSection ( h, GetCurrentProcess(), &addr, 0, 0, &offset, &count, ViewShare, 0, PAGE_READWRITE);
1439 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1440
1441 #if defined(__x86_64__) || defined(__i386__)
1442 *(unsigned char*)addr = 0xc3; /* lret ... in both i386 and x86_64 */
1443 #elif defined(__arm__)
1444 *(unsigned long*)addr = 0xe12fff1e; /* bx lr */
1445 #else
1446 ok(0, "Add a return opcode for your architecture or expect a crash in this test\n");
1447 #endif
1448 trace("trying to execute code in the readwrite only mapped anon file...\n");
1449 f = addr;f();
1450 trace("...done.\n");
1451
1452 status = pNtQueryVirtualMemory( GetCurrentProcess(), addr, MemoryBasicInformation, &info, sizeof(info), &retlen );
1453 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1454 ok( retlen == sizeof(info), "Expected STATUS_SUCCESS, got %08x\n", status);
1455 ok((info.Protect & ~PAGE_NOCACHE) == PAGE_READWRITE, "addr.Protect is not PAGE_READWRITE, but 0x%x\n", info.Protect);
1456
1457 status = pNtUnmapViewOfSection (GetCurrentProcess(), addr);
1458 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1459 pNtClose (h);
1460
1461 /* Switch back */
1462 pNtSetInformationProcess( GetCurrentProcess(), ProcessExecuteFlags, &oldflags, sizeof(oldflags) );
1463 }
1464
1465 static void test_queryvirtualmemory(void)
1466 {
1467 NTSTATUS status;
1468 SIZE_T readcount;
1469 static const char teststring[] = "test string";
1470 static char datatestbuf[42] = "abc";
1471 static char rwtestbuf[42];
1472 MEMORY_BASIC_INFORMATION mbi;
1473 char stackbuf[42];
1474 HMODULE module;
1475
1476 module = GetModuleHandleA( "ntdll.dll" );
1477 trace("Check flags of the PE header of NTDLL.DLL at %p\n", module);
1478 status = pNtQueryVirtualMemory(NtCurrentProcess(), module, MemoryBasicInformation, &mbi, sizeof(MEMORY_BASIC_INFORMATION), &readcount);
1479 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1480 ok( readcount == sizeof(MEMORY_BASIC_INFORMATION), "Expected to read %d bytes, got %ld\n",(int)sizeof(MEMORY_BASIC_INFORMATION),readcount);
1481 ok (mbi.AllocationBase == module, "mbi.AllocationBase is 0x%p, expected 0x%p\n", mbi.AllocationBase, module);
1482 ok (mbi.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "mbi.AllocationProtect is 0x%x, expected 0x%x\n", mbi.AllocationProtect, PAGE_EXECUTE_WRITECOPY);
1483 ok (mbi.State == MEM_COMMIT, "mbi.State is 0x%x, expected 0x%x\n", mbi.State, MEM_COMMIT);
1484 ok (mbi.Protect == PAGE_READONLY, "mbi.Protect is 0x%x, expected 0x%x\n", mbi.Protect, PAGE_READONLY);
1485 ok (mbi.Type == MEM_IMAGE, "mbi.Type is 0x%x, expected 0x%x\n", mbi.Type, MEM_IMAGE);
1486
1487 trace("Check flags of a function entry in NTDLL.DLL at %p\n", pNtQueryVirtualMemory);
1488 module = GetModuleHandleA( "ntdll.dll" );
1489 status = pNtQueryVirtualMemory(NtCurrentProcess(), pNtQueryVirtualMemory, MemoryBasicInformation, &mbi, sizeof(MEMORY_BASIC_INFORMATION), &readcount);
1490 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1491 ok( readcount == sizeof(MEMORY_BASIC_INFORMATION), "Expected to read %d bytes, got %ld\n",(int)sizeof(MEMORY_BASIC_INFORMATION),readcount);
1492 ok (mbi.AllocationBase == module, "mbi.AllocationBase is 0x%p, expected 0x%p\n", mbi.AllocationBase, module);
1493 ok (mbi.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "mbi.AllocationProtect is 0x%x, expected 0x%x\n", mbi.AllocationProtect, PAGE_EXECUTE_WRITECOPY);
1494 ok (mbi.State == MEM_COMMIT, "mbi.State is 0x%x, expected 0x%x\n", mbi.State, MEM_COMMIT);
1495 ok (mbi.Protect == PAGE_EXECUTE_READ, "mbi.Protect is 0x%x, expected 0x%x\n", mbi.Protect, PAGE_EXECUTE_READ);
1496
1497 trace("Check flags of heap at %p\n", GetProcessHeap());
1498 status = pNtQueryVirtualMemory(NtCurrentProcess(), GetProcessHeap(), MemoryBasicInformation, &mbi, sizeof(MEMORY_BASIC_INFORMATION), &readcount);
1499 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1500 ok( readcount == sizeof(MEMORY_BASIC_INFORMATION), "Expected to read %d bytes, got %ld\n",(int)sizeof(MEMORY_BASIC_INFORMATION),readcount);
1501 ok (mbi.AllocationProtect == PAGE_READWRITE || mbi.AllocationProtect == PAGE_EXECUTE_READWRITE,
1502 "mbi.AllocationProtect is 0x%x\n", mbi.AllocationProtect);
1503 ok (mbi.State == MEM_COMMIT, "mbi.State is 0x%x, expected 0x%x\n", mbi.State, MEM_COMMIT);
1504 ok (mbi.Protect == PAGE_READWRITE || mbi.Protect == PAGE_EXECUTE_READWRITE,
1505 "mbi.Protect is 0x%x\n", mbi.Protect);
1506
1507 trace("Check flags of stack at %p\n", stackbuf);
1508 status = pNtQueryVirtualMemory(NtCurrentProcess(), stackbuf, MemoryBasicInformation, &mbi, sizeof(MEMORY_BASIC_INFORMATION), &readcount);
1509 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1510 ok( readcount == sizeof(MEMORY_BASIC_INFORMATION), "Expected to read %d bytes, got %ld\n",(int)sizeof(MEMORY_BASIC_INFORMATION),readcount);
1511 ok (mbi.AllocationProtect == PAGE_READWRITE, "mbi.AllocationProtect is 0x%x, expected 0x%x\n", mbi.AllocationProtect, PAGE_READWRITE);
1512 ok (mbi.State == MEM_COMMIT, "mbi.State is 0x%x, expected 0x%x\n", mbi.State, MEM_COMMIT);
1513 ok (mbi.Protect == PAGE_READWRITE, "mbi.Protect is 0x%x, expected 0x%x\n", mbi.Protect, PAGE_READWRITE);
1514
1515 trace("Check flags of read-only data at %p\n", teststring);
1516 module = GetModuleHandleA( NULL );
1517 status = pNtQueryVirtualMemory(NtCurrentProcess(), teststring, MemoryBasicInformation, &mbi, sizeof(MEMORY_BASIC_INFORMATION), &readcount);
1518 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1519 ok( readcount == sizeof(MEMORY_BASIC_INFORMATION), "Expected to read %d bytes, got %ld\n",(int)sizeof(MEMORY_BASIC_INFORMATION),readcount);
1520 ok (mbi.AllocationBase == module, "mbi.AllocationBase is 0x%p, expected 0x%p\n", mbi.AllocationBase, module);
1521 ok (mbi.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "mbi.AllocationProtect is 0x%x, expected 0x%x\n", mbi.AllocationProtect, PAGE_EXECUTE_WRITECOPY);
1522 ok (mbi.State == MEM_COMMIT, "mbi.State is 0x%x, expected 0x%X\n", mbi.State, MEM_COMMIT);
1523 if (mbi.Protect != PAGE_READONLY)
1524 todo_wine ok( mbi.Protect == PAGE_READONLY, "mbi.Protect is 0x%x, expected 0x%X\n", mbi.Protect, PAGE_READONLY);
1525
1526 trace("Check flags of read-write data at %p\n", datatestbuf);
1527 status = pNtQueryVirtualMemory(NtCurrentProcess(), datatestbuf, MemoryBasicInformation, &mbi, sizeof(MEMORY_BASIC_INFORMATION), &readcount);
1528 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1529 ok( readcount == sizeof(MEMORY_BASIC_INFORMATION), "Expected to read %d bytes, got %ld\n",(int)sizeof(MEMORY_BASIC_INFORMATION),readcount);
1530 ok (mbi.AllocationBase == module, "mbi.AllocationBase is 0x%p, expected 0x%p\n", mbi.AllocationBase, module);
1531 ok (mbi.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "mbi.AllocationProtect is 0x%x, expected 0x%x\n", mbi.AllocationProtect, PAGE_EXECUTE_WRITECOPY);
1532 ok (mbi.State == MEM_COMMIT, "mbi.State is 0x%x, expected 0x%X\n", mbi.State, MEM_COMMIT);
1533 ok (mbi.Protect == PAGE_READWRITE || mbi.Protect == PAGE_WRITECOPY,
1534 "mbi.Protect is 0x%x\n", mbi.Protect);
1535
1536 trace("Check flags of read-write uninitialized data (.bss) at %p\n", rwtestbuf);
1537 status = pNtQueryVirtualMemory(NtCurrentProcess(), rwtestbuf, MemoryBasicInformation, &mbi, sizeof(MEMORY_BASIC_INFORMATION), &readcount);
1538 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1539 ok( readcount == sizeof(MEMORY_BASIC_INFORMATION), "Expected to read %d bytes, got %ld\n",(int)sizeof(MEMORY_BASIC_INFORMATION),readcount);
1540 if (mbi.AllocationBase == module)
1541 {
1542 ok (mbi.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "mbi.AllocationProtect is 0x%x, expected 0x%x\n", mbi.AllocationProtect, PAGE_EXECUTE_WRITECOPY);
1543 ok (mbi.State == MEM_COMMIT, "mbi.State is 0x%x, expected 0x%X\n", mbi.State, MEM_COMMIT);
1544 ok (mbi.Protect == PAGE_READWRITE || mbi.Protect == PAGE_WRITECOPY,
1545 "mbi.Protect is 0x%x\n", mbi.Protect);
1546 }
1547 else skip( "bss is outside of module\n" ); /* this can happen on Mac OS */
1548 }
1549
1550 static void test_affinity(void)
1551 {
1552 NTSTATUS status;
1553 PROCESS_BASIC_INFORMATION pbi;
1554 DWORD_PTR proc_affinity, thread_affinity;
1555 THREAD_BASIC_INFORMATION tbi;
1556 SYSTEM_INFO si;
1557
1558 GetSystemInfo(&si);
1559 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), NULL );
1560 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1561 proc_affinity = pbi.AffinityMask;
1562 ok( proc_affinity == (1 << si.dwNumberOfProcessors) - 1, "Unexpected process affinity\n" );
1563 proc_affinity = 1 << si.dwNumberOfProcessors;
1564 status = pNtSetInformationProcess( GetCurrentProcess(), ProcessAffinityMask, &proc_affinity, sizeof(proc_affinity) );
1565 ok( status == STATUS_INVALID_PARAMETER,
1566 "Expected STATUS_INVALID_PARAMETER, got %08x\n", status);
1567
1568 proc_affinity = 0;
1569 status = pNtSetInformationProcess( GetCurrentProcess(), ProcessAffinityMask, &proc_affinity, sizeof(proc_affinity) );
1570 ok( status == STATUS_INVALID_PARAMETER,
1571 "Expected STATUS_INVALID_PARAMETER, got %08x\n", status);
1572
1573 status = pNtQueryInformationThread( GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL );
1574 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1575 ok( tbi.AffinityMask == (1 << si.dwNumberOfProcessors) - 1, "Unexpected thread affinity\n" );
1576 thread_affinity = 1 << si.dwNumberOfProcessors;
1577 status = pNtSetInformationThread( GetCurrentThread(), ThreadAffinityMask, &thread_affinity, sizeof(thread_affinity) );
1578 ok( status == STATUS_INVALID_PARAMETER,
1579 "Expected STATUS_INVALID_PARAMETER, got %08x\n", status);
1580 thread_affinity = 0;
1581 status = pNtSetInformationThread( GetCurrentThread(), ThreadAffinityMask, &thread_affinity, sizeof(thread_affinity) );
1582 ok( status == STATUS_INVALID_PARAMETER,
1583 "Expected STATUS_INVALID_PARAMETER, got %08x\n", status);
1584
1585 thread_affinity = 1;
1586 status = pNtSetInformationThread( GetCurrentThread(), ThreadAffinityMask, &thread_affinity, sizeof(thread_affinity) );
1587 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1588 status = pNtQueryInformationThread( GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL );
1589 ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1590 ok( tbi.AffinityMask == 1, "Unexpected thread affinity\n" );
1591
1592 /* NOTE: Pre-Vista does not recognize the "all processors" flag (all bits set) */
1593 thread_affinity = ~(DWORD_PTR)0;
1594 status = pNtSetInformationThread( GetCurrentThread(), ThreadAffinityMask, &thread_affinity, sizeof(thread_affinity) );
1595 ok( broken(status == STATUS_INVALID_PARAMETER) || status == STATUS_SUCCESS,
1596 "Expected STATUS_SUCCESS, got %08x\n", status);
1597
1598 if (si.dwNumberOfProcessors <= 1)
1599 {
1600 skip("only one processor, skipping affinity testing\n");
1601 return;
1602 }
1603
1604 /* Test thread affinity mask resulting from "all processors" flag */
1605 if (status == STATUS_SUCCESS)
1606 {
1607 status = pNtQueryInformationThread( GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL );
1608 ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1609 ok( broken(tbi.AffinityMask == 1) || tbi.AffinityMask == (1 << si.dwNumberOfProcessors) - 1,
1610 "Unexpected thread affinity\n" );
1611 }
1612 else
1613 skip("Cannot test thread affinity mask for 'all processors' flag\n");
1614
1615 proc_affinity = 2;
1616 status = pNtSetInformationProcess( GetCurrentProcess(), ProcessAffinityMask, &proc_affinity, sizeof(proc_affinity) );
1617 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1618 status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), NULL );
1619 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1620 proc_affinity = pbi.AffinityMask;
1621 ok( proc_affinity == 2, "Unexpected process affinity\n" );
1622 /* Setting the process affinity changes the thread affinity to match */
1623 status = pNtQueryInformationThread( GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL );
1624 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1625 ok( tbi.AffinityMask == 2, "Unexpected thread affinity\n" );
1626 /* The thread affinity is restricted to the process affinity */
1627 thread_affinity = 1;
1628 status = pNtSetInformationThread( GetCurrentThread(), ThreadAffinityMask, &thread_affinity, sizeof(thread_affinity) );
1629 ok( status == STATUS_INVALID_PARAMETER,
1630 "Expected STATUS_INVALID_PARAMETER, got %08x\n", status);
1631
1632 proc_affinity = (1 << si.dwNumberOfProcessors) - 1;
1633 status = pNtSetInformationProcess( GetCurrentProcess(), ProcessAffinityMask, &proc_affinity, sizeof(proc_affinity) );
1634 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1635 /* Resetting the process affinity also resets the thread affinity */
1636 status = pNtQueryInformationThread( GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL );
1637 ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1638 ok( tbi.AffinityMask == (1 << si.dwNumberOfProcessors) - 1,
1639 "Unexpected thread affinity\n" );
1640 }
1641
1642 static void test_NtGetCurrentProcessorNumber(void)
1643 {
1644 NTSTATUS status;
1645 SYSTEM_INFO si;
1646 PROCESS_BASIC_INFORMATION pbi;
1647 THREAD_BASIC_INFORMATION tbi;
1648 DWORD_PTR old_process_mask;
1649 DWORD_PTR old_thread_mask;
1650 DWORD_PTR new_mask;
1651 ULONG current_cpu;
1652 ULONG i;
1653
1654 if (!pNtGetCurrentProcessorNumber) {
1655 win_skip("NtGetCurrentProcessorNumber not available\n");
1656 return;
1657 }
1658
1659 GetSystemInfo(&si);
1660 current_cpu = pNtGetCurrentProcessorNumber();
1661 trace("dwNumberOfProcessors: %d, current processor: %d\n", si.dwNumberOfProcessors, current_cpu);
1662
1663 status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
1664 old_process_mask = pbi.AffinityMask;
1665 ok(status == STATUS_SUCCESS, "got 0x%x (expected STATUS_SUCCESS)\n", status);
1666
1667 status = pNtQueryInformationThread(GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL);
1668 old_thread_mask = tbi.AffinityMask;
1669 ok(status == STATUS_SUCCESS, "got 0x%x (expected STATUS_SUCCESS)\n", status);
1670
1671 /* allow the test to run on all processors */
1672 new_mask = (1 << si.dwNumberOfProcessors) - 1;
1673 status = pNtSetInformationProcess(GetCurrentProcess(), ProcessAffinityMask, &new_mask, sizeof(new_mask));
1674 ok(status == STATUS_SUCCESS, "got 0x%x (expected STATUS_SUCCESS)\n", status);
1675
1676 for (i = 0; i < si.dwNumberOfProcessors; i++)
1677 {
1678 new_mask = 1 << i;
1679 status = pNtSetInformationThread(GetCurrentThread(), ThreadAffinityMask, &new_mask, sizeof(new_mask));
1680 ok(status == STATUS_SUCCESS, "%d: got 0x%x (expected STATUS_SUCCESS)\n", i, status);
1681
1682 status = pNtQueryInformationThread(GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL);
1683 ok(status == STATUS_SUCCESS, "%d: got 0x%x (expected STATUS_SUCCESS)\n", i, status);
1684
1685 current_cpu = pNtGetCurrentProcessorNumber();
1686 ok((current_cpu == i), "%d (new_mask 0x%lx): running on processor %d (AffinityMask: 0x%lx)\n",
1687 i, new_mask, current_cpu, tbi.AffinityMask);
1688 }
1689
1690 /* restore old values */
1691 status = pNtSetInformationProcess(GetCurrentProcess(), ProcessAffinityMask, &old_process_mask, sizeof(old_process_mask));
1692 ok(status == STATUS_SUCCESS, "got 0x%x (expected STATUS_SUCCESS)\n", status);
1693
1694 status = pNtSetInformationThread(GetCurrentThread(), ThreadAffinityMask, &old_thread_mask, sizeof(old_thread_mask));
1695 ok(status == STATUS_SUCCESS, "got 0x%x (expected STATUS_SUCCESS)\n", status);
1696 }
1697
1698 START_TEST(info)
1699 {
1700 char **argv;
1701 int argc;
1702
1703 if(!InitFunctionPtrs())
1704 return;
1705
1706 argc = winetest_get_mainargs(&argv);
1707 if (argc >= 3) return; /* Child */
1708
1709 /* NtQuerySystemInformation */
1710
1711 /* 0x0 SystemBasicInformation */
1712 trace("Starting test_query_basic()\n");
1713 test_query_basic();
1714
1715 /* 0x1 SystemCpuInformation */
1716 trace("Starting test_query_cpu()\n");
1717 test_query_cpu();
1718
1719 /* 0x2 SystemPerformanceInformation */
1720 trace("Starting test_query_performance()\n");
1721 test_query_performance();
1722
1723 /* 0x3 SystemTimeOfDayInformation */
1724 trace("Starting test_query_timeofday()\n");
1725 test_query_timeofday();
1726
1727 /* 0x5 SystemProcessInformation */
1728 trace("Starting test_query_process()\n");
1729 test_query_process();
1730
1731 /* 0x8 SystemProcessorPerformanceInformation */
1732 trace("Starting test_query_procperf()\n");
1733 test_query_procperf();
1734
1735 /* 0xb SystemModuleInformation */
1736 trace("Starting test_query_module()\n");
1737 test_query_module();
1738
1739 /* 0x10 SystemHandleInformation */
1740 trace("Starting test_query_handle()\n");
1741 test_query_handle();
1742
1743 /* 0x15 SystemCacheInformation */
1744 trace("Starting test_query_cache()\n");
1745 test_query_cache();
1746
1747 /* 0x17 SystemInterruptInformation */
1748 trace("Starting test_query_interrupt()\n");
1749 test_query_interrupt();
1750
1751 /* 0x23 SystemKernelDebuggerInformation */
1752 trace("Starting test_query_kerndebug()\n");
1753 test_query_kerndebug();
1754
1755 /* 0x25 SystemRegistryQuotaInformation */
1756 trace("Starting test_query_regquota()\n");
1757 test_query_regquota();
1758
1759 /* 0x49 SystemLogicalProcessorInformation */
1760 trace("Starting test_query_logicalproc()\n");
1761 test_query_logicalproc();
1762
1763 /* NtPowerInformation */
1764
1765 /* 0xb ProcessorInformation */
1766 trace("Starting test_query_processor_power_info()\n");
1767 test_query_processor_power_info();
1768
1769 /* NtQueryInformationProcess */
1770
1771 /* 0x0 ProcessBasicInformation */
1772 trace("Starting test_query_process_basic()\n");
1773 test_query_process_basic();
1774
1775 /* 0x2 ProcessIoCounters */
1776 trace("Starting test_query_process_io()\n");
1777 test_query_process_io();
1778
1779 /* 0x3 ProcessVmCounters */
1780 trace("Starting test_query_process_vm()\n");
1781 test_query_process_vm();
1782
1783 /* 0x4 ProcessTimes */
1784 trace("Starting test_query_process_times()\n");
1785 test_query_process_times();
1786
1787 /* 0x7 ProcessDebugPort */
1788 trace("Starting test_process_debug_port()\n");
1789 test_query_process_debug_port(argc, argv);
1790
1791 /* 0x14 ProcessHandleCount */
1792 trace("Starting test_query_process_handlecount()\n");
1793 test_query_process_handlecount();
1794
1795 /* 0x1A ProcessWow64Information */
1796 trace("Starting test_query_process_wow64()\n");
1797 test_query_process_wow64();
1798
1799 /* 0x1B ProcessImageFileName */
1800 trace("Starting test_query_process_image_file_name()\n");
1801 test_query_process_image_file_name();
1802
1803 /* 0x1E ProcessDebugObjectHandle */
1804 trace("Starting test_query_process_debug_object_handle()\n");
1805 test_query_process_debug_object_handle(argc, argv);
1806
1807 /* 0x1F ProcessDebugFlags */
1808 trace("Starting test_process_debug_flags()\n");
1809 test_query_process_debug_flags(argc, argv);
1810
1811 /* belongs to its own file */
1812 trace("Starting test_readvirtualmemory()\n");
1813 test_readvirtualmemory();
1814
1815 trace("Starting test_queryvirtualmemory()\n");
1816 test_queryvirtualmemory();
1817
1818 trace("Starting test_mapprotection()\n");
1819 test_mapprotection();
1820
1821 trace("Starting test_affinity()\n");
1822 test_affinity();
1823 test_NtGetCurrentProcessorNumber();
1824 }