Generell beskyttelsesfeil - General protection fault

Generisk feilmelding for en generell beskyttelsesfeil (uopprettelig applikasjonsfeil) i Windows 3.0

Eksempel på feilmelding for en generell beskyttelsesfeil i Windows 3.1x

En generell beskyttelsesfeil ( GPF ) i x86 instruksjonssettarkitekturen (ISA) er en feil (en type avbrudd ) som initieres av ISA-definerte beskyttelsesmekanismer som svar på et brudd på tilgang forårsaket av noen kjørende kode, enten i kjernen eller en brukerprogram. Mekanismen er først beskrevet i Intel manualer og datablad for Intel 80286 CPU, som ble introdusert i 1983; Det er også beskrevet i seksjon 9.8.13 i Intel 80386 programmererens referansemanualen fra 1986. En generell beskyttelsesfeil er implementert som et avbrudd ( vektor nummer 13 (0Dh)). Noen operativsystemer kan også klassifisere noen unntak som ikke er knyttet til brudd på tilgang, for eksempel ulovlige opcode -unntak, som generelle beskyttelsesfeil, selv om de ikke har noe med minnebeskyttelse å gjøre. Hvis en CPU oppdager et brudd på beskyttelsen, slutter den å kjøre koden og sender en GPF -avbrudd. I de fleste tilfeller fjerner operativsystemet den mislykkede prosessen fra kjøringskøen, signaliserer brukeren og fortsetter å utføre andre prosesser. Hvis imidlertid operativsystemet ikke klarer å fange den generelle beskyttelsesfeilen, dvs. at det oppstår et nytt beskyttelsesbrudd før operativsystemet kommer tilbake fra forrige GPF -avbrudd, signaliserer CPU en dobbel feil og stopper operativsystemet. Hvis det oppstår enda en feil ( trippel feil ), kan ikke CPU'en gjenopprette; siden 80286 går CPU -en inn i en spesiell stopp -tilstand kalt "Shutdown", som bare kan avsluttes ved å tilbakestille maskinvaren . Den IBM PC AT , den første PC-kompatibel system for å inneholde et 80 286, har hardware som registrerer Shutdown staten og automatisk tilbakestiller CPU når det skjer. Alle etterkommere av PC AT gjør det samme, så i en PC forårsaker en trippel feil en umiddelbar tilbakestilling av systemet.

Spesifikk oppførsel

I Microsoft Windows viser den generelle beskyttelsesfeilen et variert språk, avhengig av produktversjon:

I Unix og Linux rapporteres feilene separat (f.eks. Segmenteringsfeil for minnefeil).

Minne feil

I minnefeil får det feilaktige programmet tilgang til minne som det ikke burde ha tilgang til. Eksempler inkluderer:

• Forsøk på å skrive til en skrivebeskyttet del av minnet
• Forsøk på å utføre byte i minne som ikke er angitt som instruksjoner
• Forsøk på å lese som databyte i minnet som er angitt som instruksjoner
• Andre diverse konflikter mellom betegnelsen på en del av minnet og bruken av den

Imidlertid implementerer mange moderne operativsystemer sine tilgangskontrollsystemer for minne via personsøk i stedet for segmentering, så det er ofte slik at ugyldige minnereferanser i operativsystemer som Windows rapporteres via sidefeil i stedet for generelle beskyttelsesfeil. Operativsystemer gir vanligvis et abstraksjonslag (for eksempel unntakshåndtering eller signaler) som skjuler hvilken intern prosessormekanisme som ble brukt for å heve en minnetilgangsfeil fra et program, for å tilby et standard grensesnitt for håndtering av mange forskjellige typer prosessorgenererte feilbetingelser.

Når det gjelder x86-arkitekturen, er generelle beskyttelsesfeil spesifikke for segmenteringsbasert beskyttelse når det gjelder minnetilgang. Imidlertid brukes generelle beskyttelsesfeil fortsatt for å rapportere andre beskyttelsesbrudd (bortsett fra brudd på minnetilgang) når personsøking brukes, for eksempel bruk av instruksjoner som ikke er tilgjengelige fra gjeldende privilegiumnivå (CPL).

Selv om det er teoretisk mulig for et operativsystem å bruke både personsøking og segmentering, er vanlige operativsystemer for det meste vanligvis avhengige av personsøkning for hovedtyngden av behovet for tilgangskontroll for minne.

