77b950f85bd1dfd9efe792f2cfaf87ff70877a3b
[reactos.git] / reactos / dll / win32 / kernel32 / client / sysinfo.c
1 /*
2 * PROJECT: ReactOS Win32 Base API
3 * LICENSE: See COPYING in the top level directory
4 * FILE: dll/win32/kernel32/client/sysinfo.c
5 * PURPOSE: System Information Functions
6 * PROGRAMMERS: Emanuele Aliberti
7 * Christoph von Wittich
8 * Thomas Weidenmueller
9 * Gunnar Andre Dalsnes
10 */
11
12 /* INCLUDES *******************************************************************/
13
14 #include <k32.h>
15
16 #define NDEBUG
17 #include <debug.h>
18
19 #define PV_NT351 0x00030033
20
21 /* PRIVATE FUNCTIONS **********************************************************/
22
23 VOID
24 WINAPI
25 GetSystemInfoInternal(IN PSYSTEM_BASIC_INFORMATION BasicInfo,
26 IN PSYSTEM_PROCESSOR_INFORMATION ProcInfo,
27 OUT LPSYSTEM_INFO SystemInfo)
28 {
29 RtlZeroMemory(SystemInfo, sizeof (SYSTEM_INFO));
30 SystemInfo->wProcessorArchitecture = ProcInfo->ProcessorArchitecture;
31 SystemInfo->wReserved = 0;
32 SystemInfo->dwPageSize = BasicInfo->PageSize;
33 SystemInfo->lpMinimumApplicationAddress = (PVOID)BasicInfo->MinimumUserModeAddress;
34 SystemInfo->lpMaximumApplicationAddress = (PVOID)BasicInfo->MaximumUserModeAddress;
35 SystemInfo->dwActiveProcessorMask = BasicInfo->ActiveProcessorsAffinityMask;
36 SystemInfo->dwNumberOfProcessors = BasicInfo->NumberOfProcessors;
37 SystemInfo->wProcessorLevel = ProcInfo->ProcessorLevel;
38 SystemInfo->wProcessorRevision = ProcInfo->ProcessorRevision;
39 SystemInfo->dwAllocationGranularity = BasicInfo->AllocationGranularity;
40
41 switch (ProcInfo->ProcessorArchitecture)
42 {
43 case PROCESSOR_ARCHITECTURE_INTEL:
44 switch (ProcInfo->ProcessorLevel)
45 {
46 case 3:
47 SystemInfo->dwProcessorType = PROCESSOR_INTEL_386;
48 break;
49 case 4:
50 SystemInfo->dwProcessorType = PROCESSOR_INTEL_486;
51 break;
52 default:
53 SystemInfo->dwProcessorType = PROCESSOR_INTEL_PENTIUM;
54 }
55 break;
56
57 case PROCESSOR_ARCHITECTURE_AMD64:
58 SystemInfo->dwProcessorType = PROCESSOR_AMD_X8664;
59 break;
60
61 case PROCESSOR_ARCHITECTURE_IA64:
62 SystemInfo->dwProcessorType = PROCESSOR_INTEL_IA64;
63 break;
64
65 default:
66 SystemInfo->dwProcessorType = 0;
67 break;
68 }
69
70 if (PV_NT351 > GetProcessVersion(0))
71 {
72 SystemInfo->wProcessorLevel = 0;
73 SystemInfo->wProcessorRevision = 0;
74 }
75 }
76
77 /* PUBLIC FUNCTIONS ***********************************************************/
78
79 /*
80 * @implemented
81 */
82 SIZE_T
83 WINAPI
84 GetLargePageMinimum(VOID)
85 {
86 return SharedUserData->LargePageMinimum;
87 }
88
89 /*
90 * @implemented
91 */
92 VOID
93 WINAPI
94 GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
95 {
96 SYSTEM_BASIC_INFORMATION BasicInfo;
97 SYSTEM_PROCESSOR_INFORMATION ProcInfo;
98 NTSTATUS Status;
99
100 Status = NtQuerySystemInformation(SystemBasicInformation,
101 &BasicInfo,
102 sizeof(BasicInfo),
103 0);
104 if (!NT_SUCCESS(Status)) return;
105
106 Status = NtQuerySystemInformation(SystemProcessorInformation,
107 &ProcInfo,
108 sizeof(ProcInfo),
109 0);
110 if (!NT_SUCCESS(Status)) return;
111
112 GetSystemInfoInternal(&BasicInfo, &ProcInfo, lpSystemInfo);
113 }
114
115 /*
116 * @implemented
117 */
118 BOOL
119 WINAPI
120 IsProcessorFeaturePresent(IN DWORD ProcessorFeature)
121 {
122 if (ProcessorFeature >= PROCESSOR_FEATURE_MAX) return FALSE;
123 return ((BOOL)SharedUserData->ProcessorFeatures[ProcessorFeature]);
124 }
125
126 /*
127 * @implemented
128 */
129 BOOL
130 WINAPI
131 GetSystemRegistryQuota(OUT PDWORD pdwQuotaAllowed,
132 OUT PDWORD pdwQuotaUsed)
133 {
134 SYSTEM_REGISTRY_QUOTA_INFORMATION QuotaInfo;
135 ULONG BytesWritten;
136 NTSTATUS Status;
137
138 Status = NtQuerySystemInformation(SystemRegistryQuotaInformation,
139 &QuotaInfo,
140 sizeof(QuotaInfo),
141 &BytesWritten);
142 if (NT_SUCCESS(Status))
143 {
144 if (pdwQuotaAllowed) *pdwQuotaAllowed = QuotaInfo.RegistryQuotaAllowed;
145 if (pdwQuotaUsed) *pdwQuotaUsed = QuotaInfo.RegistryQuotaUsed;
146 return TRUE;
147 }
148
149 BaseSetLastNTError(Status);
150 return FALSE;
151 }
152
153 /*
154 * @implemented
155 */
156 VOID
157 WINAPI
158 GetNativeSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
159 {
160 SYSTEM_BASIC_INFORMATION BasicInfo;
161 SYSTEM_PROCESSOR_INFORMATION ProcInfo;
162 NTSTATUS Status;
163
164 /* FIXME: Should be SystemNativeBasicInformation */
165 Status = NtQuerySystemInformation(SystemBasicInformation,
166 &BasicInfo,
167 sizeof(BasicInfo),
168 0);
169 if (!NT_SUCCESS(Status)) return;
170
171 /* FIXME: Should be SystemNativeProcessorInformation */
172 Status = NtQuerySystemInformation(SystemProcessorInformation,
173 &ProcInfo,
174 sizeof(ProcInfo),
175 0);
176 if (!NT_SUCCESS(Status)) return;
177
178 GetSystemInfoInternal(&BasicInfo, &ProcInfo, lpSystemInfo);
179 }
180
181 /*
182 * @implemented
183 */
184 BOOL
185 WINAPI
186 GetLogicalProcessorInformation(OUT PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
187 IN OUT PDWORD ReturnLength)
188 {
189 NTSTATUS Status;
190
191 if (!ReturnLength)
192 {
193 SetLastError(ERROR_INVALID_PARAMETER);
194 return FALSE;
195 }
196
197 Status = NtQuerySystemInformation(SystemLogicalProcessorInformation,
198 Buffer,
199 *ReturnLength,
200 ReturnLength);
201
202 /* Normalize the error to what Win32 expects */
203 if (Status == STATUS_INFO_LENGTH_MISMATCH) Status = STATUS_BUFFER_TOO_SMALL;
204 if (!NT_SUCCESS(Status))
205 {
206 BaseSetLastNTError(Status);
207 return FALSE;
208 }
209
210 return TRUE;
211 }
212
213 /*
214 * @implemented
215 */
216 BOOL
217 WINAPI
218 GetNumaHighestNodeNumber(OUT PULONG HighestNodeNumber)
219 {
220 NTSTATUS Status;
221 ULONG Length;
222 ULONG PartialInfo[2]; // First two members of SYSTEM_NUMA_INFORMATION
223
224 /* Query partial NUMA info */
225 Status = NtQuerySystemInformation(SystemNumaProcessorMap,
226 PartialInfo,
227 sizeof(PartialInfo),
228 &Length);
229 if (!NT_SUCCESS(Status))
230 {
231 BaseSetLastNTError(Status);
232 return FALSE;
233 }
234
235 if (Length < sizeof(ULONG))
236 {
237 SetLastError(ERROR_INVALID_PARAMETER);
238 return FALSE;
239 }
240
241 /* First member of the struct is the highest node number */
242 *HighestNodeNumber = PartialInfo[0];
243 return TRUE;
244 }
245
246 /*
247 * @implemented
248 */
249 BOOL
250 WINAPI
251 GetNumaNodeProcessorMask(IN UCHAR Node,
252 OUT PULONGLONG ProcessorMask)
253 {
254 NTSTATUS Status;
255 SYSTEM_NUMA_INFORMATION NumaInformation;
256 ULONG Length;
257
258 /* Query NUMA information */
259 Status = NtQuerySystemInformation(SystemNumaProcessorMap,
260 &NumaInformation,
261 sizeof(NumaInformation),
262 &Length);
263 if (!NT_SUCCESS(Status))
264 {
265 BaseSetLastNTError(Status);
266 return FALSE;
267 }
268
269 /* Validate input node number */
270 if (Node > NumaInformation.HighestNodeNumber)
271 {
272 SetLastError(ERROR_INVALID_PARAMETER);
273 return FALSE;
274 }
275
276 /* Return mask for that node */
277 *ProcessorMask = NumaInformation.ActiveProcessorsAffinityMask[Node];
278 return TRUE;
279 }
280
281 /*
282 * @implemented
283 */
284 BOOL
285 WINAPI
286 GetNumaProcessorNode(IN UCHAR Processor,
287 OUT PUCHAR NodeNumber)
288 {
289 NTSTATUS Status;
290 SYSTEM_NUMA_INFORMATION NumaInformation;
291 ULONG Length;
292 ULONG Node;
293 ULONGLONG Proc;
294
295 /* Can't handle processor number >= 32 */
296 if (Processor >= MAXIMUM_PROCESSORS)
297 {
298 *NodeNumber = -1;
299 SetLastError(ERROR_INVALID_PARAMETER);
300 return FALSE;
301 }
302
303 /* Query NUMA information */
304 Status = NtQuerySystemInformation(SystemNumaProcessorMap,
305 &NumaInformation,
306 sizeof(NumaInformation),
307 &Length);
308 if (!NT_SUCCESS(Status))
309 {
310 *NodeNumber = -1;
311 BaseSetLastNTError(Status);
312 return FALSE;
313 }
314
315 /* Find ourselves */
316 Node = 0;
317 Proc = (1ULL << Processor) >> MAXIMUM_PROCESSORS;
318 while ((Proc & NumaInformation.ActiveProcessorsAffinityMask[Node]) == 0ULL)
319 {
320 ++Node;
321 /* Out of options */
322 if (Node > NumaInformation.HighestNodeNumber)
323 {
324 *NodeNumber = -1;
325 SetLastError(ERROR_INVALID_PARAMETER);
326 return FALSE;
327 }
328 }
329
330 /* Return found node */
331 *NodeNumber = Node;
332 return TRUE;
333 }
334
335 /*
336 * @implemented
337 */
338 BOOL
339 WINAPI
340 GetNumaAvailableMemoryNode(IN UCHAR Node,
341 OUT PULONGLONG AvailableBytes)
342 {
343 NTSTATUS Status;
344 SYSTEM_NUMA_INFORMATION NumaInformation;
345 ULONG Length;
346
347 /* Query NUMA information */
348 Status = NtQuerySystemInformation(SystemNumaAvailableMemory,
349 &NumaInformation,
350 sizeof(NumaInformation),
351 &Length);
352 if (!NT_SUCCESS(Status))
353 {
354 BaseSetLastNTError(Status);
355 return FALSE;
356 }
357
358 /* Validate input node number */
359 if (Node > NumaInformation.HighestNodeNumber)
360 {
361 SetLastError(ERROR_INVALID_PARAMETER);
362 return FALSE;
363 }
364
365 /* Return available memory for that node */
366 *AvailableBytes = NumaInformation.AvailableMemory[Node];
367 return TRUE;
368 }
369
370 /*
371 * @unimplemented
372 */
373 DWORD
374 WINAPI
375 GetFirmwareEnvironmentVariableW(IN LPCWSTR lpName,
376 IN LPCWSTR lpGuid,
377 IN PVOID pValue,
378 IN DWORD nSize)
379 {
380 STUB;
381 return 0;
382 }
383
384 /*
385 * @unimplemented
386 */
387 BOOL
388 WINAPI
389 SetFirmwareEnvironmentVariableW(IN LPCWSTR lpName,
390 IN LPCWSTR lpGuid,
391 IN PVOID pValue,
392 IN DWORD nSize)
393 {
394 STUB;
395 return 0;
396 }
397
398 /*
399 * @unimplemented
400 */
401 DWORD
402 WINAPI
403 GetFirmwareEnvironmentVariableA(IN LPCSTR lpName,
404 IN LPCSTR lpGuid,
405 IN PVOID pValue,
406 IN DWORD nSize)
407 {
408 STUB;
409 return 0;
410 }
411
412 /*
413 * @unimplemented
414 */
415 BOOL
416 WINAPI
417 SetFirmwareEnvironmentVariableA(IN LPCSTR lpName,
418 IN LPCSTR lpGuid,
419 IN PVOID pValue,
420 IN DWORD nSize)
421 {
422 STUB;
423 return 0;
424 }
425
426 /*
427 * @unimplemented
428 */
429 UINT
430 WINAPI
431 EnumSystemFirmwareTables(IN DWORD FirmwareTableProviderSignature,
432 OUT PVOID pFirmwareTableBuffer,
433 IN DWORD BufferSize)
434 {
435 STUB;
436 return 0;
437 }
438
439 /*
440 * @unimplemented
441 */
442 UINT
443 WINAPI
444 GetSystemFirmwareTable(IN DWORD FirmwareTableProviderSignature,
445 IN DWORD FirmwareTableID,
446 OUT PVOID pFirmwareTableBuffer,
447 IN DWORD BufferSize)
448 {
449 STUB;
450 return 0;
451 }
452
453 /*
454 * @unimplemented
455 */
456 BOOL
457 WINAPI
458 GetSystemFileCacheSize(OUT PSIZE_T lpMinimumFileCacheSize,
459 OUT PSIZE_T lpMaximumFileCacheSize,
460 OUT PDWORD lpFlags)
461 {
462 STUB;
463 return FALSE;
464 }
465
466 /*
467 * @unimplemented
468 */
469 BOOL
470 WINAPI
471 SetSystemFileCacheSize(IN SIZE_T MinimumFileCacheSize,
472 IN SIZE_T MaximumFileCacheSize,
473 IN DWORD Flags)
474 {
475 STUB;
476 return FALSE;
477 }