Wat is een segmentatiefout?
Segmentatie fout of toegangsschending ( segmentfout Kortom) is een storing of fout die wordt veroorzaakt door hardware met geheugenbeveiliging, waardoor een besturingssysteem wordt gewaarschuwd dat de software heeft geprobeerd toegang te krijgen tot een beperkt geheugengebied (een schending van de geheugentoegang).
Het is een algemene beveiligingsfout op standaard x86-systemen. Als reactie hierop zal de kernel van het besturingssysteem doorgaans enkele corrigerende handelingen uitvoeren, waarbij de fout meestal wordt doorgegeven aan het overtredende proces door een signaal naar het proces over te brengen.
In sommige gevallen kunnen processen een signaalbehandelaar installeren, waardoor ze zelfstandig kunnen herstellen, maar in andere gevallen wordt de standaard signaalbehandelaar van het besturingssysteem gebruikt, wat doorgaans leidt tot abnormale beëindiging van het proces en soms tot een kerndump.
- Segmentatiefouten zijn een basisfoutklasse in programma's die in veel talen zijn gespecificeerd, zoals C taal die geheugentoegang op laag niveau biedt en sommige om veiligheidscontroles te kennen.
- In de eerste plaats ontstaan ze als gevolg van veel fouten in pointers die worden gebruikt voor de adressering van virtueel geheugen, met name illegale toegang.
- Andere typen geheugentoegangsfouten zijn: busfout , waartoe ook verschillende oorzaken behoren.
- Deze verschijnen voornamelijk vanwege onnauwkeurige fysieke geheugenadressering of verkeerd uitgelijnde geheugentoegang.
- Dit zijn enkele geheugenreferenties die de hardware niet kan adresseren, in plaats van referenties die het proces niet mag adresseren.
- Verschillende programmeertalen kunnen mechanismen toepassen die zijn gemaakt om segmentatiefouten te voorkomen en geheugenveiligheid te ontwikkelen. Bijvoorbeeld, de Roest programmeertaal past een op eigendom gebaseerd model toe om de geheugenveiligheid te garanderen. Een andere taal zoals Java En Lisp past garbage collection toe, waarbij veel geheugenfoutklassen worden genegeerd die segmentatiefouten kunnen veroorzaken.
Overzicht van segmentatiefouten
- Er treedt een segmentatiefout op wanneer een programma probeert toegang te krijgen tot een geheugenlocatie waartoe het geen toegang heeft, of probeert toegang te krijgen tot een geheugenlocatie op een manier die niet is toegestaan (bijvoorbeeld wanneer wordt geprobeerd naar een alleen-lezen locatie te schrijven of de geheugenlocatie te overschrijven). besturingssysteemgedeelte).
- In de computerwereld is het woord 'segmentatie' heeft verschillende toepassingen. In de zin van segmentatiefout, een woord dat sinds 1950 wordt gebruikt, definieert het de adresruimte van het programma, alleen de adresruimte van het programma is leesbaar met geheugenbeveiliging, en hiervan zijn alleen de stapel en het datasegment lees-schrijfgedeelte van het programma is beschrijfbaar. Daarom resulteert een poging om buiten de adresruimte van het programma te lezen, of om naar het alleen-lezen deel van de adresruimte te schrijven, in een segmentatiefout.
- Er treedt een segmentatiefout op als de hardware een poging vindt om te verwijzen naar een niet-bestaand segment, een locatie buiten de segmentgrenzen, of een locatie in een stijl die niet is toegestaan door de machtigingen die voor het segment zijn verleend op de systemen die gebruik maken van de geheugensegmentatie van de hardware voor het leveren van virtueel geheugen.
- Over het algemeen veroorzaakt een ongeldige paginafout een segmentatiefout op de systemen die alleen paging gebruiken. De paginafouten en segmentatiefouten zijn beide fouten die voortkomen uit het virtuele geheugenbeheersysteem. Ook kan een segmentatiefout onafhankelijk van de paginafouten optreden; onwettige toegang tot een geldige pagina is een segmentatiefout. De segmentatiefout kan in het midden van een pagina verschijnen. Binnen een bufferoverloop dat zich op een pagina bevindt, maar bijvoorbeeld het geheugen illegaal overschrijft.
- In eerste instantie is de fout ontstaan MMU ( geheugenbeheereenheid ) op illegale toegang, als onderdeel van het geheugenbeschermingsaspect, of een ongeldige paginafout op hardwareniveau. Als het probleem niet een ongeldig logisch adres is, maar eerder een ongeldig fysiek adres, treedt eerder de busfout op. Deze worden dus niet altijd onderscheiden.
- Deze fout wordt gevonden en er wordt een signaal naar het overtredende proces gestuurd, waarbij de handler van het proces voor dat signaal op besturingssysteemniveau wordt ingeschakeld. Verschillende typen besturingssystemen hebben verschillende signaalnamen om aan te geven dat er een segmentatiefout is opgetreden.
- Een signaal dat bekend staat als SIGSEGV (kort voor schending van de segmentatie ) wordt overgebracht naar het overtredende proces op de Unix-achtige besturingssystemen. Het overtredende proces krijgt een uitzondering, d.w.z. STATUS_ACCESS_VIOLATION op Microsoft Windows.
Oorzaken van segmentatiefouten
De omstandigheden waaronder een segmentatiefout optreedt en hoe deze zich manifesteert, zijn specifiek voor het besturingssysteem en de hardware. Verschillende hardware veroorzaakt verschillende fouten voor verschillende omstandigheden en verschillende besturingssystemen zetten deze om in verschillende signalen die naar de processen worden gestuurd.
De aanstaande oorzaak kan een schending van de geheugentoegang zijn, hoewel de onderliggende oorzaak een aantal soorten softwarefouten is. In enkele gevallen kan het debuggen van een bug of het vaststellen van de hoofdoorzaak eenvoudig zijn, waarbij het programma consequent tot een segmentatiefout zal leiden. In andere gevallen kan de tas echter moeilijk te reproduceren zijn en bij elke run afhankelijk zijn van de geheugentoewijzing.
Hieronder volgen enkele typische oorzaken van de segmentatiefout:
- Poging om toegang te krijgen tot een niet-bestaand geheugenadres (buiten de adresruimte van het proces)
- Pogingen om toegang te krijgen tot het geheugen waar een programma geen rechten voor heeft (zoals kernelstructuren binnen de procescontext)
- Poging tot het schrijven van alleen-lezen geheugen (zoals codesegment )
- Deze worden op hun beurt vaak veroorzaakt door veel programmeerfouten die resulteren in ongeldige geheugentoegang:
- Poging tot het uitvoeren van een programma dat niet correct compileert. (Sommige compilers resulteren in een uitvoerbaar bestand, ongeacht het bestaan van compileerfouten.)
- Een stapeloverloop
- Een bufferoverloop
- Het toewijzen of verwijderen van verwijzingen naar een vrijgemaakte aanwijzer (a bungelende wijzer , wat aangeeft dat geheugen is verwijderd/ongedaan gemaakt/vrijgemaakt)
- Het toewijzen of verwijderen van verwijzingen naar een niet-geïnitialiseerde aanwijzer (A wilde wijzer , wat een willekeurig geheugenadres aangeeft)
- Herverwijzing naar a nul punten geeft meestal een adres aan dat geen deel uitmaakt van de adresruimte van het proces
Segmentatiefouten verschijnen vaak als gevolg van fouten bij het gebruik van een aanwijzer, met name in C dynamische geheugentoewijzing in C-code. Herverwijzing naar a nul punten , wat resulteert in ongedefinieerd gedrag, zal leiden tot een segmentatiefout. Dit komt door een nulaanwijzer die geen geldig geheugenadres kan zijn. De bungelende wijzers En wilde aanwijzingen duiden op een geheugen dat wel of niet bestaat en wel of niet beschrijfbaar of leesbaar is en dus kan resulteren in tijdelijke bugs.
methode overbelasting
Segmentatiefout in Ubuntu oplossen
Deze fout kan ons Ubuntu-systeem op elk moment treffen. Er is sprake van een segmentatiefout wanneer ons systeem probeert toegang te krijgen tot een geheugenpagina die niet bestaat. Kern gedumpt definieert wanneer een codedeel probeert een schrijf- en leesbewerking uit te voeren op een vrije of alleen-lezen locatie. Over het algemeen, segmentfouten zijn gekoppeld aan een bestand met de naam core en gebeuren op het moment van de upgrade.
Tijdens het uitvoeren van een paar opdrachten ten tijde van de kerndumpsituatie kunnen we de 'Kan het vergrendelingsbestand niet openen' fout. Dit komt doordat het systeem probeert een stukje blok te nemen dat niet bestaat. Het komt door het crashen van binaire bestanden van een paar specifieke programma's.
Het kan zijn dat we bezig zijn met debuggen of teruggaan om het probleem op te lossen, maar de oplossing is om de kapotte pakketten te repareren door enkele stappen te implementeren die als volgt worden vermeld:
1. Verwijder de vergrendelingsbestanden die op verschillende locaties beschikbaar zijn.
$ sudo rm -rvf /var/lib/apt/lists/lock /var/cache/apt/archives/lock /var/lib/dpkg/lock and restart our system
2. Opslagplaatscache verwijderen.
$ sudo apt-get clean all
3. Upgrade en update onze repositorycache.
$ sudo apt-get update
$ sudo apt-get upgrade
4. Upgrade nu onze distributie, het zal onze pakketten bijwerken.
$ sudo apt-get dist-upgrade
5. Zoek de kapotte pakketten en verwijder ze krachtig.
$ sudo dpkg -1 | grep ^..r | apt-get purge
Een geweldige manier die altijd zal werken is als volgt, afgezien van de opdrachtregel:
c++ converteert in naar string
- Voer in de opstartmodus Ubuntu uit door op de knop te klikken Esc toets na het opnieuw opstarten.
- Kiezen ' Geavanceerde opties voor Ubuntu
- Voer in de herstelmodus Ubuntu uit en er worden verschillende opties genoemd.
- Kies eerst de 'Gebroken pakketten repareren'
- Kies vervolgens de 'Normaal opstarten hervatten'
Nu hebben we twee manieren om de GUI en CLI van segmentatiefouten op te lossen. Soms kan het ook gebeuren dat het commando, d.w.z. apt, niet werkt vanwege de segmentfout , dus de CLI-methode wordt niet geïmplementeerd. Maak je in die situatie geen zorgen, want de GUI-methode zal altijd voor ons werken.
Segmentatiefout afhandelen
De standaardtaak voor een busfout of segmentatiefout is de abnormale beëindiging van een proces dat deze fout heeft aangetroffen. Er kan een kernbestand worden geproduceerd om te helpen bij het opsporen van fouten, en er kunnen ook andere platformafhankelijke taken worden geïmplementeerd. Veel Linux-systemen passen bijvoorbeeld de grbeveiligingspatch zou kunnen loggen SIGSEGV-signalen voor het monitoren van mogelijke inbraakpogingen met bufferoverflows.
Op een aantal systemen, zoals Windows en Linux, is het mogelijk dat een programma zelf een segmentatiefout beheert. Het actieve programma kan de gebeurtenis niet alleen beheren, maar kan ook enkele details over de status ervan extraheren, zoals de waarden van het processorregister, het verkrijgen van een stacktrace, de regel van een broncode wanneer deze werd aangetroffen, het geheugenadres dat ongeldig werd benaderd en of de taak een schrijf- of leesopdracht was, afhankelijk van het besturingssysteem en de architectuur.
Een segmentatiefout definieert echter dat een programma een fout heeft die moet worden verholpen. Het is ook mogelijk om een dergelijke fout opzettelijk te veroorzaken voor testdoeleinden, voor foutopsporing, en ook om platforms te imiteren waarin directe toegang tot het geheugen vereist is. In het laatste geval moet het systeem het programma kunnen laten uitvoeren, zelfs nadat de fout is opgetreden.
In deze situatie is het, wanneer het systeem dit toelaat, mogelijk om de gebeurtenis te beheren en het processorprogramma tegen te gaan 'springen' over de falende instructie om door te gaan met de uitvoering.
Voorbeelden van segmentatiefouten
Schrijven naar alleen-lezen geheugen
Er ontstaat een segmentatiefout. Het verschijnt wanneer het programma naar een deel van zijn codesegment of het alleen-lezen deel van het datasegment schrijft op de codefoutniveaus, omdat deze via het besturingssysteem in het alleen-lezen geheugen worden geladen.
java byte-array naar string
Null pointer-dereferentie
In C en andere C-achtige talen worden de nulaanwijzers gebruikt voor betekenis 'wijzer naar geen object' en aangezien de foutindicator en dereferentie in de nulaanwijzer (een schrijven of lezen vanaf een nulaanwijzer) een zeer fundamentele programmafout is.
De standaard zegt niet dat de nulpointer vergelijkbaar is met de pointer naar het geheugenadres 0, hoewel dat wel het geval zou kunnen zijn. Bijna alle besturingssystemen brengen het adres van de nulaanwijzer zodanig in kaart dat het gebruik ervan tot een segmentatiefout leidt.
Dit gedrag wordt door geen enkele C-standaard gegarandeerd. In C is het derefereren van de nulwijzer de ongedefinieerd gedrag , en een conforme implementatie mag ervan uitgaan dat een pointer waarvan de verwijzing is verwijderd, niet nul is.