REA repair

How to understand what the problem is when a blue screen (BSOD) appears or how to open the dump file. Computer Error Codes Identifying Error Text Messages

30.06.2023

The Anniversary update of the Windows 10 operating system added many utilities and additional programs that the user may need. Microsoft has also introduced a new diagnostic application that allows you to determine the cause of the Blue Screen, a well-known error that causes your computer to restart. If the blue screen occurs frequently, it is important for the user to find out why it is happening and then take steps to resolve the problem.

How to find out the cause of a blue screen (BSOD) in Windows 10

Before the Anniversary update on Windows 10, you could only find out the cause of a blue screen in your computer's system files. Microsoft strives to reduce the number of interactions between the user and PC system data by releasing various utilities and diagnostic applications to detect blue screens.

To find out the cause of the blue screen in Windows 10 after the Anniversary update, you need to do the following:



It is important to remember that a blue screen does not always occur when running Windows due to a software error. It may appear due to problems with hardware (overheating or damage to computer components) or viruses. When the error is detected by the diagnostic Windows utility, you can find out more about it on the Microsoft website using the BugCheck error code.

Why you need to diagnose the cause of a blue screen

Many Windows users consider it normal for the computer to reboot several times a month due to a BSOD - blue screen. This error is familiar to many, and they do not think about the many problems it can lead to:

If a blue screen appears regularly, you must determine the cause of the error and eliminate it.

In this article we will talk about such a phenomenon in the Windows operating system as - Blue Screen of Death or in our opinion blue screen of death", also called STOP error. Let's look at the main causes and decipher these error codes.

First, let's define what " Blue Screen of Death" is a way to generate a fatal error message in operating systems. Windows systems NT 4.0, Windows 2000, Windows 2003, Windows XP, Windows Vista and Windows 7 caused by malfunctions of some programs or drivers, but still more often due to computer hardware failures.

Blue screen causes all processes in the operating system to stop and the computer to freeze after displaying a blue screen. In general, the blue screen helps us, you may ask, in what way, but in that it prevents the destruction of the operating system and the failure of equipment. When " blue screen of death» the error code and how to solve it are displayed. But it may be that the STOP error was caused, for example, by corruption of data packets transmitted via local network, in this case a simple reboot helps. If the error appears every time you start the operating system, then this may already be a problem related to the computer hardware, for example, damaged drivers, file system, hard drive, RAM memory blocks. But to find out the reasons for the error that occurred, it is necessary to rewrite the first two output lines of the STOP error. For example, as shown just below:

STOP 0x0000006B (0xC0000022, 0x00000000, 0x00000000, 0x00000000) PROCESS1_INITIALIZATION_FAILED

Where 0xC0000022, 0x00000000, 0x00000000, 0x00000000— parameters that reveal the meaning of this BSoD.

By the way, there is a small feature, it lies in the fact that in the operating system, in order to see the blue screen, you must first turn on this windows possibility, or you simply won’t see this screen; if an error occurs, the computer will simply reboot quickly (and so on every time).

To enable this option, go to the properties of “My Computer”, select the “Advanced” tab. In the "Boot and Recovery" field, click the "Options" button. In the window that appears, uncheck the box next to “Perform automatic reboot.”

When a STOP error appears, the text of the message briefly describes the method for solving it. English. But I can say for sure that currently the common cause of STOP errors is hardware problems with the computer hardware or its software parts, and sometimes due to inconsistencies between one and the other.

Now let's move directly to the errors themselves and look at the reasons for their occurrence and short solutions.

0x00000001: APC_INDEX_MISMATCH

Internal kernel error. The problem is most often associated with a driver problem, lack of RAM or hard drive space.

0x0000000A: IRQL_NOT_LESS_OR_EQUAL

There was virtual memory interference on a high-level internal IRQ process. The most common cause is that the device driver is using the wrong address. The error occurs due to bad drivers. Rarely occurs due to a malfunction of one of the devices in the system.
Parameters:

  1. Address where the erroneous request was made
  2. IRQL that was used to access memory
  3. Memory access type: 0 = read operation, 1 = write operation
  4. Address of the instruction that requested memory access at address

0x0000001E: KMODE_EXCEPTION_NOT_HANDLED

This is a very common mistake. Typically the excluded address points to the driver or function that caused the freeze screen. Always pay attention not only to the specified driver, but also to the address or image itself that contains this error. This is usually the exception code 0x80000003. This error means that a breakpoint or handler was initialized during a memory access, but the system booted with the /NODEBUG switch. This error may not appear too often. If the error appears constantly, make sure that the debugger is connected and the system boots with the /DEBUG key.
On non-Intel systems, if the exception address is 0XBFC0304, the error occurs due to processor caching. If the error persists, contact your processor manufacturer.
Typically, you need to look at the second parameter of this message, which indicates the address of the driver/function that was causing the problem.
Parameters:

  1. Exception code
  2. Address that failed to process
  3. Parameter 0 - exception
  4. Parameter 1 - exception

0x00000020: KERNEL_APC_PENDING_DURING_EXIT

The error name indicates a damaged/disabled APC counter. If you have this situation, check all file systems installed on the machine, for example using the EMRD rescue kit.
The current IRQL must be zero. If the IRQ is not zero, then the specific order in which drivers are unloaded when returning to a higher IRQ level may cause an error. Try to remember what you were doing or what applications you closed, what drivers were installed at the time the blue screen occurred. This symptom indicates a serious problem with third-party drivers.
Parameters:

  1. APC address at the time of failure.
  2. Failed APC thread
  3. Current IRQ level

0x00000023: FAT_FILE_SYSTEM

FAT).

0x00000024: NTFS_FILE_SYSTEM

There was a failure to read or write to a hard disk partition with the format NTFS. The failure may be due to damage to the file system, or to the appearance of bad sectors on the disk. The failure may also be due to software, changing the disk structure ( encryption programs, etc.).

0x0000002A: INCONSISTENT_IRP

I/O Request Packet (IRP) is not functioning; Occurs when a field or multiple fields are incorrect compared to the preserved IRP state. For example, the IRP was already disabled when a device driver was waiting for a command.
Parameters:
1 - the address at which the IRP was found in idle mode

