You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 54.163.0.0/16 has been blocked (disabled) by ‪Blablubbs‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider or colocation provider. To prevent abuse, web hosts and colocation providers may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host or colocation provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a colocation provider's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a colocation web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host or colocation provider (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host or colocation provider.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and requests should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 17:28, 10 March 2024.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis. The block was made by ‪Jon Kolbert‬. The reason given is Open proxy/Webhost: See the help page if you are affected .
- Start of block: 18:27, 12 November 2023
- Expiry of block: 18:27, 12 November 2028
Your current IP address is 54.163.179.242. The blocked range is 54.163.0.0/16. Please include all above details in any queries you make. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

You can view and copy the source of this page:

((Multiple issues|
((technical|date=June 2015))
((refimprove|date=January 2017))
))
((multiple image
 | align = right
 | direction = vertical
 | width = 220
 | image1 = Unrecoverable Application Error.png
 | alt1 = Error message in a white dialog box stating "UNRECOVERABLE APPLICATION ERROR: Terminating current application."
 | caption1 = Generic error message for a general protection fault (Unrecoverable Application Error) in [[Windows 3.0]]
 | image2 = General Protection Fault example in Windows 3.1.png
 | alt2 = Error message for a general protection fault in Windows 3.1x
 | caption2 = Example error message for a general protection fault in [[Windows 3.1x]]
))
A '''general protection fault''' ('''GPF''') in the [[x86]] [[instruction set architecture]]s (ISAs) is a [[Fault (computing)|fault]] (a type of [[interrupt]]) initiated by ISA-defined protection mechanisms in response to an access violation caused by some running code, either in the [[Kernel (operating system)|kernel]] or a user program. The mechanism is first described in Intel manuals and datasheets for the [[Intel 80286]] CPU, which was introduced in 1983; it is also described in section 9.8.13 in the [[Intel 80386]] programmer's reference manual from 1986. A general protection fault is implemented as an interrupt ([[interrupt vector|vector]] number 13 (0Dh)). Some [[operating system]]s may also classify some exceptions not related to access violations, such as illegal [[opcode]] exceptions, as general protection faults, even though they have nothing to do with memory protection. If a CPU detects a protection violation, it stops executing the code and sends a GPF interrupt. In most cases, the operating system removes the failing [[Process (computing)|process]] from the execution queue, signals the user, and continues executing other processes. If, however, the operating system fails to catch the general protection fault, i.e. another protection violation occurs before the operating system returns from the previous GPF interrupt, the CPU signals a [[double fault]], stopping the operating system. If yet another failure ([[triple fault]]) occurs, the CPU is unable to recover; since 80286, the CPU enters a special halt state called "Shutdown", which can only be exited through a [[hardware reset]]. The [[IBM Personal Computer AT|IBM PC AT]], the first [[PC-compatible]] system to contain an 80286, has hardware that detects the Shutdown state and automatically resets the CPU when it occurs. All descendants of the PC AT do the same, so in a PC, a triple fault causes an immediate system reset.

== Specific behavior ==
=== Microsoft Windows ===

