dll/win32/kernel32/misc/sysinfo.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            dll/win32/kernel32/misc/sysinfo.c
   6  * PURPOSE:         SystemInfo functions
   7  * PROGRAMMER:      Emanuele Aliberti
   8  *                  Christoph von Wittich
   9  *                  Thomas Weidenmueller
  10  *                  Gunnar Andre Dalsnes
  11  * UPDATE HISTORY:
  12  *     2000-04-26 created
  13  */
  14
  15 #include <k32.h>
  16
  17 #define NDEBUG
  18 #include <debug.h>
  19
  20
  21 #define PV_NT351 0x00030033
  22
  23 /*
  24  * @implemented
  25  */
  26 SIZE_T
  27 WINAPI
  28 GetLargePageMinimum(VOID)
  29 {
  30         return SharedUserData->LargePageMinimum;
  31 }
  32
  33 /*
  34  * @unimplemented
  35  */
  36 VOID
  37 WINAPI
  38 GetSystemInfo (
  39         LPSYSTEM_INFO   Si
  40         )
  41 {
  42         SYSTEM_BASIC_INFORMATION        Sbi;
  43         SYSTEM_PROCESSOR_INFORMATION    Spi;
  44         DWORD                           ProcessVersion;
  45         NTSTATUS                        Status;
  46
  47         RtlZeroMemory (Si, sizeof (SYSTEM_INFO));
  48         Status = NtQuerySystemInformation (
  49                         SystemBasicInformation, /* 0 */
  50                         & Sbi,
  51                         sizeof Sbi, /* 44 */
  52                         0
  53                         );
  54         if (STATUS_SUCCESS != Status)
  55         {
  56                 SetLastErrorByStatus (Status);
  57                 return;
  58         }
  59         Status = NtQuerySystemInformation (
  60                         SystemProcessorInformation, /* 1 */
  61                         & Spi,
  62                         sizeof Spi, /* 12 */
  63                         0
  64                         );
  65         if (STATUS_SUCCESS != Status)
  66         {
  67                 SetLastErrorByStatus (Status);
  68                 return;
  69         }
  70         /*
  71          *      PROCESSOR_ARCHITECTURE_INTEL 0
  72          *      PROCESSOR_ARCHITECTURE_MIPS  1
  73          *      PROCESSOR_ARCHITECTURE_ALPHA 2
  74          *      PROCESSOR_ARCHITECTURE_PPC   3
  75          *      PROCESSOR_ARCHITECTURE_UNKNOWN 0xFFFF
  76          */
  77         Si->wProcessorArchitecture      = Spi.ProcessorArchitecture;
  78         /* For future use: always zero */
  79         Si->wReserved                   = 0;
  80         Si->dwPageSize                  = Sbi.PageSize;
  81         Si->lpMinimumApplicationAddress = (PVOID)Sbi.MinimumUserModeAddress;
  82         Si->lpMaximumApplicationAddress = (PVOID)Sbi.MaximumUserModeAddress;
  83         Si->dwActiveProcessorMask       = Sbi.ActiveProcessorsAffinityMask;
  84         Si->dwNumberOfProcessors        = Sbi.NumberOfProcessors;
  85         /*
  86          * Compatibility (no longer relevant):
  87          *      PROCESSOR_INTEL_386     386
  88          *      PROCESSOR_INTEL_486     486
  89          *      PROCESSOR_INTEL_PENTIUM 586
  90          *      PROCESSOR_MIPS_R4000    4000
  91          *      PROCESSOR_ALPHA_21064   21064
  92          */
  93         switch (Spi.ProcessorArchitecture)
  94         {
  95         case PROCESSOR_ARCHITECTURE_INTEL:
  96                 switch (Spi.ProcessorLevel)
  97                 {
  98                 case 3:
  99                         Si->dwProcessorType = PROCESSOR_INTEL_386;
 100                         break;
 101                 case 4:
 102                         Si->dwProcessorType = PROCESSOR_INTEL_486;
 103                         break;
 104                 case 5:
 105                         Si->dwProcessorType = PROCESSOR_INTEL_PENTIUM;
 106                         break;
 107                 default:
 108                         /* FIXME: P2, P3, P4...? */
 109                         Si->dwProcessorType = PROCESSOR_INTEL_PENTIUM;
 110                 }
 111                 break;
 112
 113         case PROCESSOR_ARCHITECTURE_MIPS:
 114                 Si->dwProcessorType = PROCESSOR_MIPS_R4000;
 115                 break;
 116
 117         case PROCESSOR_ARCHITECTURE_ALPHA:
 118                 Si->dwProcessorType = PROCESSOR_ALPHA_21064;
 119                 break;
 120
 121         case PROCESSOR_ARCHITECTURE_IA64:
 122                 Si->dwProcessorType = PROCESSOR_INTEL_IA64;
 123                 break;
 124
 125         case PROCESSOR_ARCHITECTURE_PPC:
 126                 switch (Spi.ProcessorLevel)
 127                 {
 128                 case 1:
 129                         Si->dwProcessorType = PROCESSOR_PPC_601;
 130                         break;
 131                 case 3:
 132                         Si->dwProcessorType = PROCESSOR_PPC_603;
 133                         break;
 134                 case 4:
 135                         Si->dwProcessorType = PROCESSOR_PPC_604;
 136                         break;
 137                 case 6:
 138                         /* PPC 603+ */
 139                         Si->dwProcessorType = PROCESSOR_PPC_603;
 140                         break;
 141                 case 9:
 142                         /* PPC 604+ */
 143                         Si->dwProcessorType = PROCESSOR_PPC_604;
 144                         break;
 145                 case 20:
 146                         Si->dwProcessorType = PROCESSOR_PPC_620;
 147                         break;
 148                 default:
 149                         Si->dwProcessorType = 0;
 150                 }
 151                 break;
 152
 153         }
 154         /* Once hardcoded to 64kb */
 155         Si->dwAllocationGranularity     = Sbi.AllocationGranularity;
 156         /* */
 157         Si->wProcessorLevel             = Spi.ProcessorLevel;
 158         Si->wProcessorRevision          = Spi.ProcessorRevision;
 159         /*
 160          * Get the version of Windows on which
 161          * the process expects to run.
 162          */
 163         ProcessVersion = GetProcessVersion (0); /* current process */
 164          /* In NT 3.1 and 3.5 these fields were always zero. */
 165         if (PV_NT351 > ProcessVersion)
 166         {
 167                 Si->wProcessorLevel = 0;
 168                 Si->wProcessorRevision = 0;
 169         }
 170 }
 171
 172
 173 /*
 174  * @implemented
 175  */
 176 BOOL WINAPI
 177 IsProcessorFeaturePresent(DWORD ProcessorFeature)
 178 {
 179   if (ProcessorFeature >= PROCESSOR_FEATURE_MAX)
 180     return(FALSE);
 181
 182   return((BOOL)SharedUserData->ProcessorFeatures[ProcessorFeature]);
 183 }
 184
 185
 186 /*
 187  * @implemented
 188  */
 189 BOOL
 190 WINAPI
 191 GetSystemRegistryQuota(PDWORD pdwQuotaAllowed,
 192                        PDWORD pdwQuotaUsed)
 193 {
 194     SYSTEM_REGISTRY_QUOTA_INFORMATION srqi;
 195     ULONG BytesWritten;
 196     NTSTATUS Status;
 197
 198     Status = NtQuerySystemInformation(SystemRegistryQuotaInformation,
 199                                       &srqi,
 200                                       sizeof(srqi),
 201                                       &BytesWritten);
 202     if(NT_SUCCESS(Status))
 203     {
 204       if(pdwQuotaAllowed != NULL)
 205       {
 206         *pdwQuotaAllowed = srqi.RegistryQuotaAllowed;
 207       }
 208       if(pdwQuotaUsed != NULL)
 209       {
 210         *pdwQuotaUsed = srqi.RegistryQuotaUsed;
 211       }
 212
 213       return TRUE;
 214     }
 215
 216     SetLastErrorByStatus(Status);
 217     return FALSE;
 218 }
 219
 220 /*
 221  * @implemented
 222  */
 223 VOID
 224 WINAPI
 225 GetNativeSystemInfo(
 226     LPSYSTEM_INFO lpSystemInfo
 227     )
 228 {
 229     //FIXME: GetNativeSystemInfo should return always the real Hardware Processorarchitecture
 230     // in case a Program is running in 32bit Mode on AMD64
 231     // GetSystemInfo should return PROCESSOR_ARCHITECTURE_INTEL and
 232     // GetNativeSystemInfo should return PROCESSOR_ARCHITECTURE_AMD64
 233     GetSystemInfo(lpSystemInfo);
 234 }
 235
 236 /*
 237  * @implemented
 238  */
 239 BOOL
 240 WINAPI
 241 GetLogicalProcessorInformation(OUT PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
 242                                IN OUT PDWORD ReturnLength)
 243 {
 244     NTSTATUS Status;
 245
 246     if (!ReturnLength)
 247     {
 248         SetLastError(ERROR_INVALID_PARAMETER);
 249         return FALSE;
 250     }
 251
 252     Status = NtQuerySystemInformation(SystemLogicalProcessorInformation,
 253                                       Buffer,
 254                                       *ReturnLength,
 255                                       ReturnLength);
 256
 257     if (!NT_SUCCESS(Status))
 258     {
 259         /*
 260          * When NtQuerySystemInformation says STATUS_INFO_LENGTH_MISMATCH,
 261          * return ERROR_INSUFFICIENT_BUFFER instead of ERROR_BAD_LENGTH.
 262          */
 263         SetLastErrorByStatus(Status == STATUS_INFO_LENGTH_MISMATCH
 264                              ? STATUS_BUFFER_TOO_SMALL
 265                              : Status);
 266         return FALSE;
 267     }
 268
 269     return TRUE;
 270 }