0x0000002B: PANIC_STACK_SWITCH

This error occurs when the kernel stack area is full. The error occurs when the kernel driver uses too much stack space. A possible cause of the error could also be damage to the kernel itself.

0x0000002E: DATA_BUS_ERROR

This STOP error most often occurs due to a failure in the RAM area. This can happen when the driver tries to access a memory address that does not exist.
Parameters:

  1. Virtual memory address that caused the error
  2. Physical address of the error cause
  3. Processor Status Record (PSR)
  4. Error Instruction Logging (FIR)

0x00000031: PHASE0_INITIALIZATION_FAILED

System initialization could not be completed at an early stage (phase 0). It is necessary to study the error in more detail, since this error code says practically nothing.
0x00000032: PHASE1_INITIALIZATION_FAILED
System initialization could not be completed at a late stage (phase 1). It is necessary to study the error in more detail, since this error code says practically nothing.
Parameters:

  1. System level code that describes why the system believes that initialization has not completed
  2. Indicates the location within INIT.C where phase 1 initialization failed

0x00000035: NO_MORE_IRP_STACK_LOCATIONS

The high level driver tried to call the low level driver through the IoCallDriver() interface, but the system did not have free space in the stack area, for this reason the low level driver will not reach the required parameters, since there are no parameters for it at all. This is a fatal situation because the high-level driver thinks it has filled in the parameters for the low-level driver (something it had to do to call the low-level driver). However, since there is no free space in the stack area, the end of the packet was overwritten. This often occurs due to corruption of stack memory blocks. It is necessary to check the memory and drivers for errors.
Parameters:
1 - IRP address

0x00000036: DEVICE_REFERENCE_COUNT_NOT_ZERO

The device driver tried to remove one of the components of its device from the system, but the hit counter of this component was not equal to zero - this means that there are some outstanding tasks behind this component (the counter indicates an error code, which is why this component cannot be unloaded). This is a driver call error.
Parameters:
1 — object address

0x0000003E: MULTIPROCESSOR_CONFIGURATION_NOT_SUPPORTED

A multiprocessor system is not symmetrical with respect to each other. For proper symmetry, processors must be of the same type and level. For example, trying to use a Pentium and 80486 processor at the same time will cause an error. In addition, on x86 systems, floating point capabilities must be available on all processors or on none.

0x0000003F: NO_MORE_SYSTEM_PTES

There are not enough PTE (page file entries - access points to the paging file). Usually the cause is a driver that does not clean out the swap file well and it becomes full. The cause may also be excessive fragmentation of the paging file.

0x00000040: TARGET_MDL_TOO_SMALL

The driver called IoBuildPartialMdl() and passed the MDL to it to reveal the source portion of the MDL, but the destination MDL area is not large enough to show the limits of the required addresses. This is a driver error.

0x00000041: MUST_SUCCEED_POOL_EMPTY

The system driver has requested space in the Must Suceed Pool. This function cannot be done because the system does not allocate space in the Must Suceed Pool. Replace or update the faulty system driver.
Parameters:

  1. Amount of request required
  2. Page number used
  3. Number of pages requested
  4. Number of available pages

0x00000044: MULTIPLE_IRP_COMPLETE_REQUESTS

The driver requested completion of the IRP, but the packet was already completed. This error is difficult to detect. A possible cause is that the driver is trying to complete the same operation multiple times. Rare reason - 2 various drivers trying to take possession of the package and terminate it. The first one usually works, but the second one doesn’t. It is difficult to track which driver did this, since traces of the first driver were overwritten by the second.
Parameters:
1 - IRP address

0x00000048: CANCEL_STATE_IN_COMPLETED_IRP

This error indicates that the I/O Request Packet (IRP) that must be terminated has a cancellation order defined within it, i.e. this means that a package in this mode can be canceled. However, the package no longer belongs to the driver, since it has already entered the final stage.
Parameters:
1 - IRP address

0x00000049: PAGE_FAULT_WITH_INTERRUPTS_OFF

Page fault when accessing memory with IRQ interrupts disabled. The error description is the same as 0x0000000A.

0x0000004C: FATAL_UNHANDLED_HARD_ERROR

Critical unrecognized error. The most likely causes are described in 0xC0000218, 0xC000022A or
0xC0000221.

0x0000004D: NO_PAGES_AVAILABLE

There is no more free page memory to complete the operation. Check the available disk space. Replace the driver. Parameters:

  1. Number of pages used
  2. Number of physical pages on the machine
  3. Extended page size
  4. Overall page size

0x0000004E: PFN_LIST_CORRUPT

The reason is a damaged/faulty driver I/O structure. Parameters:

  1. Value 1
  2. ListHead value that is corrupted
  3. Number of available pages
  1. Value 2
  2. Data that is deleted
  3. Maximum number of physical pages
  4. Summary of deleted data

0x00000050: PAGE_FAULT_IN_NONPAGED_AREA

Occurs when the requested information was not found in memory. The system checks the page file, but the missing information was indicated as not being able to be written to the page file.
Parameters:
1. indicates the address in memory that made an error

0x00000051: REGISTRY_ERROR

An I/O error occurred with the registry when the system tried to read one of its files, which suggests that the error could be caused by a hardware problem or damage to the system itself. This could also mean that the error is caused by an update operation that is only used by the security system and this error occurs when resources are running low. If such an error occurs, check whether the machine is PDC or BDC and how many accounts are in the SAM (Security Account Manager) database, and whether the corresponding libraries are almost full.
Parameters:
1. value 1 (indicates where the error occurred)
2. value 2 (indicates where the error occurred)
3. may point to a library
4. may be HvCheckHive's return code, if any
library is damaged

0x00000058: FTDISK_INTERNAL_ERROR

The system booted from the restored primary partition of the array, as a result of which the libraries report that the mirror is ok, but in fact it is not. The actual images of the libraries are in shadow copy. You need to boot from them.

0x00000067: CONFIG_INITIALIZATION_FAILED

