bugcodes.pas

详细Windows API大全有关知识以及相关问题

//  restart your computer.
//  
//  Refer to your Getting Started manual for more information on
//  troubleshooting Stop errors.
//

  BUGCODE_PSS_MESSAGE_7B = ULONG($000000B2);
  {$EXTERNALSYM BUGCODE_PSS_MESSAGE_7B}

//
// MessageId: BUGCODE_PSS_MESSAGE_7F
//
// MessageText:
//
//  If this is the first time you've seen this Stop error screen,
//  restart your computer. If this screen appears again, follow
//  these steps:
//  
//  Run a system diagnostic utility supplied by your hardware manufacturer.
//  In particular, run a memory check, and check for faulty or mismatched
//  memory. Try changing video adapters.
//  
//  Disable or remove any newly installed hardware and drivers. Disable or
//  remove any newly installed software. If you need to use Safe Mode to
//  remove or disable components, restart your computer, press F8 to select
//  Advanced Startup Options, and then select Safe Mode.
//  
//  Refer to your Getting Started manual for more information on
//  troubleshooting Stop errors.
//

  BUGCODE_PSS_MESSAGE_7F = ULONG($000000B3);
  {$EXTERNALSYM BUGCODE_PSS_MESSAGE_7F}

//
// MessageId: VIDEO_DRIVER_INIT_FAILURE
//
// MessageText:
//
//  The video driver failed to initialize
//

  VIDEO_DRIVER_INIT_FAILURE = ULONG($000000B4);
  {$EXTERNALSYM VIDEO_DRIVER_INIT_FAILURE}

//
// MessageId: BOOTLOG_LOADED
//
// MessageText:
//
//  Loaded driver
//

  BOOTLOG_LOADED = ULONG($000000B5);
  {$EXTERNALSYM BOOTLOG_LOADED}

//
// MessageId: BOOTLOG_NOT_LOADED
//
// MessageText:
//
//  Did not load driver
//

  BOOTLOG_NOT_LOADED = ULONG($000000B6);
  {$EXTERNALSYM BOOTLOG_NOT_LOADED}

//
// MessageId: BOOTLOG_ENABLED
//
// MessageText:
//
//  Boot Logging Enabled
//

  BOOTLOG_ENABLED = ULONG($000000B7);
  {$EXTERNALSYM BOOTLOG_ENABLED}

//
// MessageId: ATTEMPTED_SWITCH_FROM_DPC
//
// MessageText:
//
//  A wait operation, attach process, or yield was attempted from a DPC routine.
//

  ATTEMPTED_SWITCH_FROM_DPC = ULONG($000000B8);
  {$EXTERNALSYM ATTEMPTED_SWITCH_FROM_DPC}

//
// MessageId: CHIPSET_DETECTED_ERROR
//
// MessageText:
//
//  A parity error in the system memory or I/O system was detected.
//

  CHIPSET_DETECTED_ERROR = ULONG($000000B9);
  {$EXTERNALSYM CHIPSET_DETECTED_ERROR}

//
// MessageId: SESSION_HAS_VALID_VIEWS_ON_EXIT
//
// MessageText:
//
//  SESSION_HAS_VALID_VIEWS_ON_EXIT
//

  SESSION_HAS_VALID_VIEWS_ON_EXIT = ULONG($000000BA);
  {$EXTERNALSYM SESSION_HAS_VALID_VIEWS_ON_EXIT}

//
// MessageId: NETWORK_BOOT_INITIALIZATION_FAILED
//
// MessageText:
//
//  An initialization failure occurred while attempting to boot from the network.
//

  NETWORK_BOOT_INITIALIZATION_FAILED = ULONG($000000BB);
  {$EXTERNALSYM NETWORK_BOOT_INITIALIZATION_FAILED}

//
// MessageId: NETWORK_BOOT_DUPLICATE_ADDRESS
//
// MessageText:
//
//  A duplicate IP address was assigned to this machine while attempting to
//  boot from the network.
//

  NETWORK_BOOT_DUPLICATE_ADDRESS = ULONG($000000BC);
  {$EXTERNALSYM NETWORK_BOOT_DUPLICATE_ADDRESS}

//
// MessageId: INVALID_HIBERNATED_STATE
//
// MessageText:
//
//  The hibernated memory image does not match the current hardware configuration.
//

  INVALID_HIBERNATED_STATE = ULONG($000000BD);
  {$EXTERNALSYM INVALID_HIBERNATED_STATE}

