dlls/kernel32/cpu.c

   1 /*
   2  * What processor?
   3  *
   4  * Copyright 1995,1997 Morten Welinder
   5  * Copyright 1997-1998 Marcus Meissner
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #ifdef HAVE_SYS_TIME_H
  29 # include <sys/time.h>
  30 #endif
  31
  32
  33 #define NONAMELESSUNION
  34 #define NONAMELESSSTRUCT
  35 #include "ntstatus.h"
  36 #define WIN32_NO_STATUS
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winnt.h"
  40 #include "winternl.h"
  41 #include "psapi.h"
  42 #include "ddk/wdm.h"
  43 #include "wine/unicode.h"
  44 #include "kernel_private.h"
  45 #include "wine/debug.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(reg);
  48
  49 /***********************************************************************
  50  *                      GetSystemInfo                   [KERNEL32.@]
  51  *
  52  * Get information about the system.
  53  *
  54  * RETURNS
  55  *  Nothing.
  56  */
  57 VOID WINAPI GetSystemInfo(
  58         LPSYSTEM_INFO si        /* [out] Destination for system information, may not be NULL */)
  59 {
  60     SYSTEM_CPU_INFORMATION   sci;
  61
  62     TRACE("si=0x%p\n", si);
  63
  64     if (!set_ntstatus( NtQuerySystemInformation( SystemCpuInformation, &sci, sizeof(sci), NULL ))) return;
  65
  66     si->u.s.wProcessorArchitecture  = sci.Architecture;
  67     si->u.s.wReserved               = 0;
  68     si->dwPageSize                  = system_info.PageSize;
  69     si->lpMinimumApplicationAddress = system_info.LowestUserAddress;
  70     si->lpMaximumApplicationAddress = system_info.HighestUserAddress;
  71     si->dwActiveProcessorMask       = system_info.ActiveProcessorsAffinityMask;
  72     si->dwNumberOfProcessors        = system_info.NumberOfProcessors;
  73
  74     switch (sci.Architecture)
  75     {
  76     case PROCESSOR_ARCHITECTURE_INTEL:
  77         switch (sci.Level)
  78         {
  79         case 3:  si->dwProcessorType = PROCESSOR_INTEL_386;     break;
  80         case 4:  si->dwProcessorType = PROCESSOR_INTEL_486;     break;
  81         case 5:
  82         case 6:  si->dwProcessorType = PROCESSOR_INTEL_PENTIUM; break;
  83         default: si->dwProcessorType = PROCESSOR_INTEL_PENTIUM; break;
  84         }
  85         break;
  86     case PROCESSOR_ARCHITECTURE_PPC:
  87         switch (sci.Level)
  88         {
  89         case 1:  si->dwProcessorType = PROCESSOR_PPC_601;       break;
  90         case 3:
  91         case 6:  si->dwProcessorType = PROCESSOR_PPC_603;       break;
  92         case 4:  si->dwProcessorType = PROCESSOR_PPC_604;       break;
  93         case 9:  si->dwProcessorType = PROCESSOR_PPC_604;       break;
  94         case 20: si->dwProcessorType = PROCESSOR_PPC_620;       break;
  95         default: si->dwProcessorType = 0;
  96         }
  97         break;
  98     case PROCESSOR_ARCHITECTURE_AMD64:
  99         si->dwProcessorType = PROCESSOR_AMD_X8664;
 100         break;
 101     case PROCESSOR_ARCHITECTURE_ARM:
 102         switch (sci.Level)
 103         {
 104         case 4:  si->dwProcessorType = PROCESSOR_ARM_7TDMI;     break;
 105         default: si->dwProcessorType = PROCESSOR_ARM920;
 106         }
 107         break;
 108     case PROCESSOR_ARCHITECTURE_ARM64:
 109         si->dwProcessorType = 0;
 110         break;
 111     default:
 112         FIXME("Unknown processor architecture %x\n", sci.Architecture);
 113         si->dwProcessorType = 0;
 114     }
 115     si->dwAllocationGranularity     = system_info.AllocationGranularity;
 116     si->wProcessorLevel             = sci.Level;
 117     si->wProcessorRevision          = sci.Revision;
 118 }
 119
 120
 121 /***********************************************************************
 122  *                      GetNativeSystemInfo             [KERNEL32.@]
 123  */
 124 VOID WINAPI GetNativeSystemInfo(
 125     LPSYSTEM_INFO si    /* [out] Destination for system information, may not be NULL */)
 126 {
 127     BOOL is_wow64;
 128
 129     GetSystemInfo(si);
 130
 131     IsWow64Process(GetCurrentProcess(), &is_wow64);
 132     if (is_wow64)
 133     {
 134         if (si->u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)
 135         {
 136             si->u.s.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_AMD64;
 137             si->dwProcessorType = PROCESSOR_AMD_X8664;
 138         }
 139         else
 140         {
 141             FIXME("Add the proper information for %d in wow64 mode\n",
 142                   si->u.s.wProcessorArchitecture);
 143         }
 144     }
 145 }
 146
 147 /***********************************************************************
 148  *           K32GetPerformanceInfo (KERNEL32.@)
 149  */
 150 BOOL WINAPI K32GetPerformanceInfo(PPERFORMANCE_INFORMATION info, DWORD size)
 151 {
 152     SYSTEM_PERFORMANCE_INFORMATION perf;
 153     SYSTEM_BASIC_INFORMATION basic;
 154     SYSTEM_PROCESS_INFORMATION *process, *spi;
 155     DWORD info_size;
 156     NTSTATUS status;
 157
 158     TRACE( "(%p, %d)\n", info, size );
 159
 160     if (size < sizeof(*info))
 161     {
 162         SetLastError( ERROR_BAD_LENGTH );
 163         return FALSE;
 164     }
 165
 166     status = NtQuerySystemInformation( SystemPerformanceInformation, &perf, sizeof(perf), NULL );
 167     if (status) goto err;
 168     status = NtQuerySystemInformation( SystemBasicInformation, &basic, sizeof(basic), NULL );
 169     if (status) goto err;
 170
 171     info->cb                 = sizeof(*info);
 172     info->CommitTotal        = perf.TotalCommittedPages;
 173     info->CommitLimit        = perf.TotalCommitLimit;
 174     info->CommitPeak         = perf.PeakCommitment;
 175     info->PhysicalTotal      = basic.MmNumberOfPhysicalPages;
 176     info->PhysicalAvailable  = perf.AvailablePages;
 177     info->SystemCache        = 0;
 178     info->KernelTotal        = perf.PagedPoolUsage + perf.NonPagedPoolUsage;
 179     info->KernelPaged        = perf.PagedPoolUsage;
 180     info->KernelNonpaged     = perf.NonPagedPoolUsage;
 181     info->PageSize           = basic.PageSize;
 182
 183     /* fields from SYSTEM_PROCESS_INFORMATION */
 184     NtQuerySystemInformation( SystemProcessInformation, NULL, 0, &info_size );
 185     for (;;)
 186     {
 187         process = HeapAlloc( GetProcessHeap(), 0, info_size );
 188         if (!process)
 189         {
 190             SetLastError( ERROR_OUTOFMEMORY );
 191             return FALSE;
 192         }
 193         status = NtQuerySystemInformation( SystemProcessInformation, process, info_size, &info_size );
 194         if (!status) break;
 195         HeapFree( GetProcessHeap(), 0, process );
 196         if (status != STATUS_INFO_LENGTH_MISMATCH)
 197             goto err;
 198     }
 199
 200     info->HandleCount = info->ProcessCount = info->ThreadCount = 0;
 201     spi = process;
 202     for (;;)
 203     {
 204         info->ProcessCount++;
 205         info->HandleCount += spi->HandleCount;
 206         info->ThreadCount += spi->dwThreadCount;
 207         if (spi->NextEntryOffset == 0) break;
 208         spi = (SYSTEM_PROCESS_INFORMATION *)((char *)spi + spi->NextEntryOffset);
 209     }
 210     HeapFree( GetProcessHeap(), 0, process );
 211     return TRUE;
 212
 213 err:
 214     SetLastError( RtlNtStatusToDosError( status ) );
 215     return FALSE;
 216 }
 217
 218 /***********************************************************************
 219  *           GetLargePageMinimum (KERNEL32.@)
 220  */
 221 SIZE_T WINAPI GetLargePageMinimum(void)
 222 {
 223 #if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
 224     return 2 * 1024 * 1024;
 225 #endif
 226     FIXME("Not implemented on your platform/architecture.\n");
 227     return 0;
 228 }
 229
 230 /***********************************************************************
 231  *           GetActiveProcessorGroupCount (KERNEL32.@)
 232  */
 233 WORD WINAPI GetActiveProcessorGroupCount(void)
 234 {
 235     FIXME("semi-stub, always returning 1\n");
 236     return 1;
 237 }
 238
 239 /***********************************************************************
 240  *           GetActiveProcessorCount (KERNEL32.@)
 241  */
 242 DWORD WINAPI GetActiveProcessorCount(WORD group)
 243 {
 244     SYSTEM_INFO si;
 245     DWORD cpus;
 246
 247     GetSystemInfo( &si );
 248     cpus = si.dwNumberOfProcessors;
 249
 250     FIXME("semi-stub, returning %u\n", cpus);
 251     return cpus;
 252 }
 253
 254 /***********************************************************************
 255  *           GetMaximumProcessorCount (KERNEL32.@)
 256  */
 257 DWORD WINAPI GetMaximumProcessorCount(WORD group)
 258 {
 259     SYSTEM_INFO si;
 260     DWORD cpus;
 261
 262     GetSystemInfo( &si );
 263     cpus = si.dwNumberOfProcessors;
 264
 265     FIXME("semi-stub, returning %u\n", cpus);
 266     return cpus;
 267 }
 268
 269 /***********************************************************************
 270  *           GetEnabledXStateFeatures (KERNEL32.@)
 271  */
 272 DWORD64 WINAPI GetEnabledXStateFeatures(void)
 273 {
 274     FIXME("\n");
 275     return 0;
 276 }
 277
 278 /***********************************************************************
 279  *           GetSystemFirmwareTable (KERNEL32.@)
 280  */
 281 UINT WINAPI GetSystemFirmwareTable(DWORD provider, DWORD id, void *buffer, DWORD size)
 282 {
 283     ULONG buffer_size = FIELD_OFFSET(SYSTEM_FIRMWARE_TABLE_INFORMATION, TableBuffer) + size;
 284     SYSTEM_FIRMWARE_TABLE_INFORMATION *sfti = HeapAlloc(GetProcessHeap(), 0, buffer_size);
 285     NTSTATUS status;
 286
 287     TRACE("(0x%08x, 0x%08x, %p, %d)\n", provider, id, buffer, size);
 288
 289     if (!sfti)
 290     {
 291         SetLastError(ERROR_OUTOFMEMORY);
 292         return 0;
 293     }
 294
 295     sfti->ProviderSignature = provider;
 296     sfti->Action = SystemFirmwareTable_Get;
 297     sfti->TableID = id;
 298
 299     status = NtQuerySystemInformation(SystemFirmwareTableInformation, sfti, buffer_size, &buffer_size);
 300     buffer_size -= FIELD_OFFSET(SYSTEM_FIRMWARE_TABLE_INFORMATION, TableBuffer);
 301     if (buffer_size <= size)
 302         memcpy(buffer, sfti->TableBuffer, buffer_size);
 303
 304     if (status) SetLastError(RtlNtStatusToDosError(status));
 305     HeapFree(GetProcessHeap(), 0, sfti);
 306     return buffer_size;
 307 }
 308
 309
 310 /***********************************************************************
 311  *           EnumSystemFirmwareTables (KERNEL32.@)
 312  */
 313 UINT WINAPI EnumSystemFirmwareTables(DWORD provider, void *buffer, DWORD size)
 314 {
 315     FIXME("(0x%08x, %p, %d)\n", provider, buffer, size);
 316     return 0;
 317 }