The error means that the registry cannot allocate the space required for the registry files to function. This error can never appear because the process of reserving such space occurs early in the system boot and sufficient space is allocated for the registry.
Parameters:
1. five
2. Points to NTOS\CONFIG\CMSYSINI, which failed.

0x00000069: IO1_INITIALIZATION_FAILED

The I/O device failed to initialize for an unknown reason. This happens if the system installer incorrectly identified the equipment during the system installation process, or the user incorrectly reconfigured the system.

0x0000006B: PROCESS1_INITIALIZATION_FAILED

Parameters:
1. reports to the process code that decided that system initialization was not successful.
2. reports to the location in NTOS\PS\PSINIT.C where the error was detected.
0x0000006D: SESSION1_INITIALIZATION_FAILED 0x0000006E: SESSION2_INITIALIZATION_FAILED 0x0000006F: SESSION3_INITIALIZATION_FAILED 0x00000070: SESSION4_INITIALIZATION_FAILED 0x00000071: 5_INITIALIZATION_FAILED
These codes (SESSION1 - SESSION5) indicate the location in NTOS\INIT\INIT.C where the error was made.
Parameters:
1. reports the session code that decided that system initialization was not successful.

0x00000073: CONFIG_LIST_FAILED

Indicates that one of the registry files is corrupted or unreadable. One of the following files registry: SOFTWARE, SECURITY, SAM (Account Security Manager). A possible reason is lack of disk space or lack of RAM.

0x00000074: BAD_SYSTEM_CONFIG_INFO

This error may occur because the SYSTEM registry file loaded through the NTLDR component is corrupted.
This error may also mean that some required parameters and their parameters are missing. Loading into LastKnownGood may solve this problem. But it is possible that you will have to reinstall the system, or use a rescue disk.

0x00000075: CANNOT_WRITE_CONFIGURATION

This error can occur when additional data cannot be written to the system registry files (SYSTEM and SYSTEM.ALT) during the first phase of registry initialization (when file systems are accessed). This error means that there is no free space on the disk, and an attempt was made to save the registry to a read-only device.

0x00000076: PROCESS_HAS_LOCKED_PAGES

This error may occur due to a driver that is not completely unloaded after an I/O operation. Parameters:
1. process address
2. number of closed pages
3. number of reserved pages
4. zero

0x00000077: KERNEL_STACK_INPAGE_ERROR

Error reading one of the system kernel pages. The problem is a bad block of the virtual memory file or a disk controller error (very rarely, the cause may be a lack of system resources, or more precisely, the non-virtual memory reserve may run out with status c0000009a).
If the first and second parameters of the error code are 0, then this means that the location of the error in the kernel was not found. This means that the error is caused by bad hardware.
I/O status c000009c (STATUS_DEVICE_DATA_ERROR) or C000016AL (STATUS_DISK_OPERATION_FAILED) usually means that the information cannot be read due to a bad block in memory. After reboot, automatic disk check will try to determine the address of the bad block in memory. If the status is C0000185 (STATUS_IO_DEVICE_ERROR) and virtual memory located on a SCSI disk, then check the connection and operation of the SCSI device.
Parameters:
1. zero
2. zero
3. PTE value at the time of the error
4. kernel error address or

1. status code
2. I/O status code
3. virtual memory page number
4. Offset in the paging file

0x00000079: MISMATCHED_HAL

The HAL check level and HAL configuration type are not appropriate for the system kernel or machine type. This error is most likely caused by the user manually updating either NTOSKRNL.EXE or HAL.DLL. Either the machine has a multiprocessor HAL (MP) and a uniprocessor kernel (UP), or vice versa.

0x0000007A: KERNEL_DATA_INPAGE_ERROR

The page requested by the kernel is not read. The error is caused by a bad block in memory or a disk controller error. See also 0x00000077. Parameters:
1. stuck lock type
2. error status (usually I/O code)
3. current process (virtual address for blocking type 3 or PTE)
4. virtual memory address that cannot be moved to the page file

0x0000007B: INACCESSIBLE_BOOT_DEVICE

During the installation of an I/O system, the boot device driver may have failed to initialize the device from which the system was attempting to boot, or the file system that was supposed to read the device either failed to initialize or simply did not recognize information on the device, such as file system structure. In the above case, the first argument is the address of a unicode information structure, which is the ARC name of the device from which the attempt was made to boot. In the second case, the first argument is the address of the device object that cannot be mounted.
If this error occurred during the initial installation of the system, the system may have been installed on a disk or SCSI controller that is not supported by it. Please note that some controllers are only supported by Windows Driver Driver Libraries (WDL), which must be installed in Custom Install mode.
This error can also occur after installing a new SCSI adapter or controller or after changing system partitions. In this case, on x86 systems, you need to edit BOOT.INI.
Parameters:
1. pointer to a device object or Unicode string, or ARC name.

0x0000007D: INSTALL_MORE_MEMORY

There is not enough RAM to run the Windows kernel (5 MB required)
Parameters:
1. number of found physical pages
2. bottom physical page
3. top physical page
4. zero

0x0000007E: SYSTEM_THREAD_EXCEPTION_NOT_HANDLED

There is a hardware problem, driver problem, or low disk space detected. The error may also appear when trying Windows updates XP to Service Pack 2 or Service Pack 3, or Windows Vista when trying to upgrade to Service Pack 1. The cause of the error may be related to hardware drivers. It is necessary to roll back the changes to the state at the time of installing the Service Pack, or remove the installed update. To solve this problem, you need to update the hardware drivers from the manufacturer's website.

0x0000007F: UNEXPECTED_KERNEL_MODE_TRAP

An unexpected kernel-mode exception, or interrupt, occurred in which the kernel does not fire. Also, the cause of the error can be an interruption, which entails immediate death in the form of a double fault. The first number in the error code is the interrupt number (8 = double fault). To find out more about what this interrupt is, refer to the Intel x86 family manual.
In other words, the error appears when the processor makes an error that the kernel cannot handle. Most often, the error occurs due to bad RAM blocks, and sometimes due to overclocking the processor.
Try disabling the synchronous data transfer function in the BIOS.

0x00000080: NMI_HARDWARE_FAILURE