//
// MessageId: ATTEMPTED_WRITE_TO_READONLY_MEMORY
//
// MessageText:
//
//  An attempt was made to write to read-only memory.
//

  ATTEMPTED_WRITE_TO_READONLY_MEMORY = ULONG($000000BE);
  {$EXTERNALSYM ATTEMPTED_WRITE_TO_READONLY_MEMORY}

//
// MessageId: MUTEX_ALREADY_OWNED
//
// MessageText:
//
//  MUTEX_ALREADY_OWNED
//

  MUTEX_ALREADY_OWNED = ULONG($000000BF);
  {$EXTERNALSYM MUTEX_ALREADY_OWNED}

//
// MessageId: PCI_CONFIG_SPACE_ACCESS_FAILURE
//
// MessageText:
//
//  An attempt to access PCI configuration space failed.
//

  PCI_CONFIG_SPACE_ACCESS_FAILURE = ULONG($000000C0);
  {$EXTERNALSYM PCI_CONFIG_SPACE_ACCESS_FAILURE}

//
// MessageId: SPECIAL_POOL_DETECTED_MEMORY_CORRUPTION
//
// MessageText:
//
//  SPECIAL_POOL_DETECTED_MEMORY_CORRUPTION
//

  SPECIAL_POOL_DETECTED_MEMORY_CORRUPTION = ULONG($000000C1);
  {$EXTERNALSYM SPECIAL_POOL_DETECTED_MEMORY_CORRUPTION}

//
// MessageId: BAD_POOL_CALLER
//
// MessageText:
//
//  BAD_POOL_CALLER
//

  BAD_POOL_CALLER = ULONG($000000C2);
  {$EXTERNALSYM BAD_POOL_CALLER}

//
// MessageId: BUGCODE_PSS_MESSAGE_SIGNATURE
//
// MessageText:
//
//  
//  A system file that is owned by Windows 2000 was replaced by an application
//  running on your system.  The operating system detected this and tried to
//  verify the validity of the file's signature.  The operating system found that
//  the file signature is not valid and put the original, correct file back
//  so that your operating system will continue to function properly.
//

  BUGCODE_PSS_MESSAGE_SIGNATURE = ULONG($000000C3);
  {$EXTERNALSYM BUGCODE_PSS_MESSAGE_SIGNATURE}

//
// MessageId: DRIVER_VERIFIER_DETECTED_VIOLATION
//
// MessageText:
//
//  
//  A device driver attempting to corrupt the system has been caught.
//  The faulty driver currently on the kernel stack must be replaced
//  with a working version.
//

  DRIVER_VERIFIER_DETECTED_VIOLATION = ULONG($000000C4);
  {$EXTERNALSYM DRIVER_VERIFIER_DETECTED_VIOLATION}

//
// MessageId: DRIVER_CORRUPTED_EXPOOL
//
// MessageText:
//
//  
//  A device driver has corrupted the executive memory pool.
//  
//  If this is the first time you've seen this Stop error screen,
//  restart your computer. If this screen appears again, follow
//  these steps:
//  
//  Check to make sure any new hardware or software is properly installed.
//  If this is a new installation, ask your hardware or software manufacturer
//  for any Windows 2000 updates you might need.
//  
//  Run the driver verifier against any new (or suspect) drivers.
//  If that doesn't reveal the corrupting driver, try enabling special pool.
//  Both of these features are intended to catch the corruption at an earlier
//  point where the offending driver can be identified.
//  
//  If you need to use Safe Mode to remove or disable components,
//  restart your computer, press F8 to select Advanced Startup Options,
//  and then select Safe Mode.
//  
//  Refer to your Getting Started manual for more information on
//  troubleshooting Stop errors.
//

  DRIVER_CORRUPTED_EXPOOL = ULONG($000000C5);
  {$EXTERNALSYM DRIVER_CORRUPTED_EXPOOL}

//
// MessageId: DRIVER_CAUGHT_MODIFYING_FREED_POOL
//
// MessageText:
//
//  
//  A device driver attempting to corrupt the system has been caught.
//  The faulty driver currently on the kernel stack must be replaced
//  with a working version.
//

  DRIVER_CAUGHT_MODIFYING_FREED_POOL = ULONG($000000C6);
  {$EXTERNALSYM DRIVER_CAUGHT_MODIFYING_FREED_POOL}

//
// MessageId: TIMER_OR_DPC_INVALID
//
// MessageText:
//
//  
//  A kernel timer or DPC was found in memory which must not contain such
//  items.  Usually this is memory being freed.  This is usually caused by
//  a device driver that has not cleaned up properly before freeing memory.
//

  TIMER_OR_DPC_INVALID = ULONG($000000C7);
  {$EXTERNALSYM TIMER_OR_DPC_INVALID}