In [[Microsoft Windows]], the general protection fault presents with varied language, depending on product version:
{| class="wikitable plainrowheaders"
|-
! scope=col | Operating system !! scope=col | Error message !! scope=col | Notes
|-
! scope=row | [[Windows 3.0]]
| UNRECOVERABLE APPLICATION ERROR
Terminating current application.
| <ref>((cite web|title=Troubleshooting "Unrecoverable Application Error" in DrWatson|url=https://support.microsoft.com/en-us/kb/75490|website=Support|publisher=[[Microsoft]]|date=27 February 2014))</ref>
|-
! scope=row | [[Windows 3.1x]]
| [Program Name] caused a General Protection Fault in module [module name] at [memory address].
| This error message (with the same design format) can also appear in later versions (95, 98 and Me) in rare occasions. The text of this error also appears in 95, 98 and Me if the 'Details' button is clicked or if Alt+D is pressed.
|-
! scope=row | [[Windows 95]]<br/>[[Windows 98]]<br/>[[Windows NT 4.0]]
| This program has performed an illegal operation and will be shut down.
If the problem persists, contact the program vendor.
|Sometimes, the error also says, "Quit all programs, and then restart your computer", especially when the problem is more severe or when the system is unstable. When a debugger is installed, there is also a Debug button between the Close and Details buttons.
|-
! scope=row | [[Windows 2000]]
| [Program Name] has generated errors and will be closed by Windows. You will need to restart the program.
An error log is being created.
|
|-
! scope=row | [[Windows Me]]
| [Program Name] has caused an error in [Module Name]. [Program Name] will now close.
If you continue to experience problems, try restarting the computer.
|When a debugger is installed, there is also a Debug button below the Close button. Details are still viewable by pressing Alt+D and via the faultlog.txt file.
|-
! scope=row | [[Windows XP]]<br/>[[Windows Server 2003]]<br/>[[Windows Server 2003 R2]]
| [Program Name] has encountered a problem and needs to close. We are sorry for the inconvenience.
If you were in the middle of something, the information you were working on might be lost.

[...]

For more information about this error, <u>click here</u>.
|The error message also offers the option to send error details to Microsoft for analysis.
|-
! scope=row | [[Windows Vista]] and later, excluding Windows 10<br/>[[Windows Server 2008]] and later
| rowspan=2 | [Program Name] has stopped working.
A problem caused the program to stop working correctly. Windows will close the program and notify you if a solution is available.
|By default, Windows will send error details to Microsoft for analysis but the system can be configured to either not send, or ask the user what to do each time.
|-
! scope=row | [[Windows 10]]<br/>[[Windows 11]]
| Windows will send error details to Microsoft for analysis. Users with a business license can configure how much information is sent.
|}

=== Unix ===
In [[Linux]] and other [[Unix|Unices]], the errors are reported separately (e.g. [[segmentation fault]] for memory errors).

==Memory errors==
In memory errors, the faulting program accesses [[computer memory|memory]] that it should not access. Examples include:

* Attempting to write to a [[read-only memory|read-only portion of memory]]
* Attempting to execute [[byte]]s in memory which are not designated as [[Instruction (computer science)|instructions]]
* Attempting to read as data bytes in memory which are designated as instructions
* Other miscellaneous conflicts between the designation of a part of memory and its use

However, many modern operating systems implement their memory access-control schemes via paging instead of segmentation, so it is often the case that invalid memory references in operating systems such as Windows are reported via [[page fault]]s instead of general protection faults. Operating systems typically provide an abstraction layer (such as exception handling or signals) that hides whatever internal processor mechanism was used to raise a memory access error from a program, for the purposes of providing a standard interface for handling many different types of processor-generated error conditions.

In terms of the x86 architecture, general protection faults are specific to segmentation-based protection when it comes to memory accesses.  However, general protection faults are still used to report other protection violations (aside from memory access violations) when paging is used, such as the use of instructions not accessible from the [[current privilege level]] (CPL).

While it is theoretically possible for an operating system to utilize both paging and segmentation, for the most part, common operating systems typically rely on paging for the bulk of their memory access control needs.

==Privilege errors==
There are some things on a computer which are reserved for the exclusive use of the [[operating system]]. If a program which is not part of the operating system attempts to use one of these features, it may cause a general protection fault.

Additionally, there are storage locations which are reserved both for the operating system and the processor itself. As a consequence of their reservation, they are read-only and an attempt to write [[data]] to them by an unprivileged program produces  an error.

==Technical causes for faults==
General protection faults are raised by the processor when a protected instruction is encountered which exceeds the permission level of the currently executing task, either because a user-mode program is attempting a protected instruction, or because the operating system has issued a request which would put the processor into an undefined state.

General protection faults are caught and handled by modern operating systems. Generally, if the fault originated in a user-mode program, the user-mode program is terminated. If, however, the fault originated in a core system driver or the operating system itself, the operating system usually saves diagnostic information either to a file or to the screen and stops operating. It either restarts the computer or displays an [[error screen]], such as a [[Blue Screen of Death]] or [[kernel panic]].

===Segment limits exceeded===
Segment limits can be exceeded:
* with [[code segment]] (CS), [[data segment]] (DS), or ES, FS, or GS (extra segment) registers; or
* accessing descriptor tables such as the [[Global Descriptor Table]] (GDT), the [[Interrupt descriptor table]] (IDT) and the [[Local Descriptor Table]] (LDT).

===Segment permissions violated===
Segment permissions can be violated by:
* jumping to non-executable segments
* writing to code segments, or read only segments
* reading execute-only segments

===Segments illegally loaded===
This can occur when:
* a stack segment (SS) is loaded with a segment selector for a read only, executable, null segment, or segment with descriptor privilege not matching the current privilege in CS
* a code segment (CS) loaded with a segment selector for a data, system, or null segment
* SS, DS, ES, FS, or GS are segments loaded with a segment selector for a system segment
* SS, DS, ES, FS, or GS are segments loaded with a segment selector for an execute-only code segment
* accessing memory using DS, ES, FS, or GS registers, when they contain a null selector

===Switching===
Faults can occur in the [[task state segment]] (TSS) structure when:
* switching to a busy task during a call or jump instruction
* switching to an available task during an interrupt return (IRET) instruction
* using a segment selector on a switch pointing to a TSS descriptor in the LDT((clarify|note=What does this mean?|date=May 2017))

===Miscellaneous===
Other causes of general protection faults are:
* attempting to access an interrupt/exception handler from [[virtual 8086 mode]] when the handler's code segment descriptor [[privilege level]] (DPL) is greater than zero
* attempting to write a one into the reserved bits of [[control register|CR4]]
* attempting to execute [[privilege (computing)|privileged]] instructions when the current privilege level (CPL) is not zero
* attempting to execute a single instruction with a length greater than 15 bytes (possibly by prepending the instruction with superfluous prefixes)<ref>((cite web|url=https://xem.github.io/minix86/manual/intel-x86-and-64-manual-vol3/o_fe12b1e2a880e0ce-223.html|title=Page 223|access-date=2023-09-24))</ref><ref>[https://tornote.io/ Tornote - Privnote]</ref>
* writing to a reserved bit in an [[model-specific register|MSR]] instruction
* accessing a gate containing a null segment selector
* executing a software interrupt when the CPL is greater than the DPL set for the interrupt gate
* the segment selector in a call, interrupt or trap gate does not point to a code segment
* violating privilege rules
* enabling paging whilst disabling protection
* referencing the interrupt descriptor table following an interrupt or exception that is not an interrupt, trap, or a task gate
* Legacy [[Streaming SIMD Extensions|SSE]]: Memory operand is not 16-byte aligned.

== References ==
((Reflist))

== Further reading ==
*''Intel Architecture Software Developer's Manual''–Volume 3: System Programming

((Operating System))

[[Category:Operating system technology]]
[[Category:Computer errors]]

[[de:Allgemeine Schutzverletzung]]

Pages transcluded onto the current version of this page (help):

General protection fault (edit)
Template:Ambox (view source) (template editor protected)
Template:Category handler (view source) (protected)
Template:Cite web (view source) (protected)
Template:Clarify (view source) (template editor protected)
Template:Delink (view source) (protected)
Template:Find sources mainspace (view source) (template editor protected)
Template:Fix-span (view source) (template editor protected)
Template:Fix/category (view source) (protected)
Template:Hlist/styles.css (view source) (protected)
Template:Main other (view source) (protected)
Template:More citations needed (view source) (template editor protected)
Template:Multiple image (view source) (template editor protected)
Template:Multiple image/styles.css (view source) (template editor protected)
Template:Multiple issues (view source) (template editor protected)
Template:Multiple issues/styles.css (view source) (template editor protected)
Template:Navbox (view source) (template editor protected)
Template:Operating System (edit)
Template:Operating systems (view source) (semi-protected)
Template:Refimprove (view source) (template editor protected)
Template:Reflist (view source) (protected)
Template:Reflist/styles.css (view source) (protected)
Template:Technical (view source) (template editor protected)
Module:Arguments (view source) (protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:DecodeEncode (view source) (template editor protected)
Module:Delink (view source) (protected)
Module:Find sources (view source) (template editor protected)
Module:Find sources/config (view source) (template editor protected)
Module:Find sources/links (view source) (template editor protected)
Module:Find sources/templates/Find sources mainspace (view source) (template editor protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Multiple image (view source) (template editor protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Navbar (view source) (protected)
Module:Navbar/configuration (view source) (protected)
Module:Navbar/styles.css (view source) (protected)
Module:Navbox (view source) (template editor protected)
Module:Navbox/configuration (view source) (template editor protected)
Module:Navbox/styles.css (view source) (template editor protected)
Module:String (view source) (protected)
Module:Unsubst (view source) (protected)
Module:Yesno (view source) (protected)

Return to General protection fault.

Retrieved from "https://en.wikipedia.org/wiki/General_protection_fault"