Privilegeringsfeil

Det er noen ting på en datamaskin som er forbeholdt eksklusiv bruk av operativsystemet . Hvis et program som ikke er en del av operativsystemet prøver å bruke en av disse funksjonene, kan det forårsake en generell beskyttelsesfeil.

I tillegg er det lagringssteder som er reservert både for operativsystemet og selve prosessoren. Som en konsekvens av reservasjonen er de skrivebeskyttet, og et forsøk på å skrive data til dem av et uprivilegert program er en feil.

Tekniske årsaker til feil

Generelle beskyttelsesfeil tas opp av prosessoren når det oppstår en beskyttet instruksjon som overskrider tillatelsesnivået for oppgaven som utføres for øyeblikket, enten fordi et brukermodusprogram prøver en beskyttet instruksjon, eller fordi operativsystemet har sendt en forespørsel prosessoren til en udefinert tilstand.

Generelle beskyttelsesfeil fanges opp og håndteres av moderne operativsystemer. Vanligvis, hvis feilen oppsto i et brukermodusprogram, avsluttes brukermodusprogrammet. Hvis feilen imidlertid oppsto i en kjernesystemdriver eller selve operativsystemet, lagrer operativsystemet vanligvis diagnostisk informasjon enten i en fil eller på skjermen og slutter å fungere. Den starter datamaskinen på nytt eller viser en feilskjerm , for eksempel en Blue Screen of Death eller kjernepanikk .

Segmentgrensene overskredet

Segmentgrenser kan overskrides:

• med kodesegment (CS), datasegment (DS) eller ES, FS eller GS (ekstrasegment) registre; eller
• få tilgang til deskriptortabeller som Global Descriptor Table (GDT), Interrupt deskriptortabellen (IDT) og Local Descriptor Table (LDT).

Segmenttillatelser brutt

Segmenttillatelser kan krenkes av:

• hopper til ikke-kjørbare segmenter
• skrive til kodesegmenter, eller skrivebeskyttede segmenter
• lese eksekverte segmenter

Segmenter ulovlig lastet inn

Dette kan skje når:

• et stacksegment (SS) er lastet med en segmentvelger for et skrivebeskyttet, kjørbart, nullsegment eller segment med deskriptorrettighet som ikke samsvarer med gjeldende privilegium i CS
• et kodesegment (CS) lastet med en segmentvelger for et data-, system- eller nullsegment
• SS, DS, ES, FS eller GS er segmenter lastet med en segmentvelger for et systemsegment
• SS, DS, ES, FS eller GS er segmenter lastet med en segmentvelger for et bare utførende kodesegment
• tilgang til minne ved hjelp av DS-, ES-, FS- eller GS -registre når de inneholder en nullvelger

Veksling

Det kan oppstå feil i oppgavestatus -segmentet (TSS) -strukturen når:

• bytte til en travel oppgave under en samtale eller hoppinstruksjon
• bytte til en tilgjengelig oppgave under en interrupt return (IRET) instruksjon
• ved hjelp av en segmentvelger på en bryter som peker til en TSS -deskriptor i LDT

Diverse

Andre årsaker til generelle beskyttelsesfeil er:

• forsøker å få tilgang til en avbrudds / unntaksbehandler fra virtuell 8086 modus når føreren kode segmentdeskriptor privilegienivået (DPL) er større enn null
• prøver å skrive en en til de reserverte bitene i CR4
• prøver å utføre privilegerte instruksjoner når gjeldende privilegiumnivå (CPL) ikke er null
• skrive til en reservert bit i en MSR -instruksjon
• tilgang til en port som inneholder en nullsegmentvelger
• utføre et programvareavbrudd når CPL er større enn DPL -settet for avbruddsporten
• segmentvelgeren i en samtale-, avbrudds- eller fangeport peker ikke på et kodesegment
• krenker privilegiereglene
• muliggjøre personsøk mens deaktivering av beskyttelse
• referere til avbrytningsbeskrivelsestabellen etter et avbrudd eller unntak som ikke er en avbrudd, felle eller en oppgaveport
• Eldre SSE : Minneoperand er ikke 16-byte justert.

Referanser

Videre lesning

• Intel Architecture Software Developer's Manual – Volume 3: System Programming