//
// MessageId: IRQL_UNEXPECTED_VALUE
//
// MessageText:
//
//  
//  The processor's IRQL is not valid for the currently executing context.
//  This is a software error condition and is usually caused by a device
//  driver changing IRQL and not restoring it to its previous value when
//  it has finished its task.
//

  IRQL_UNEXPECTED_VALUE = ULONG($000000C8);
  {$EXTERNALSYM IRQL_UNEXPECTED_VALUE}

//
// MessageId: DRIVER_VERIFIER_IOMANAGER_VIOLATION
//
// MessageText:
//
//  
//  The IO manager has detected a violation by a driver that is being verified.
//  The faulty driver that is being verified must be debugged and
//  replaced with a working version.
//

  DRIVER_VERIFIER_IOMANAGER_VIOLATION = ULONG($000000C9);
  {$EXTERNALSYM DRIVER_VERIFIER_IOMANAGER_VIOLATION}

//
// MessageId: PNP_DETECTED_FATAL_ERROR
//
// MessageText:
//
//  
//  Plug and Play detected an error most likely caused by a faulty driver.
//

  PNP_DETECTED_FATAL_ERROR = ULONG($000000CA);
  {$EXTERNALSYM PNP_DETECTED_FATAL_ERROR}

//
// MessageId: DRIVER_LEFT_LOCKED_PAGES_IN_PROCESS
//
// MessageText:
//
//  DRIVER_LEFT_LOCKED_PAGES_IN_PROCESS
//

  DRIVER_LEFT_LOCKED_PAGES_IN_PROCESS = ULONG($000000CB);
  {$EXTERNALSYM DRIVER_LEFT_LOCKED_PAGES_IN_PROCESS}

//
// MessageId: PAGE_FAULT_IN_FREED_SPECIAL_POOL
//
// MessageText:
//
//  
//  The system is attempting to access memory after it has been freed.
//  This usually indicates a system-driver synchronization issue.
//

  PAGE_FAULT_IN_FREED_SPECIAL_POOL = ULONG($000000CC);
  {$EXTERNALSYM PAGE_FAULT_IN_FREED_SPECIAL_POOL}

//
// MessageId: PAGE_FAULT_BEYOND_END_OF_ALLOCATION
//
// MessageText:
//
//  
//  The system is attempting to access memory beyond the end of the allocation.
//  This usually indicates a system-driver synchronization issue.
//

  PAGE_FAULT_BEYOND_END_OF_ALLOCATION = ULONG($000000CD);
  {$EXTERNALSYM PAGE_FAULT_BEYOND_END_OF_ALLOCATION}

//
// MessageId: DRIVER_UNLOADED_WITHOUT_CANCELLING_PENDING_OPERATIONS
//
// MessageText:
//
//  DRIVER_UNLOADED_WITHOUT_CANCELLING_PENDING_OPERATIONS
//

  DRIVER_UNLOADED_WITHOUT_CANCELLING_PENDING_OPERATIONS = ULONG($000000CE);
  {$EXTERNALSYM DRIVER_UNLOADED_WITHOUT_CANCELLING_PENDING_OPERATIONS}

//
// MessageId: TERMINAL_SERVER_DRIVER_MADE_INCORRECT_MEMORY_REFERENCE
//
// MessageText:
//
//  TERMINAL_SERVER_DRIVER_MADE_INCORRECT_MEMORY_REFERENCE
//

  TERMINAL_SERVER_DRIVER_MADE_INCORRECT_MEMORY_REFERENCE = ULONG($000000CF);
  {$EXTERNALSYM TERMINAL_SERVER_DRIVER_MADE_INCORRECT_MEMORY_REFERENCE}

//
// MessageId: DRIVER_CORRUPTED_MMPOOL
//
// MessageText:
//
//  
//  A device driver has corrupted the system memory management pool.
//  
//  If this is the first time you've seen this Stop error screen,
//  restart your computer. If this screen appears again, follow
//  these steps:
//  
//  Check to make sure any new hardware or software is properly installed.
//  If this is a new installation, ask your hardware or software manufacturer
//  for any Windows 2000 updates you might need.
//  
//  Run the driver verifier against any new (or suspect) drivers.
//  If that doesn't reveal the corrupting driver, try enabling special pool.
//  Both of these features are intended to catch the corruption at an earlier
//  point where the offending driver can be identified.
//  
//  If you need to use Safe Mode to remove or disable components,
//  restart your computer, press F8 to select Advanced Startup Options,
//  and then select Safe Mode.
//  
//  Refer to your Getting Started manual for more information on
//  troubleshooting Stop errors.
//

  DRIVER_CORRUPTED_MMPOOL = ULONG($000000D0);
  {$EXTERNALSYM DRIVER_CORRUPTED_MMPOOL}

