reactos/ntoskrnl/ex/sysinfo.c

   1 /* $Id: sysinfo.c,v 1.5 2000/04/25 23:22:56 ea Exp $
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            ntoskrnl/ex/sysinfo.c
   6  * PURPOSE:         System information functions
   7  * PROGRAMMER:      David Welch (welch@mcmail.com)
   8  * UPDATE HISTORY:
   9  *                  Created 22/05/98
  10  */
  11
  12 /* INCLUDES *****************************************************************/
  13
  14 #include <ddk/ntddk.h>
  15 #include <ddk/zwtypes.h>
  16 #include <string.h>
  17 #include <internal/ex.h>
  18
  19 #include <internal/debug.h>
  20
  21 extern ULONG NtGlobalFlag; /* FIXME: it should go in a ddk/?.h */
  22
  23 /* FUNCTIONS *****************************************************************/
  24
  25 NTSTATUS
  26 STDCALL
  27 NtQuerySystemEnvironmentValue (
  28         IN      PUNICODE_STRING Name,
  29         OUT     PVOID           Value,
  30         IN      ULONG           Length,
  31         IN OUT  PULONG          ReturnLength
  32         )
  33 {
  34         UNIMPLEMENTED;
  35 }
  36
  37
  38 NTSTATUS
  39 STDCALL
  40 NtSetSystemEnvironmentValue (
  41         IN      PUNICODE_STRING VariableName,
  42         IN      PUNICODE_STRING Value
  43         )
  44 {
  45         UNIMPLEMENTED;
  46 }
  47
  48
  49 /* --- Query/Set System Information --- */
  50
  51
  52 /*
  53  * NOTE: QSI_DEF(n) and SSI_DEF(n) define _cdecl function symbols
  54  * so the stack is popped only in one place on x86 platform.
  55  */
  56 #define QSI_USE(n) QSI##n
  57 #define QSI_DEF(n) \
  58 static NTSTATUS QSI_USE(n) (PVOID Buffer, ULONG Size, PULONG ReqSize)
  59
  60 #define SSI_USE(n) SSI##n
  61 #define SSI_DEF(n) \
  62 static NTSTATUS SSI_USE(n) (PVOID Buffer, ULONG Size)
  63
  64 /* Class 0 - Basic Information */
  65 QSI_DEF(SystemBasicInformation)
  66 {
  67         PSYSTEM_BASIC_INFORMATION Sbi
  68                 = (PSYSTEM_BASIC_INFORMATION) Buffer;
  69
  70         *ReqSize = sizeof (SYSTEM_BASIC_INFORMATION);
  71         /*
  72          * Check user buffer's size
  73          */
  74         if (Size < sizeof (SYSTEM_BASIC_INFORMATION))
  75         {
  76                 return (STATUS_INFO_LENGTH_MISMATCH);
  77         }
  78
  79         Sbi->AlwaysZero = 0;
  80         Sbi->KeMaximumIncrement = 0; /* FIXME */
  81         Sbi->MmPageSize = PAGESIZE; /* FIXME: it should be PAGE_SIZE */
  82         Sbi->MmNumberOfPhysicalPages = 0; /* FIXME */
  83         Sbi->MmLowestPhysicalPage = 0; /* FIXME */
  84         Sbi->MmHighestPhysicalPage = 0; /* FIXME */
  85         Sbi->MmLowestUserAddress = 0; /* FIXME */
  86         Sbi->MmLowestUserAddress1 = 0; /* FIXME */
  87         Sbi->MmHighestUserAddress = 0; /* FIXME */
  88         Sbi->KeActiveProcessors = 0x00000001; /* FIXME */
  89         Sbi->KeNumberProcessors = 1; /* FIXME */
  90
  91         return (STATUS_SUCCESS);
  92 }
  93
  94 /* Class 1 - Processor Information */
  95 QSI_DEF(SystemProcessorInformation)
  96 {
  97         PSYSTEM_PROCESSOR_INFORMATION Spi
  98                 = (PSYSTEM_PROCESSOR_INFORMATION) Buffer;
  99
 100         *ReqSize = sizeof (SYSTEM_PROCESSOR_INFORMATION);
 101         /*
 102          * Check user buffer's size
 103          */
 104         if (Size < sizeof (SYSTEM_PROCESSOR_INFORMATION))
 105         {
 106                 return (STATUS_INFO_LENGTH_MISMATCH);
 107         }
 108
 109         /* FIXME: add CPU type detection code */
 110         Spi->KeProcessorArchitecture = 0; /* FIXME */
 111         Spi->KeProcessorLevel = 0; /* FIXME */
 112         Spi->KeProcessorRevision = 0; /* FIXME */
 113         Spi->AlwaysZero = 0;
 114         Spi->KeFeatureBits = 0x00000000; /* FIXME */
 115
 116         return (STATUS_SUCCESS);
 117 }
 118
 119 /* Class 2 - Performance Information */
 120 QSI_DEF(SystemPerformanceInfo)
 121 {
 122         PSYSTEM_PERFORMANCE_INFO Spi
 123                 = (PSYSTEM_PERFORMANCE_INFO) Buffer;
 124
 125         *ReqSize = sizeof (SYSTEM_PERFORMANCE_INFO);
 126         /*
 127          * Check user buffer's size
 128          */
 129         if (Size < sizeof (SYSTEM_PERFORMANCE_INFO))
 130         {
 131                 return (STATUS_INFO_LENGTH_MISMATCH);
 132         }
 133
 134         Spi->TotalProcessorTime.QuadPart = 0; /* FIXME */
 135         Spi->IoReadTransferCount.QuadPart = 0; /* FIXME */
 136         Spi->IoWriteTransferCount.QuadPart = 0; /* FIXME */
 137         Spi->IoOtherTransferCount.QuadPart = 0; /* FIXME */
 138         Spi->IoReadOperationCount = 0; /* FIXME */
 139         Spi->IoWriteOperationCount = 0; /* FIXME */
 140         Spi->IoOtherOperationCount = 0; /* FIXME */
 141         Spi->MmAvailablePages = 0; /* FIXME */
 142         Spi->MmTotalCommitedPages = 0; /* FIXME */
 143         Spi->MmTotalCommitLimit = 0; /* FIXME */
 144         Spi->MmPeakLimit = 0; /* FIXME */
 145         Spi->PageFaults = 0; /* FIXME */
 146         Spi->WriteCopies = 0; /* FIXME */
 147         Spi->TransitionFaults = 0; /* FIXME */
 148         Spi->Unknown1 = 0; /* FIXME */
 149         Spi->DemandZeroFaults = 0; /* FIXME */
 150         Spi->PagesInput = 0; /* FIXME */
 151         Spi->PagesRead = 0; /* FIXME */
 152         Spi->Unknown2 = 0; /* FIXME */
 153         Spi->Unknown3 = 0; /* FIXME */
 154         Spi->PagesOutput = 0; /* FIXME */
 155         Spi->PageWrites = 0; /* FIXME */
 156         Spi->Unknown4 = 0; /* FIXME */
 157         Spi->Unknown5 = 0; /* FIXME */
 158         Spi->PoolPagedBytes = 0; /* FIXME */
 159         Spi->PoolNonPagedBytes = 0; /* FIXME */
 160         Spi->Unknown6 = 0; /* FIXME */
 161         Spi->Unknown7 = 0; /* FIXME */
 162         Spi->Unknown8 = 0; /* FIXME */
 163         Spi->Unknown9 = 0; /* FIXME */
 164         Spi->MmTotalSystemFreePtes = 0; /* FIXME */
 165         Spi->MmSystemCodepage = 0; /* FIXME */
 166         Spi->MmTotalSystemDriverPages = 0; /* FIXME */
 167         Spi->MmTotalSystemCodePages = 0; /* FIXME */
 168         Spi->Unknown10 = 0; /* FIXME */
 169         Spi->Unknown11 = 0; /* FIXME */
 170         Spi->Unknown12 = 0; /* FIXME */
 171         Spi->MmSystemCachePage = 0; /* FIXME */
 172         Spi->MmPagedPoolPage = 0; /* FIXME */
 173         Spi->MmSystemDriverPage = 0; /* FIXME */
 174         Spi->CcFastReadNoWait = 0; /* FIXME */
 175         Spi->CcFastReadWait = 0; /* FIXME */
 176         Spi->CcFastReadResourceMiss = 0; /* FIXME */
 177         Spi->CcFastReadNotPossible = 0; /* FIXME */
 178         Spi->CcFastMdlReadNoWait = 0; /* FIXME */
 179         Spi->CcFastMdlReadWait = 0; /* FIXME */
 180         Spi->CcFastMdlReadResourceMiss = 0; /* FIXME */
 181         Spi->CcFastMdlReadNotPossible = 0; /* FIXME */
 182         Spi->CcMapDataNoWait = 0; /* FIXME */
 183         Spi->CcMapDataWait = 0; /* FIXME */
 184         Spi->CcMapDataNoWaitMiss = 0; /* FIXME */
 185         Spi->CcMapDataWaitMiss = 0; /* FIXME */
 186         Spi->CcPinMappedDataCount = 0; /* FIXME */
 187         Spi->CcPinReadNoWait = 0; /* FIXME */
 188         Spi->CcPinReadWait = 0; /* FIXME */
 189         Spi->CcPinReadNoWaitMiss = 0; /* FIXME */
 190         Spi->CcPinReadWaitMiss = 0; /* FIXME */
 191         Spi->CcCopyReadNoWait = 0; /* FIXME */
 192         Spi->CcCopyReadWait = 0; /* FIXME */
 193         Spi->CcCopyReadNoWaitMiss = 0; /* FIXME */
 194         Spi->CcCopyReadWaitMiss = 0; /* FIXME */
 195         Spi->CcMdlReadNoWait = 0; /* FIXME */
 196         Spi->CcMdlReadWait = 0; /* FIXME */
 197         Spi->CcMdlReadNoWaitMiss = 0; /* FIXME */
 198         Spi->CcMdlReadWaitMiss = 0; /* FIXME */
 199         Spi->CcReadaheadIos = 0; /* FIXME */
 200         Spi->CcLazyWriteIos = 0; /* FIXME */
 201         Spi->CcLazyWritePages = 0; /* FIXME */
 202         Spi->CcDataFlushes = 0; /* FIXME */
 203         Spi->CcDataPages = 0; /* FIXME */
 204         Spi->ContextSwitches = 0; /* FIXME */
 205         Spi->Unknown13 = 0; /* FIXME */
 206         Spi->Unknown14 = 0; /* FIXME */
 207         Spi->SystemCalls = 0; /* FIXME */
 208
 209         return (STATUS_SUCCESS);
 210 }
 211
 212 /* Class 3 - Time Information */
 213 QSI_DEF(SystemTimeInformation)
 214 {
 215         PSYSTEM_TIME_INFORMATION Sti
 216                 = (PSYSTEM_TIME_INFORMATION) Buffer;
 217
 218         *ReqSize = sizeof (SYSTEM_TIME_INFORMATION);
 219         /*
 220          * Check user buffer's size
 221          */
 222         if (Size < sizeof (SYSTEM_TIME_INFORMATION))
 223         {
 224                 return (STATUS_INFO_LENGTH_MISMATCH);
 225         }
 226
 227         Sti->KeBootTime.QuadPart = 0;           /* FIXME */
 228         Sti->KeSystemTime.QuadPart = 0;         /* FIXME */
 229         Sti->ExpTimeZoneBias.QuadPart = 0;      /* FIXME */
 230         Sti->ExpTimeZoneId = 0;                 /* FIXME */
 231         Sti->Unused = 0;                        /* FIXME */
 232
 233         return (STATUS_SUCCESS);
 234 }
 235
 236 /* Class 4 - Path Information */
 237 QSI_DEF(SystemPathInformation)
 238 {
 239         /* FIXME: QSI returns STATUS_BREAKPOINT. Why? */
 240         return (STATUS_BREAKPOINT);
 241 }
 242
 243 /* Class 5 - Process Information */
 244 QSI_DEF(SystemProcessInformation)
 245 {
 246         /* FIXME: scan the process+thread list */
 247         return (STATUS_NOT_IMPLEMENTED);
 248 }
 249
 250 /* Class 6 - SDT Information */
 251 QSI_DEF(SystemServiceDescriptorTableInfo)
 252 {
 253         /* FIXME */
 254         return (STATUS_NOT_IMPLEMENTED);
 255 }
 256
 257 /* Class 7 - I/O Configuration Information */
 258 QSI_DEF(SystemIoConfigInfo)
 259 {
 260         /* FIXME */
 261         return (STATUS_NOT_IMPLEMENTED);
 262 }
 263
 264 /* Class 8 - Processor Time Information */
 265 QSI_DEF(SystemProcessorTimeInfo)
 266 {
 267         /* FIXME */
 268         return (STATUS_NOT_IMPLEMENTED);
 269 }
 270
 271 /* Class 9 - Global Flag Information */
 272 QSI_DEF(SystemNtGlobalFlagInformation)
 273 {
 274         if (sizeof (SYSTEM_GLOBAL_FLAG_INFO) != Size)
 275         {
 276                 * ReqSize = sizeof (SYSTEM_GLOBAL_FLAG_INFO);
 277                 return (STATUS_INFO_LENGTH_MISMATCH);
 278         }
 279         ((PSYSTEM_GLOBAL_FLAG_INFO) Buffer)->NtGlobalFlag = NtGlobalFlag;
 280         return (STATUS_SUCCESS);
 281 }
 282
 283 SSI_DEF(SystemNtGlobalFlagInformation)
 284 {
 285         if (sizeof (SYSTEM_GLOBAL_FLAG_INFO) != Size)
 286         {
 287                 return (STATUS_INFO_LENGTH_MISMATCH);
 288         }
 289         NtGlobalFlag = ((PSYSTEM_GLOBAL_FLAG_INFO) Buffer)->NtGlobalFlag;
 290         return (STATUS_SUCCESS);
 291 }
 292
 293 /* Class 10 - ? Information */
 294 QSI_DEF(SystemInformation10)
 295 {
 296         /* FIXME */
 297         return (STATUS_NOT_IMPLEMENTED);
 298 }
 299
 300 /* Class 11 - Modules Information */
 301 QSI_DEF(SystemModuleInfo)
 302 {
 303         /* FIXME */
 304         return (STATUS_NOT_IMPLEMENTED);
 305 }
 306
 307 /* Class 12 - Resource Lock Information */
 308 QSI_DEF(SystemResourceLockInfo)
 309 {
 310         /* FIXME */
 311         return (STATUS_NOT_IMPLEMENTED);
 312 }
 313
 314 /* Class 13 - ? Information */
 315 QSI_DEF(SystemInformation13)
 316 {
 317         /* FIXME */
 318         return (STATUS_NOT_IMPLEMENTED);
 319 }
 320
 321 /* Class 14 - ? Information */
 322 QSI_DEF(SystemInformation14)
 323 {
 324         /* FIXME */
 325         return (STATUS_NOT_IMPLEMENTED);
 326 }
 327
 328 /* Class 15 - ? Information */
 329 QSI_DEF(SystemInformation15)
 330 {
 331         /* FIXME */
 332         return (STATUS_NOT_IMPLEMENTED);
 333 }
 334
 335 /* Class 16 - Handle Information */
 336 QSI_DEF(SystemHandleInfo)
 337 {
 338         /* FIXME */
 339         return (STATUS_NOT_IMPLEMENTED);
 340 }
 341
 342 /* Class 17 -  Information */
 343 QSI_DEF(SystemObjectInformation)
 344 {
 345         /* FIXME */
 346         return (STATUS_NOT_IMPLEMENTED);
 347 }
 348
 349 /* Class 18 -  Information */
 350 QSI_DEF(SystemPageFileInformation)
 351 {
 352         /* FIXME */
 353         return (STATUS_NOT_IMPLEMENTED);
 354 }
 355
 356 /* Class 19 -  Information */
 357 QSI_DEF(SystemInstructionEmulationInfo)
 358 {
 359         /* FIXME */
 360         return (STATUS_NOT_IMPLEMENTED);
 361 }
 362
 363 /* Class 20 - ? Information */
 364 QSI_DEF(SystemInformation20)
 365 {
 366         /* FIXME */
 367         return (STATUS_NOT_IMPLEMENTED);
 368 }
 369
 370 /* Class 21 -  Information */
 371 QSI_DEF(SystemCacheInformation)
 372 {
 373         if (Size < sizeof (SYSTEM_CACHE_INFORMATION))
 374         {
 375                 * ReqSize = sizeof (SYSTEM_CACHE_INFORMATION);
 376                 return (STATUS_INFO_LENGTH_MISMATCH);
 377         }
 378         /* FIXME */
 379         return (STATUS_NOT_IMPLEMENTED);
 380 }
 381
 382 SSI_DEF(SystemCacheInformation)
 383 {
 384         if (Size < sizeof (SYSTEM_CACHE_INFORMATION))
 385         {
 386                 return (STATUS_INFO_LENGTH_MISMATCH);
 387         }
 388         /* FIXME */
 389         return (STATUS_NOT_IMPLEMENTED);
 390 }
 391
 392 /* Class 22 - Pool Tag Information */
 393 QSI_DEF(SystemPoolTagInformation)
 394 {
 395         /* FIXME */
 396         return (STATUS_NOT_IMPLEMENTED);
 397 }
 398
 399 /* Class 23 - Processor Schedule Information */
 400 QSI_DEF(SystemProcessorScheduleInfo)
 401 {
 402         /* FIXME */
 403         return (STATUS_NOT_IMPLEMENTED);
 404 }
 405
 406 /* Class 24 - DPC Information */
 407 QSI_DEF(SystemDpcInformation)
 408 {
 409         /* FIXME */
 410         return (STATUS_NOT_IMPLEMENTED);
 411 }
 412
 413 SSI_DEF(SystemDpcInformation)
 414 {
 415         /* FIXME */
 416         return (STATUS_NOT_IMPLEMENTED);
 417 }
 418
 419 /* Class 25 - ? Information */
 420 QSI_DEF(SystemInformation25)
 421 {
 422         /* FIXME */
 423         return (STATUS_NOT_IMPLEMENTED);
 424 }
 425
 426 /* Class 26 - Load Image (callable) */
 427 SSI_DEF(SystemLoadImage)
 428 {
 429         /* FIXME */
 430         return (STATUS_NOT_IMPLEMENTED);
 431 }
 432
 433 /* Class 27 - Unload Image (callable) */
 434 SSI_DEF(SystemUnloadImage)
 435 {
 436         /* FIXME */
 437         return (STATUS_NOT_IMPLEMENTED);
 438 }
 439
 440 /* Class 28 -  Information */
 441 QSI_DEF(SystemTimeAdjustmentInformation)
 442 {
 443         if (sizeof (SYSTEM_TIME_ADJUSTMENT_INFO) > Size)
 444         {
 445                 * ReqSize = sizeof (SYSTEM_TIME_ADJUSTMENT_INFO);
 446                 return (STATUS_INFO_LENGTH_MISMATCH);
 447         }
 448         /* FIXME: */
 449         return (STATUS_NOT_IMPLEMENTED);
 450 }
 451
 452 SSI_DEF(SystemTimeAdjustmentInformation)
 453 {
 454         if (sizeof (SYSTEM_TIME_ADJUSTMENT_INFO) > Size)
 455         {
 456                 return (STATUS_INFO_LENGTH_MISMATCH);
 457         }
 458         /* FIXME: */
 459         return (STATUS_NOT_IMPLEMENTED);
 460 }
 461
 462 /* Class 29 - ? Information */
 463 QSI_DEF(SystemInformation29)
 464 {
 465         /* FIXME */
 466         return (STATUS_NOT_IMPLEMENTED);
 467 }
 468
 469 /* Class 30 - ? Information */
 470 QSI_DEF(SystemInformation30)
 471 {
 472         /* FIXME */
 473         return (STATUS_NOT_IMPLEMENTED);
 474 }
 475
 476 /* Class 31 - ? Information */
 477 QSI_DEF(SystemInformation31)
 478 {
 479         /* FIXME */
 480         return (STATUS_NOT_IMPLEMENTED);
 481 }
 482
 483 /* Class 32 - Crach Dump Information */
 484 QSI_DEF(SystemCrashDumpSectionInfo)
 485 {
 486         /* FIXME */
 487         return (STATUS_NOT_IMPLEMENTED);
 488 }
 489
 490 /* Class 33 - Processor Fault Information */
 491 QSI_DEF(SystemProcessorFaultCountInfo)
 492 {
 493         /* FIXME */
 494         return (STATUS_NOT_IMPLEMENTED);
 495 }
 496
 497 /* Class 34 - Crach Dump State Information */
 498 QSI_DEF(SystemCrashDumpStateInfo)
 499 {
 500         /* FIXME */
 501         return (STATUS_NOT_IMPLEMENTED);
 502 }
 503
 504 /* Class 35 - Debugger Information */
 505 QSI_DEF(SystemDebuggerInfo)
 506 {
 507         /* FIXME */
 508         return (STATUS_NOT_IMPLEMENTED);
 509 }
 510
 511 /* Class 36 - Thread Switch Counters Information */
 512 QSI_DEF(SystemThreadSwitchCountersInfo)
 513 {
 514         /* FIXME */
 515         return (STATUS_NOT_IMPLEMENTED);
 516 }
 517
 518 /* Class 37 - Quota Information */
 519 QSI_DEF(SystemQuotaInformation)
 520 {
 521         /* FIXME */
 522         return (STATUS_NOT_IMPLEMENTED);
 523 }
 524
 525 SSI_DEF(SystemQuotaInformation)
 526 {
 527         /* FIXME */
 528         return (STATUS_NOT_IMPLEMENTED);
 529 }
 530
 531 /* Class 38 - Load Driver Information */
 532 SSI_DEF(SystemLoadDriverInfo)
 533 {
 534         /* FIXME */
 535         return (STATUS_NOT_IMPLEMENTED);
 536 }
 537
 538 /* Class 39 - Priority Separation Information */
 539 SSI_DEF(SystemPrioritySeparationInfo)
 540 {
 541         /* FIXME */
 542         return (STATUS_NOT_IMPLEMENTED);
 543 }
 544
 545 /* Class 40 - ? Information */
 546 QSI_DEF(SystemInformation40)
 547 {
 548         /* FIXME */
 549         return (STATUS_NOT_IMPLEMENTED);
 550 }
 551
 552 /* Class 41 - ? Information */
 553 QSI_DEF(SystemInformation41)
 554 {
 555         /* FIXME */
 556         return (STATUS_NOT_IMPLEMENTED);
 557 }
 558
 559 /* Class 42 - ? Information */
 560 QSI_DEF(SystemInformation42)
 561 {
 562         /* FIXME */
 563         return (STATUS_NOT_IMPLEMENTED);
 564 }
 565
 566 /* Class 43 - ? Information */
 567 QSI_DEF(SystemInformation43)
 568 {
 569         /* FIXME */
 570         return (STATUS_NOT_IMPLEMENTED);
 571 }
 572
 573 /* Class 44 -  Information */
 574 QSI_DEF(SystemTimeZoneInformation)
 575 {
 576         * ReqSize = sizeof (TIME_ZONE_INFORMATION);
 577
 578         if (sizeof (TIME_ZONE_INFORMATION) != Size)
 579         {
 580                 return (STATUS_INFO_LENGTH_MISMATCH);
 581         }
 582         /* Copy the time zone information struct */
 583         memcpy (
 584                 Buffer,
 585                 & SystemTimeZoneInfo,
 586                 sizeof (TIME_ZONE_INFORMATION)
 587                 );
 588
 589         return (STATUS_SUCCESS);
 590 }
 591
 592
 593 SSI_DEF(SystemTimeZoneInformation)
 594 {
 595         /*
 596          * Check user buffer's size
 597          */
 598         if (Size < sizeof (TIME_ZONE_INFORMATION))
 599         {
 600                 return (STATUS_INFO_LENGTH_MISMATCH);
 601         }
 602         /* Copy the time zone information struct */
 603         memcpy (
 604                 & SystemTimeZoneInfo,
 605                 (TIME_ZONE_INFORMATION *) Buffer,
 606                 sizeof (TIME_ZONE_INFORMATION)
 607                 );
 608         return (STATUS_SUCCESS);
 609 }
 610
 611
 612 /* Class 45 -  Information */
 613 QSI_DEF(SystemLookasideInformation)
 614 {
 615         /* FIXME */
 616         return (STATUS_NOT_IMPLEMENTED);
 617 }
 618
 619
 620 /* Query/Set Calls Table */
 621 typedef
 622 struct _QSSI_CALLS
 623 {
 624         NTSTATUS (* Query) (PVOID,ULONG,PULONG);
 625         NTSTATUS (* Set) (PVOID,ULONG);
 626
 627 } QSSI_CALLS;
 628
 629 // QS   Query & Set
 630 // QX   Query
 631 // XQ   Set
 632 // XX   unknown behaviour
 633 //
 634 #define SI_QS(n) {QSI_USE(n),SSI_USE(n)}
 635 #define SI_QX(n) {QSI_USE(n),NULL}
 636 #define SI_XS(n) {NULL,SSI_USE(n)}
 637 #define SI_XX(n) {NULL,NULL}
 638
 639 static
 640 QSSI_CALLS
 641 CallQS [] =
 642 {
 643         SI_QX(SystemBasicInformation),
 644         SI_QX(SystemProcessorInformation),
 645         SI_QX(SystemPerformanceInfo),
 646         SI_QX(SystemTimeInformation),
 647         SI_QX(SystemPathInformation), /* should be SI_XX */
 648         SI_QX(SystemProcessInformation),
 649         SI_QX(SystemServiceDescriptorTableInfo),
 650         SI_QX(SystemIoConfigInfo),
 651         SI_QX(SystemProcessorTimeInfo),
 652         SI_QS(SystemNtGlobalFlagInformation),
 653         SI_QX(SystemInformation10), /* should be SI_XX */
 654         SI_QX(SystemModuleInfo),
 655         SI_QX(SystemResourceLockInfo),
 656         SI_QX(SystemInformation13), /* should be SI_XX */
 657         SI_QX(SystemInformation14), /* should be SI_XX */
 658         SI_QX(SystemInformation15), /* should be SI_XX */
 659         SI_QX(SystemHandleInfo),
 660         SI_QX(SystemObjectInformation),
 661         SI_QX(SystemPageFileInformation),
 662         SI_QX(SystemInstructionEmulationInfo),
 663         SI_QX(SystemInformation20), /* it should be SI_XX */
 664         SI_QS(SystemCacheInformation),
 665         SI_QX(SystemPoolTagInformation),
 666         SI_QX(SystemProcessorScheduleInfo),
 667         SI_QS(SystemDpcInformation),
 668         SI_QX(SystemInformation25), /* it should be SI_XX */
 669         SI_XS(SystemLoadImage),
 670         SI_XS(SystemUnloadImage),
 671         SI_QS(SystemTimeAdjustmentInformation),
 672         SI_QX(SystemInformation29), /* it should be SI_XX */
 673         SI_QX(SystemInformation30), /* it should be SI_XX */
 674         SI_QX(SystemInformation31), /* it should be SI_XX */
 675         SI_QX(SystemCrashDumpSectionInfo),
 676         SI_QX(SystemProcessorFaultCountInfo),
 677         SI_QX(SystemCrashDumpStateInfo),
 678         SI_QX(SystemDebuggerInfo),
 679         SI_QX(SystemThreadSwitchCountersInfo),
 680         SI_QS(SystemQuotaInformation),
 681         SI_XS(SystemLoadDriverInfo),
 682         SI_XS(SystemPrioritySeparationInfo),
 683         SI_QX(SystemInformation40), /* it should be SI_XX */
 684         SI_QX(SystemInformation41), /* it should be SI_XX */
 685         SI_QX(SystemInformation42), /* it should be SI_XX */
 686         SI_QX(SystemInformation43), /* it should be SI_XX */
 687         SI_QS(SystemTimeZoneInformation), /* it should be SI_QX */
 688         SI_QX(SystemLookasideInformation)
 689 };
 690
 691
 692 NTSTATUS
 693 STDCALL
 694 NtQuerySystemInformation (
 695         IN      SYSTEM_INFORMATION_CLASS        SystemInformationClass,
 696         OUT     PVOID                           SystemInformation,
 697         IN      ULONG                           Length,
 698         OUT     PULONG                          ResultLength
 699         )
 700 {
 701         /*
 702          * If called from user mode, check
 703          * possible unsafe arguments.
 704          */
 705 #if 0
 706         if (KernelMode != KeGetPreviousMode())
 707         {
 708                 // Check arguments
 709                 //ProbeForWrite(
 710                 //      SystemInformation,
 711                 //      Length
 712                 //      );
 713                 //ProbeForWrite(
 714                 //      ResultLength,
 715                 //      sizeof (ULONG)
 716                 //      );
 717         }
 718 #endif
 719         /*
 720          * Clear the user buffer.
 721          */
 722         RtlZeroMemory (SystemInformation, Length);
 723         /*
 724          * Check the request is valid.
 725          */
 726         if (    (SystemInformationClass >= SystemInformationClassMin)
 727                 && (SystemInformationClass < SystemInformationClassMax)
 728                 )
 729         {
 730                 if (NULL != CallQS [SystemInformationClass].Query)
 731                 {
 732                         /*
 733                          * Hand the request to a subhandler.
 734                          */
 735                         return CallQS [SystemInformationClass].Query (
 736                                         SystemInformation,
 737                                         Length,
 738                                         ResultLength
 739                                         );
 740                 }
 741         }
 742         return (STATUS_INVALID_INFO_CLASS);
 743 }
 744
 745
 746 NTSTATUS
 747 STDCALL
 748 NtSetSystemInformation (
 749         IN      SYSTEM_INFORMATION_CLASS        SystemInformationClass,
 750         IN      PVOID                           SystemInformation,
 751         IN      ULONG                           SystemInformationLength
 752         )
 753 {
 754         /*
 755          * If called from user mode, check
 756          * possible unsafe arguments.
 757          */
 758 #if 0
 759         if (KernelMode != KeGetPreviousMode())
 760         {
 761                 // Check arguments
 762                 //ProbeForWrite(
 763                 //      SystemInformation,
 764                 //      Length
 765                 //      );
 766                 //ProbeForWrite(
 767                 //      ResultLength,
 768                 //      sizeof (ULONG)
 769                 //      );
 770         }
 771 #endif
 772         /*
 773          * Check the request is valid.
 774          */
 775         if (    (SystemInformationClass >= SystemInformationClassMin)
 776                 && (SystemInformationClass < SystemInformationClassMax)
 777                 )
 778         {
 779                 if (NULL != CallQS [SystemInformationClass].Set)
 780                 {
 781                         /*
 782                          * Hand the request to a subhandler.
 783                          */
 784                         return CallQS [SystemInformationClass].Set (
 785                                         SystemInformation,
 786                                         SystemInformationLength
 787                                         );
 788                 }
 789         }
 790         return (STATUS_INVALID_INFO_CLASS);
 791 }
 792
 793
 794 NTSTATUS
 795 STDCALL
 796 NtFlushInstructionCache (
 797         IN      HANDLE  ProcessHandle,
 798         IN      PVOID   BaseAddress,
 799         IN      UINT    NumberOfBytesToFlush
 800         )
 801 {
 802         UNIMPLEMENTED;
 803 }
 804
 805
 806 /* EOF */