Error initializing the kernel on this hardware. HAL should provide any specific information it has and encourage the user to contact the hardware vendor for technical support.

0x00000085: SETUP_FAILURE

An error occurs when loading the system installer in early Windows versions N.T. The setup text form no longer uses a bugcheck procedure to avoid causing serious interference during installation. Therefore, you will never encounter this error. All error checking has been replaced with friendlier and (where possible) more informative error messages.

0x0000008B: MBR_CHECKSUM_MISMATCH

The error occurs during the boot process when the MBR checksum calculated by the system does not match the bootloader checksum. This usually means a virus. Scan the boot sector antivirus program, having previously booted from the CD.
KerBugCheckEx parameters:
1 — Disk signature in MBR
2 - MBR checksum written to osloader
3 - MBR checksum recorded in the system

0x0000008E: PAGE_FAULT_IN_NON_PAGED_AREA

Incompatible or faulty RAM memory blocks. Diagnose the memory and replace faulty RAM modules.

0x0000008F: PP0_INITIALIZATION_FAILED

The error occurs during phase 0 initialization of the Plug and Play manager in kernel mode. Check your hardware and system disk.

0x00000090: PP1_INITIALIZATION_FAILED

The error occurs during initialization of the primary phase of the Plug and Play manager in kernel mode. At this point, system files, drivers and the registry have been initialized. Check your hardware and system disk.

0x00000092: UP_DRIVER_ON_MP_SYSTEM

The error occurs when a single-processor driver is loaded on a system where there is more than one active processor. KeBugCheckEx parameters: 1 — Base address of the uniprocessor driver

0x00000093: INVALID_KERNEL_HANDLE

The error occurs when kernel code or other critical OS components attempt to close a handle that is not valid.
Parameters:
1 - NtClose handle called
2 - 0 means the protected handle was closed
1 means the wrong handle was closed
0x00000094: KERNEL_STACK_LOCKED_AT_EXIT
This message appears when a thread exists while its stack is marked as blocked. The problem is caused by a hardware driver.

0x00000096: INVALID_WORK_QUEUE_ITEM

0x00000097: BOUND_IMAGE_UNSUPPORTED

The problem is caused by an incorrect hardware driver.

0x00000098: END_OF_NT_EVALUATION_PERIOD

The Windows demo has expired. Parameters:
1 — Installation date (lower 32-bits)
2 - Installation date (upper 32-bits)
3 — Trial period in minutes.

0x00000099: INVALID_REGION_OR_SEGMENT

ExInitializeRegion or ExInterlockedExtendRegion was called with an incorrect set of parameters.

0x0000009A: SYSTEM_LICENSE_VIOLATION

A violation of the software license agreement has occurred. This could be either due to an attempt to change the system product type, or an attempt to change the OS trial period.

0x0000009B: UDFS_FILE_SYSTEM

There was a failure to read or write to UDFS-formatted media. The failure may be due to damage to the file system, or to the appearance of bad sectors on the disk. The failure may also be associated with software that changes the disk structure (encryption programs, etc.).

0x0000009C: MACHINE_CHECK_EXCEPTION

Fatal error Machine Check Exception. The error is associated with incorrect hardware configuration, processor overclocking, unstable operation of RAM units, overheating of system components, and unstable operation of the power supply.

0x0000009F: DRIVER_POWER_STATE_FAILURE