//
// MessageId: DRIVER_IRQL_NOT_LESS_OR_EQUAL
//
// MessageText:
//
//  DRIVER_IRQL_NOT_LESS_OR_EQUAL
//

  DRIVER_IRQL_NOT_LESS_OR_EQUAL = ULONG($000000D1);
  {$EXTERNALSYM DRIVER_IRQL_NOT_LESS_OR_EQUAL}

//
// MessageId: BUGCODE_ID_DRIVER
//
// MessageText:
//
//  This driver may be at fault :
//

  BUGCODE_ID_DRIVER = ULONG($000000D2);
  {$EXTERNALSYM BUGCODE_ID_DRIVER}

//
// MessageId: DRIVER_PORTION_MUST_BE_NONPAGED
//
// MessageText:
//
//  The driver mistakenly marked a part of it's image pagable instead of nonpagable.
//

  DRIVER_PORTION_MUST_BE_NONPAGED = ULONG($000000D3);
  {$EXTERNALSYM DRIVER_PORTION_MUST_BE_NONPAGED}

//
// MessageId: SYSTEM_SCAN_AT_RAISED_IRQL_CAUGHT_IMPROPER_DRIVER_UNLOAD
//
// MessageText:
//
//  The driver unloaded without cancelling pending operations.
//

  SYSTEM_SCAN_AT_RAISED_IRQL_CAUGHT_IMPROPER_DRIVER_UNLOAD = ULONG($000000D4);
  {$EXTERNALSYM SYSTEM_SCAN_AT_RAISED_IRQL_CAUGHT_IMPROPER_DRIVER_UNLOAD}

//
// MessageId: DRIVER_PAGE_FAULT_IN_FREED_SPECIAL_POOL
//
// MessageText:
//
//  
//  The driver is attempting to access memory after it has been freed.
//

  DRIVER_PAGE_FAULT_IN_FREED_SPECIAL_POOL = ULONG($000000D5);
  {$EXTERNALSYM DRIVER_PAGE_FAULT_IN_FREED_SPECIAL_POOL}

//
// MessageId: DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION
//
// MessageText:
//
//  
//  The driver is attempting to access memory beyond the end of the allocation.
//

  DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION = ULONG($000000D6);
  {$EXTERNALSYM DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION}

//
// MessageId: DRIVER_UNMAPPING_INVALID_VIEW
//
// MessageText:
//
//  
//  The driver is attempting to unmap an invalid memory address.
//

  DRIVER_UNMAPPING_INVALID_VIEW = ULONG($000000D7);
  {$EXTERNALSYM DRIVER_UNMAPPING_INVALID_VIEW}

//
// MessageId: DRIVER_USED_EXCESSIVE_PTES
//
// MessageText:
//
//  
//  The driver has used an excessive number of system PTEs.
//

  DRIVER_USED_EXCESSIVE_PTES = ULONG($000000D8);
  {$EXTERNALSYM DRIVER_USED_EXCESSIVE_PTES}

//
// MessageId: LOCKED_PAGES_TRACKER_CORRUPTION
//
// MessageText:
//
//  
//  The driver is corrupting the locked pages tracking structures.
//

  LOCKED_PAGES_TRACKER_CORRUPTION = ULONG($000000D9);
  {$EXTERNALSYM LOCKED_PAGES_TRACKER_CORRUPTION}

//
// MessageId: SYSTEM_PTE_MISUSE
//
// MessageText:
//
//  
//  The driver is mismanaging system PTEs.
//

  SYSTEM_PTE_MISUSE = ULONG($000000DA);
  {$EXTERNALSYM SYSTEM_PTE_MISUSE}

//
// MessageId: DRIVER_CORRUPTED_SYSPTES
//
// MessageText:
//
//  
//  A driver has corrupted the memory management system PTEs.
//

  DRIVER_CORRUPTED_SYSPTES = ULONG($000000DB);
  {$EXTERNALSYM DRIVER_CORRUPTED_SYSPTES}

//
// MessageId: DRIVER_INVALID_STACK_ACCESS
//
// MessageText:
//
//  
//  A driver accessed a stack address that lies below the current stack pointer
//  of the stack's thread.
//

  DRIVER_INVALID_STACK_ACCESS = ULONG($000000DC);
  {$EXTERNALSYM DRIVER_INVALID_STACK_ACCESS}