The driver is in an inconsistent or unacceptable power consumption state. This usually happens due to power failures, rebooting, resuming from sleep mode, etc. It is necessary to replace the faulty driver, or remove software that controls the file system (antiviruses, encryption programs

0x000000A5: ACPI_BIOS_ERROR

Reason of this message are constant failures in ACPI BIOS. This problem cannot be solved at the operating system level. A detailed analysis is required.

0x000000B4: VIDEO_DRIVER_INIT_FAILURE

Windows was unable to load the video card driver. The problem is mainly related to the video drivers, or there is a hardware conflict with the video card. Reboot into safe mode and change the video driver to standard.

0x000000BE: ATTEMPTED_WRITE_TO_READONLY_MEMORY

The driver attempted to write data to a read-only memory (ROM) device that cannot be written to. The problem is mainly due to the installation of a bad device driver, service or firmware. Change the driver.
_MEMORY_CORRUPTION
The driver wrote data to an invalid memory section. Change the driver.

0x000000C2: BAD_POOL_CALLER

The system kernel or driver issued an incorrect memory access command. Typically, a bad driver or software caused this error. Change the driver.

0x000000C4: DRIVER_VERIFIER_DETECTED_VIOLATION

The driver checker detected a fatal error in the STOP error generation module. Accompanying parameters are parameters that are passed to KeBugCheckEx and displayed on the blue screen. Change the driver.

0x000000C5: DRIVER_CORRUPTED_EXPOOL

An attempt was made to access a high-level IRQL process from an invalid memory location. This error almost always occurs due to drivers that have corrupted the system pool. Change the driver.

0x000000C6: DRIVER_CAUGHT_MODIFYING_FREED_POOL

The driver attempted to access a freed memory pool. Change the driver.

0x000000C7: TIMER_OR_DPC_INVALID

A kernel timer or Delayed Procedure Call (DPC) is present in a prohibited memory location. This error occurs when the driver was unable to complete a kernel timer or Delayed Procedure Call (DPC) before discharging it from memory. Change the driver.

0x000000C9: DRIVER_VERIFIER_IOMANAGER_VIOLATION

This is a message from one of the driver verification managers. Change the driver.

0x000000CB: DRIVER_LEFT_LOCKED_PAGES_IN_PROCESS

An error similar to STOP error 0x00000076. It differs from the latter only in that in this case the error was detected during kernel tracing. The error indicates that the driver or I/O manager is unable to open locked pages after an I/O operation. Pay attention to the name of the application driver in the STOP error window. Change the driver.

0x000000CE: DRIVER_UNLOADED_WITHOUT_CANCELLING_PENDING_OPERATIONS

The driver cannot cancel the frozen state of system components. The error usually occurs after installing bad drivers or service components. Change the driver.

0x000000D1: DRIVER_IRQL_NOT_LESS_OR_EQUAL

The system attempted to access paged memory using a kernel process via a high-level IRQL. The most common reason is a bad device driver. This could also be caused by damaged RAM, or a damaged page file.

0x000000D8: DRIVER_USED_EXCESSIVE_PTES

The error occurs when the driver requests a large amount of kernel memory.

0x000000E3: RESOURCE_NOT_OWNED

Various file system related failures result in this STOP error. The problem may be related to the NTFS.SYS driver.

0x000000EA: THREAD_STUCK_IN_DEVICE_DRIVER

A problematic device driver has caused the system to freeze. Typically, this is caused by the display driver when the computer tries to enter standby mode. This problem is related to the video adapter, or a bad video driver.
There was a problem connecting boot disk. The error can occur on computers with high-performance disk controllers that were not configured and installed correctly, or were connected with a poor-quality cable. After a normal reboot, the system can resume normal operation as if nothing had happened. This error also appears after incorrect completion Windows operation and the failure may be due to file system corruption.

0x000000F2: HARDWARE_INTERRUPT_STORM

This message appears if the kernel detects an interrupt storm, that is, when the device caused by the interrupt level is unable to issue an interrupt request. Usually, this is caused by a bad device driver.

0x000000F3: DISORDERLY_SHUTDOWN

Windows shutdown crashed due to insufficient memory. Determine which program is running out of memory, try to discover why virtual memory is not providing the system resources it needs, and investigate whether the program (or sometimes a driver) refuses to exit without freeing open pages in memory.

0x000000FA: HTTP_DRIVER_CORRUPTED

The Http.sys system driver is corrupted. This component must be restored from the original disk.

0x000000FC: ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY

An attempt was made to execute a function in non-executable memory. Parameters:
1 — Address from which the attempt was made to execute the function
2 - Contents of page table entry (PTE)
0x000000FD: DIRTY_NOWRITE_PAGES_CONGESTION
There is no free page memory to continue basic system operations.
Parameters:
1 - Total amount of paged memory requested
2 - The amount of paged memory requested that cannot be written to.
3 —
4 — Status code at the time of the last write to page memory

0x000000FE: BUGCODE_USB_DRIVER

A critical error has occurred in USB operation controller and associated devices. The problem is usually caused by incorrect operation of the USB controller, or a malfunction of the connected USB devices. Disconnect all USB devices from the computer, also try disabling the USB controller in the BIOS. Update USB drivers.

0x00000101:CLOCK_WATCHDOG_TIMEOUT

Indicates that an expected clock interrupt on a secondary processor in a multiprocessor system was not received within a specified interval. This processor does not handle interrupts. Typically, this happens when the processor is not responding or has entered an infinite loop.
Parameters:
1 — Interval for blocking the clock interrupt time, in
nominal system clock cycles
2 - zero
3 - Address of the processor control block (PRCB) for non-responsive
processor
4 - zero

0x00000104: AGP_INVALID_ACCESS

The GPU attempted to write to memory that was not reserved for it. The error is related to the video driver, or old version BIOS.
Parameters:
1 — Offset (in ULONG) within AGP pages to the first data
ULONG whose data is destroyed
2 - zero
3 - zero
4 - zero

0x00000105: AGP_GART_CORRUPTION

The error appears when the Graphics Aperture Remapping Table (GART) is damaged. The error is caused by the DMA (Direct Memory Access) driver not working properly.
Parameters:
1 - Base address (virtual) in GART
2 - Offset in GART where distortion is detected
3 - Base address (virtual) from GART cache (GART copy)
4 - zero

0x00000106: AGP_ILLEGALLY_REPROGRAMMED

The error is caused by an unsigned or damaged video driver. Replace the video driver. Parameters:
1 - Original team
2 - Current team
3 - zero
4 - zero

0x00000108: THIRD_PARTY_FILE_SYSTEM_FAILURE

A critical error occurred in a third-party file system filter. The error may be caused by antivirus software, defragmentation programs, data backup programs, and other third-party utilities. Try also increasing the size of the page file and RAM.

0x00000109: CRITICAL_STRUCTURE_CORRUPTION

The system kernel has detected incorrect code or data integrity violation. 64-code based systems are protected from this bug. The problem could be caused by a RAM failure or third party drivers.

0x0000010E: VIDEO_MEMORY_MANAGEMENT_INTERNAL

An internal video driver error has been detected. Video driver problem.

0x0000010F: RESOURCE_MANAGER_EXCEPTION_NOT_HANDLED

An exception occurred in the kernel-mode resource manager.

0x00000112: MSRPC_STATE_VIOLATION

The msrpc.sys system component returned an error code during execution. The error code is specified in the first parameter.

0x00000113: VIDEO_DXGKRNL_FATAL_ERROR

The DirectX Graphics kernel has encountered a critical error.

0x00000114: VIDEO_SHADOW_DRIVER_FATAL_ERROR

The shadow video driver has encountered a critical error.

0x00000115: AGP_INTERNAL

A critical error was detected in the AGP video interface by the video port driver.

0x00000116: VIDEO_TDR_ERROR

The video driver timeout reset was not successful.

0x0000011C: ATTEMPTED_WRITE_TO_CM_PROTECTED_STORAGE

An attempt was made to write to the write-protected area of ​​the configuration manager: Parameters:
1 — Virtual address of the attempted write command
2 - Contents of PTE
3 - reserved
4 - reserved The name of the driver attempting the write operation is printed as
Unicode string on error screen.

0x00000121: DRIVER_VIOLATION

The driver has violated access to one of the memory areas. Parameters:
1 - describes the type of violation
2 - reserved
3 - reserved Use a kernel debugger and look at the call stack to determine
the name of the driver that caused the access violation.

0x00000122: WHEA_INTERNAL_ERROR

An internal error occurred in the hardware error detection architecture Windows tools(Windows Hardware Error Architecture (WHEA))

0x00000124: WHEA_UNCORRECTABLE_ERROR

An error has occurred in the computer hardware. This error is detected by the Windows Hardware Error Architecture (WHEA)

0x00000127: PAGE_NOT_ZERO

The memory page was not completely filled with zeros. This error occurs due to a hardware failure, or due to the triggering of a privileged component of the operating system that made a premature page change in memory.
Parameters:

page.

3 - zero
4 - zero

0x0000012B: FAULTY_HARDWARE_CORRUPTED_PAGE

A single bit error was detected on the memory page. This error is related to hardware RAM. Parameters:
1 - Virtual address in memory, which indicates an incorrect
page.
2 - Physical page number
3 - zero
4 - zero

0x0000012C: EXFAT_FILE_SYSTEM

There was a failure to read or write to a media partition in exFat format. The failure may be due to damage to the file system, or to the appearance of bad sectors on the disk. The failure may also be associated with software that changes the disk structure (encryption programs, etc.). This failure applies to media formatted for Windows Vista Service Pack 1.

0x1000007E: SYSTEM_THREAD_EXCEPTION_NOT_HANDLED_M
0x1000008E: KERNEL_MODE_EXCEPTION_NOT_HANDLED_M
0xC000009A: STATUS_INSUFFICIENT_RESOURCES

The system kernel of the operating system has exhausted all system resources for its work, including the paging file. Check the disk for errors. Increase the size of your hard drive and the amount of RAM.

0xC0000135: UNABLE TO LOCATE DLL

Windows tried to boot DLL library and received an error code. Possible cause: the file is missing or damaged. The system registry may also be damaged.

0xC0000142: DLL Initialization Failure

This error was caused by corruption of the system DLL library.

0xC0000218: UNKNOWN_HARD_ERROR

A required registry file cannot be loaded. The file may be damaged or missing (rescue disk or reinstalling Windows). The system registry files may have been destroyed due to hard drive corruption. The driver may have corrupted registry data when loading into memory, or the memory where the registry was loaded has a parity error (turn off external cache and check RAM).

0xC000021A: STATUS_SYSTEM_PROCESS_TERMINATED

This occurs when Windows has switched to privileged mode and non-privileged mode subsystems, such as Winlogon or the Client Server Runtime Subsystem (CSRSS), have caused some kind of failure and protection cannot be guaranteed. Because Windows XP cannot run without Winlogon or CSRSS, this is one of the few situations where a non-privileged mode service failure can cause the system to stop responding. This can also happen when the computer is restarted after the system administrator has changed permissions so that SYSTEM account no longer had adequate permissions to access system files and folders. The error can also be caused by corruption of the user32.dll file or incorrect system drivers (.sys)

0xC0000221: STATUS_IMAGE_CHECKSUM_MISMATCH

the driver is damaged or the system library was recognized as damaged. The system does everything to check the integrity of important system files. The blue screen shows the name of the damaged file. If this happens, boot into any other system or, if there are none, reinstall the system. Make sure that the version of the file that was detected as damaged matches the version of the file in the system distribution and if so, replace it from the disk. Constant errors with different file names indicate that there are problems with the storage media or with the disk controller where these files are located.

0xC0000244

A STOP error occurs when the audit policy enables the CrashOnAuditFail setting

0xC000026C

Typically indicates device driver problems. More information about this error

0xDEADDEAD: MANUALLY_INITIATED_CRASH1

"It's dead, Jim!" (It's dead, Jim!) This STOP error indicates that the user intentionally triggered a crash, either from the kernel debugger or from the keyboard.

Here is a small list of errors that may appear in operating systems Windows NT 4.0, Windows 2000, Windows 2003, Windows XP, Windows Vista and Windows 7. Everyone is afraid of the blue screen of death, but in fact, if it didn’t exist, the computer would simply break down, and you would have to send your equipment for repairs, or buy a new one, or maybe even the whole computer. Therefore, let's pay tribute to the developers of this operating system, who take care of our wallets. This is where we end our conversation about the famous “ Blue screen of death».

Blue screen of death(eng. Blue Screen of Death, Blue Screen of Doom, BSoD) - messages about a critical system error in operating systems Microsoft Windows. Many who encounter a blue screen of death on their computer/laptop see the only solution as reinstalling the operating system. But sometimes the OS has nothing to do with it, but the problem is in the hardware. In order not to guess - why did the blue screen of death appear, you need to use the information provided by the operating system itself in the form of logs. In this article, I will describe step by step how to find out the cause of the blue screen of death.

So, the appearance of the blue screen of death is always unexpected and at the wrong time, so many simply do not have time to see what is written, and it must be said there (though not in a very explicit form) the reasons for the failure. First of all, I suggest setting up your computer/laptop so that it does not reboot immediately after a system failure, but gives you the opportunity to see the cause of the failure, if this information is not enough, you need to look dump a file that contains information: an error code with parameters, a list of drivers loaded into RAM at the time of the system crash, etc., but this information is enough to identify the faulty driver.

Settings regarding rebooting after a system failure can be specified by clicking right click mouse on the My Computer/Computer shortcut (suitable for Windows XP, Windows7, Windows8), select " Properties", or press the key combination + . All printskirns below will concern Windows7, the same method is configured on Windows XP, Windows8, Windows8.1.

On the "tab" Additionally"select in the Boot and Recovery field" Options".

Uncheck " Perform automatic reboot", in order to have time to see everything that the blue screen of death writes. The line Dump file indicates the path where the file will be saved, which will indicate the reasons for the failure.

Now you can carefully study the information when a blue screen of death appears. If your computer no longer boots and you cannot change these settings, in this case, when booting, press F8 on the keyboard and select the menu item “If the system fails, do not reboot.”

If the information indicated there is not enough, you can use a dump ( dmp file). To do this you can use the tool microsoft-microsoft debugging tool, but it weighs a lot and requires installation and framework 4.5. You can get by with fewer sacrifices if you use the program BlueScreenView . In my opinion, a very convenient program that does not require installation and in Russian (add the file to the program folder). By running the BlueScreenView.exe file, the program interface will open in which the dump of this computer will already be loaded (the default path is C:\Windows\MiniDump, if you go to Settings - Advanced parameters, you can specify a different path if you copied the dump to another location).

Blue Screen of Death (BSOD) is one of the most vexing problems that Windows user may collide. Knowing how to determine the cause of a crash is one of the most important forms of diagnosing BSOD. An error with a blue screen code can occur for various reasons, and without analyzing what is causing the error, it is difficult to eliminate it. These are the main reasons for Blue Screen of Death BSOD:

  • Driver conflicts- Driver conflicts occur when two or more drivers cannot work with each other properly. This can also happen if multiple drivers are installed for the same device without uninstalling the previous version.
  • Hardware conflicts- Incorrect overclocking of a PC can immediately create a BSOD. Blue Screen of Death can also occur if your RAM sticks are not installed correctly or if a piece of hardware is starting to wear out.
  • Operating system (OS) errors- User error or malware can delete vital files of your OS. Significant missing files can result in a crippling error causing your PC to enter a BSOD cycle in which you get a blue screen every time your PC turns on.

Preparing to analyze a BSOD file dump

Whenever a BSOD error occurs, Windows dumps some information about it into a file on your PC, but trying to understand this dump file very complex. One of the easier ways to understand is to use the utility BlueScreenView by NirSoft, a free tool that finds these dump files and displays them in a more user-friendly form. First of all, you should check the settings for the memory dump report in the Windows system itself:

  • Click Win+R and enter sysdm.cpl
  • Go to the tab Additionally and select from below

  • Make sure you have the error logging settings enabled.

Now download the program BlueScreenView scroll to the center of the site to download the file. You will see three links as in the picture below, select the installer that is most convenient for you. If you want to Russify the program, then find Russian in the table below and download the file. The downloaded file will contain a "BlueScreenView_lng" file, just place it in the installation program at the root.


Find out Blue Screen of Death error codes

When you run the program, it will show you errors in files and memory dumps. As you can see in the figure below, I get a blue screen with an ndis.sys error and there seems to be a problem in the ntoskrni.exe file. In the top column, I can see the full file dump report, and by right-clicking on it, I can search Google for information on the fix. The error is most likely related to the installed virtual machine, or more precisely to the virtual network adapter and antivirus, which creates a blue screen error after sleep mode and the initial boot of the system.


How to Fix Blue Screen of Death Error Codes

I will give a couple of ways of what to do and how to eliminate errors using popular methods:

  • When, for example, a blue screen of death occurs in Windows 10, there will be QR code which will redirect you to the site.
  • On the website Microsoft there is already a database with BSOD errors and prompting tools.
  • Use the Microsoft Virtual Agent, enter BSOD in the first line and follow the instructions.
  • Microsoft also suggests running

Finding errors in programs is not an easy task. There are no ready-made techniques or recipes for success here. You could even say that this is art. However, there are general tips that will help you in your search. The article describes the basic steps to take if your program is not working correctly.

Step 1: Log the bug into the tracker

After completing all the steps described below, it may happen that you will be tearing your hair out in despair, still sitting at work, when you realize that:

  1. You forgot some important detail about the error, for example, what it was.
  2. You could delegate it to someone more experienced.

The tracker will help you not to lose the thread of thinking about both the current problem and the one that you have temporarily postponed. And if you work in a team, it can help to delegate corrections to a colleague and keep all the discussion in one place.

You must record the following information in the tracker:

  1. What the user did.
  2. What did he expect to see?
  3. What really happened.

This should give you a hint on how to reproduce the error. If you can't reproduce it at any time, your chances of fixing the error are slim to none.

Step 2: Look for the error message online

If you have an error message, then you are in luck. Either it will be informative enough for you to understand where and what the error is, or you will have a ready-made query to search the Internet. Unlucky? Then move on to the next step.

Step 3: Find the line where the error occurs

If an error causes the program to crash, try running it in the IDE under the debugger and see at what line of code it stops. It is not absolutely necessary that the error will be on this line (see next step), but at least it can give you information about the nature of the bug.

Step 4: Find the exact line where the error appeared

Once you find the line where the error occurs, you can step back through the code to find where it is. Sometimes it can be the same string. But more often than not, you will find that the line on which the program crashed has nothing to do with it, and the cause of the error is due to incorrect data that appeared earlier.

If you're monitoring a program's execution in a debugger, you can go back through the stack trace to find the error. If you are inside a function called inside another function called inside another function, then the stack trace will show a list of functions up to the very entry point into the program (the main() function). If the error occurs somewhere in the included library, assume that the error is still in your program - this happens much more often. Use the stacktrace to find where the library function is called from in your code, and continue searching.

Step 5: Find out the nature of the error

Errors can manifest themselves in different ways, but most of them can be classified into one category or another. Here are the most common ones.

  1. Error per unit
    You started the for loop with one instead of zero or vice versa. Or, for example, they thought that the .count() or .length() method returned the index of the last element. Check the language documentation to make sure that array numbering starts at zero or one. This error sometimes appears as an Index out of range exception.
  2. Race condition
    Your process or thread is trying to use the result of a child's execution before it has completed its work. Look for use of sleep() in the code. Perhaps on a powerful machine the child thread executes in a millisecond, but on a less powerful system there are delays. Use proper ways to synchronize multi-threaded code: mutexes, semaphores, events, etc.
  3. Incorrect settings or constants
    Check your configuration files and constants. I once spent an awful 16 hours trying to figure out why the shopping cart on a shopping website was hanging when the order was being submitted. The cause turned out to be an incorrect value in /etc/hosts that prevented the application from finding the mail server's IP address, causing an infinite loop while trying to send an invoice to the customer.
  4. Unexpected null
    I bet you've gotten an uninitialized variable error more than once. Make sure you check for null references, especially when accessing chained properties. Also check for cases where the NULL value returned from the database is a special type.
  5. Invalid input data
    Are you checking your input? Are you sure you're not trying to perform arithmetic operations on user-supplied strings?
  6. Assignment instead of comparison
    Make sure you don't write = instead of == , especially in C-like languages.
  7. Rounding error
    This happens when you use an integer instead of a Decimal, or a float for monetary amounts, or an integer that is too short (for example, trying to write a number larger than 2147483647 into a 32-bit integer). In addition, it may happen that the rounding error does not appear immediately, but accumulates over time (the so-called Butterfly Effect).
  8. Buffer overflow and array out of bounds
    The number one problem is computer security. You allocate memory that is smaller than the data you write to it. Or you are trying to access an element outside the array.
  9. Programmers can't count
    You are using an incorrect formula. Make sure you are not using integer division instead of taking a remainder, or know how to convert a rational fraction to a decimal, etc.
  10. Concatenation of string and number
    You're expecting two strings to concatenate, but one of the values ​​is a number, and the compiler is trying to do arithmetic. Try to explicitly cast each value to a string.
  11. 33 characters in varchar(32)
    Check the data passed to INSERT for type matching. Some databases throw exceptions (as they should), some simply truncate the row (like MySQL). I recently encountered this error: the programmer forgot to remove quotes from a string before inserting it into the database, and the length of the string exceeded the allowable length by just two characters. It took a long time to find the bug because it was difficult to notice the two small quotes.
  12. Incorrect state
    You are trying to run a query while the connection is closed, or you are trying to insert a record into a table before you have updated the tables on which it depends.
  13. Features of your system that the user does not have
    For example: in the test database there is a 1:1 relationship between the order ID and the address, and you programmed based on this assumption. But in the work it turns out that orders can be sent to the same address, and thus you have a 1:many relationship.

If your error is not similar to the ones described above, or you cannot find the line where it appeared, proceed to the next step.

Step 6: Elimination Method

If you can't find the line with the error, try either disabling (commenting out) blocks of code until the error goes away, or, using a unit test framework, isolate individual methods and call them with the same parameters as in real code.

Try disabling system components one by one until you find a minimum configuration that will work. Then plug them back in one at a time until the error returns. This will take you back to step 3.

Step 7: Log everything and analyze the log

Go through each module or component and add more messages. Start gradually, one module at a time. Analyze the log until a problem appears. If this does not happen, add more messages.

Your job is to return to step 3 after finding where the error occurs. This is also exactly the case when it is worth using third-party libraries for more thorough logging.

Step 8: Eliminate hardware or platform influences

Replace RAM, hard drives, change server or workstation. Install updates, uninstall updates. If the error disappears, then the cause was the hardware, OS or environment. You can try this step sooner if you wish, since hardware problems often mask software errors.

If your program runs over a network, check the switch, replace the cable, or run the program on a different network.

Just for fun, switch the power cord to a different outlet or to a different UPS. Crazy? Why not try it?

If you get the same error regardless of the environment, then it's in your code.

Step 9: Notice the Matches

  1. Does the error always appear at the same time? Check scheduled tasks.
  2. Does a mistake always appear along with something else, no matter how absurd the connection? Pay attention to every detail. For each. For example, does the error occur when the air conditioner is turned on? Perhaps because of this, the voltage in the network drops, which causes strange effects in the hardware.
  3. Do users of the program have anything in common that is not even related to the software? For example, geographical location (this is how the legendary bug with a letter 500 miles away was found).
  4. Does the error occur when another process is taking up a large enough amount of memory or CPU resources? (I once found this to be the cause of an annoying "no trusted connection" problem with SQL Server).

Step 10: Contact technical support

Finally, it's time to ask for help from someone who knows more than you. To do this, you must have at least a rough understanding of where the error is located - in the hardware, database, compiler. Before writing a letter to the developers, try asking a question on the relevant forum.

There are bugs in operating systems, compilers, frameworks and libraries, and your program may actually be correct. But the chances of drawing a developer's attention to these errors are slim unless you can provide a detailed algorithm for reproducing them. A friendly developer can help you with this, but more often than not, if the problem is difficult to reproduce, you will simply be ignored. Unfortunately, this means that you need to put more effort into writing a bug report.

  1. Call someone else.
    Ask a colleague to look for the error with you. Perhaps he will notice something that you missed. This can be done at any stage.
  2. Review the code carefully.
    I often find a bug just by calmly going through the code from the beginning and going over it in my head.
  3. Consider cases where the code works and compare them to those that don't.
    I recently discovered a bug where when the XML input contained the string xsi:type="xs:string" , everything would break, but if that string was not present, everything would work correctly. It turned out that the additional attribute was breaking the deserialization mechanism.
  4. Go to bed.
    Don't be afraid to go home before you fix the mistake. Your ability is inversely proportional to your fatigue. You'll just waste time and exhaust yourself.
  5. Take a creative break.
    A creative break is when you take your mind off a task and turn your attention to other things. You may have noticed that your best ideas come to you in the shower or on the way home. Changing the context sometimes helps. Go out to lunch, watch a movie, surf the Internet, or do something else.
  6. Turn a blind eye to some symptoms and messages and try first.
    Some bugs can affect each other. The dial-up driver in Windows 95 could report that the channel was busy, although you could clearly hear the sound of the modem connecting. If you have too many symptoms to keep in mind, try focusing on just one. Fix or find its cause and move on to the next one.
  7. Play Dr. House (without Vicodin).
    Gather all your colleagues, walk around the office with a cane, write symptoms on the board and make sarcastic comments. Since it works in TV series, why not try it?

What definitely won't help you

  1. Panic
    There is no need to immediately fire a cannon at the sparrows. Some managers start to panic and immediately roll back, reboot servers, etc. in the hope that one of these will fix the problem. It never works. It also creates more chaos and increases the time it takes to find the bug. Take only one step at a time. Study the result. Think about it, and then move on to the next hypothesis.
  2. “Help, please!”
    When you go to a forum for advice, you should at a minimum have already completed step 3. No one will be willing or able to help you unless you provide a detailed description of the problem, including information about the OS, hardware, and the problematic code section. Create a topic only when you can describe everything in detail, and come up with an informative title for it.
  3. Getting personal
    If you think someone else is to blame for the mistake, at least try to speak to them politely. Insults, shouting and panic will not help a person solve the problem. Even if democracy is not held in high esteem on your team, shouting and using brute force will not make corrections magically appear.

A bug I recently fixed

It was a mysterious issue with duplicate file names being generated. Further inspection showed that the files had different content. This was strange because the file names included the creation date and time in the format yyMMddhhmmss. Step 9, matches: the first file was created at half past five in the morning, the duplicate was generated at half past four in the evening of the same day. Coincidence? No, because hh in