//
// MessageId: BUGCODE_PSS_MESSAGE_A5
//
// MessageText:
//
//  
//  The BIOS in this system is not fully ACPI compliant.  Please contact your
//  system vendor or visit http://www.hardware-update.com for an updated BIOS.  
//  If you are unable to obtain an updated BIOS or the latest BIOS supplied by 
//  your vendor is not ACPI compliant, you can turn off ACPI mode during text 
//  mode setup.  To do this, simply press the F7 key when you are prompted to 
//  install storage drivers.  The system will not notify you that the F7 key 
//  was pressed - it will silently disable ACPI and allow you to continue 
//  your installation.
//

  BUGCODE_PSS_MESSAGE_A5 = ULONG($000000DD);
  {$EXTERNALSYM BUGCODE_PSS_MESSAGE_A5}

//
// MessageId: POOL_CORRUPTION_IN_FILE_AREA
//
// MessageText:
//
//  
//  A driver corrupted pool memory used for holding pages destined for disk.
//

  POOL_CORRUPTION_IN_FILE_AREA = ULONG($000000DE);
  {$EXTERNALSYM POOL_CORRUPTION_IN_FILE_AREA}

//
// MessageId: HARDWARE_PROFILE_UNDOCKED_STRING
//
// MessageText:
//
//  Undocked Profile
//

  HARDWARE_PROFILE_UNDOCKED_STRING = ULONG($40010001);
  {$EXTERNALSYM HARDWARE_PROFILE_UNDOCKED_STRING}

//
// MessageId: HARDWARE_PROFILE_DOCKED_STRING
//
// MessageText:
//
//  Docked Profile
//

  HARDWARE_PROFILE_DOCKED_STRING = ULONG($40010002);
  {$EXTERNALSYM HARDWARE_PROFILE_DOCKED_STRING}

//
// MessageId: HARDWARE_PROFILE_UNKNOWN_STRING
//
// MessageText:
//
//  Profile
//

  HARDWARE_PROFILE_UNKNOWN_STRING = ULONG($40010003);
  {$EXTERNALSYM HARDWARE_PROFILE_UNKNOWN_STRING}

//
// MessageId: IMPERSONATING_WORKER_THREAD
//
// MessageText:
//
//  
//  A worker thread is impersonating another process. The work item forgot to
//  disable impersonation before it returned.
//

  IMPERSONATING_WORKER_THREAD = ULONG($000000DF);
  {$EXTERNALSYM IMPERSONATING_WORKER_THREAD}

//
// MessageId: ACPI_BIOS_FATAL_ERROR
//
// MessageText:
//
//  
//  Your computer (BIOS) has reported that a component in your system is faulty and
//  has prevented Windows from operating.  You can determine which component is
//  faulty by running the diagnostic disk or tool that came with your computer.
//  
//  If you do not have this tool, you must contact your system vendor and report
//  this error message to them.  They will be able to assist you in correcting this
//  hardware problem thereby allowing Windows to operate.
//

  ACPI_BIOS_FATAL_ERROR = ULONG($000000E0);
  {$EXTERNALSYM ACPI_BIOS_FATAL_ERROR}

//
// MessageId: WORKER_THREAD_RETURNED_AT_BAD_IRQL
//
// MessageText:
//
//  WORKER_THREAD_RETURNED_AT_BAD_IRQL
//

  WORKER_THREAD_RETURNED_AT_BAD_IRQL = ULONG($000000E1);
  {$EXTERNALSYM WORKER_THREAD_RETURNED_AT_BAD_IRQL}

//
// MessageId: MANUALLY_INITIATED_CRASH
//
// MessageText:
//
//  
//  The end-user manually generated the crashdump.
//

  MANUALLY_INITIATED_CRASH = ULONG($000000E2);
  {$EXTERNALSYM MANUALLY_INITIATED_CRASH}

//
// MessageId: RESOURCE_NOT_OWNED
//
// MessageText:
//
//  
//  A thread tried to release a resource it did not own.
//

  RESOURCE_NOT_OWNED = ULONG($000000E3);
  {$EXTERNALSYM RESOURCE_NOT_OWNED}

//
// MessageId: WORKER_INVALID
//
// MessageText:
//
//  
//  A executive worker item was found in memory which must not contain such
//  items.  Usually this is memory being freed.  This is usually caused by
//  a device driver that has not cleaned up properly before freeing memory.
//

  WORKER_INVALID = ULONG($000000E4);
  {$EXTERNALSYM WORKER_INVALID}

implementation

end.