Какво е грешка в сегментирането?

Грешка в сегментацията или нарушаване на достъпа ( segfault накратко) е състояние на повреда или повреда, която възниква от хардуер със защита на паметта, предупреждавайки операционна система, която софтуерът се е опитал да получи достъп до ограничена област на паметта (нарушение на достъпа до паметта).

ник пулос черна светкавица

Това е обща форма на грешка в защитата на стандартни x86 системи. В отговор ядрото на операционната система обикновено ще приложи няколко коригиращи операции, като обикновено ще прехвърли тази грешка на процеса на нарушение чрез прехвърляне на сигнал към процеса.

В някои случаи процесите могат да инсталират манипулатор на сигнали, което им позволява да се възстановяват сами, но в противен случай се използва манипулаторът на сигнали по подразбиране на операционната система, което обикновено води до необичайно прекратяване на процеса и понякога дъмп на ядрото.

• Грешките в сегментирането са основен клас грешки в програмите, посочени на много езици, като напр ° С език, който предлага достъп до паметта на ниско ниво и някои проверки за безопасност.
• Преди всичко те възникват поради много грешки в указателите, използвани за адресиране на виртуална памет, по-специално незаконен достъп.
• Други видове грешки при достъпа до паметта са a грешка на автобуса , което също включва няколко причини.
• Те се появяват главно поради неточно адресиране на физическа памет или неправилно подравнен достъп до паметта.
• Това са някои препратки към паметта, които хардуерът не може да адресира, вместо препратки, които процесът няма разрешение да адресира.
• Няколко езика за програмиране могат да прилагат механизми, създадени за избягване на грешки в сегментирането и развитие на безопасността на паметта. Например, на Ръжда езикът за програмиране прилага модел, базиран на собствеността, за осигуряване на безопасност на паметта. Друг подобен език Java и Lisp прилага събиране на отпадъци, което игнорира много класове грешки в паметта, които могат да причинят грешки в сегментирането.

Преглед на грешката на сегментирането

• Грешка при сегментиране се появява, когато която и да е програма се опита да осъществи достъп до място в паметта, до което не е разрешен достъп, или се опита да осъществи достъп до място в паметта по начин, който не е разрешен (например опит за запис в място само за четене или за презаписване на част от операционната система).
• В компютърната техника думата 'сегментация' има няколко приложения. По пътя на segmentation fault, дума, използвана от 1950 г., тя дефинира адресното пространство на програмата, само адресното пространство на програмата може да се чете със защита на паметта и от това само стекът и частта за четене и запис на сегмента от данни на програмата може да се записва. Следователно, опит за четене извън адресното пространство на програмата или запис в частта само за четене на адресното пространство води до грешка в сегментирането.
• Грешка в сегментирането се появява, ако хардуерът открие опит за препратка към несъществуващ сегмент, местоположение извън границите на сегмента или местоположение в стил, който не е разрешен от разрешенията, предоставени за сегмента в системите, използващи сегментиране на паметта на хардуера за предоставяне на виртуална памет.
• Обикновено невалидна грешка на страницата причинява грешка в сегментирането на системите, използващи само страниране. Грешките на страницата и грешките в сегментирането са грешки, произтичащи от системата за управление на виртуалната памет. Също така грешката в сегментирането може да възникне независимо от грешките на страницата; нелегитимният достъп до която и да е валидна страница е грешка в сегментирането. Грешката в сегментирането може да се появи в средата на страницата. Вътре в a препълване на буфера който се намира в страница, но презаписва незаконно паметта например.
• Първоначално повредата възниква от MMU ( модул за управление на паметта ) при незаконен достъп, като сегмент от неговия аспект на защита на паметта, или невалидна грешка на страницата на хардуерно ниво. Ако проблемът не е невалиден логически адрес, а по-скоро невалиден физически адрес, по-скоро възниква грешката на шината. Така че те не винаги се отличават.
• Тази неизправност се открива и се изпраща сигнал до процеса на нарушение, като се включва манипулаторът на процеса за този сигнал на ниво операционна система. Различните типове операционни системи имат различни имена на сигнали, които показват, че се е появила грешка в сегментирането.
• Сигнал, известен като SIGSEGV (съкратено от нарушение на сегментацията ) се прехвърля към процеса на нарушение на Unix-подобни операционни системи. Процесът на нарушение получава изключение, т.е. STATUS_ACCESS_VIOLATION на Microsoft Windows.

Причини за грешка в сегментирането

Обстоятелствата, при които се появява грешка в сегментирането и как се проявява, са специфични за операционната система и хардуера. Различният хардуер предизвиква различни неизправности при различни обстоятелства и различните операционни системи ги трансформират в различни сигнали, които се изпращат до процесите.

Предстоящата причина може да е нарушение на достъпа до паметта, въпреки че основната причина е софтуерна грешка от няколко вида. Отстраняването на грешка или определянето на основната причина може да бъде лесно в няколко случая, в които програмата постоянно ще води до грешка в сегментирането. Въпреки това, чантата може да бъде трудна за възпроизвеждане и да разчита на разпределението на паметта при всяко изпълнение в други случаи.

Следват няколко типични причини за повреда в сегментирането:

• Опит за достъп до несъществуващ адрес в паметта (външен за адресното пространство на процеса)
• Опит за достъп до паметта, за която програма няма права (като структури на ядрото в контекста на процеса)
• Опит за запис на памет само за четене (като кодов сегмент )
• На свой ред те често възникват от много програмни грешки, които водят до невалиден достъп до паметта:
• Опит за изпълнение на програма, която не се компилира правилно. (Няколко компилатора ще доведат до изпълним файл, независимо от наличието на грешки по време на компилиране.)
• Препълване на стека
• Препълване на буфера
• Присвояване или дерефериране на освободен указател (a висяща показалка , което показва памет, която е била изтрита/освободена/освободена)
• Присвояване или дерефериране на неинициализиран указател (а дива показалка , което показва произволен адрес на паметта)
• Дерефериране на a нулев указател обикновено показва адрес, който не е част от адресното пространство на процеса

Грешките в сегментирането често се появяват поради грешки при използването на указател, по-специално в C динамично разпределение на паметта в C код. Дерефериране на a нулев указател , което води до недефинирано поведение, ще доведе до грешка в сегментирането. Това се дължи на нулев указател, който не може да бъде валиден адрес на паметта. The висящи указатели и диви указатели показват памет, която може или не може да съществува и може или не може да се записва или чете и по този начин може да доведе до преходни грешки.

Разрешаване на грешка при сегментиране в Ubuntu

Тази грешка може да удари нашата Ubuntu система по всяко време. Грешка в сегментирането е, когато нашата система се опита да получи достъп до страница от паметта, която не съществува. Ядрото е изхвърлено дефинира кога кодова част се опитва да извърши операция за запис и четене на свободно място или място само за четене. В общи линии, сегментни грешки са свързани с файл с име core и се случват по време на надграждане.

Докато изпълняваме няколко команди по време на ситуацията на изхвърляне на ядрото, може да срещнем „Не може да се отвори заключен файл“ грешка. Това се дължи на това, че системата се опитва да вземе част от блок, който не съществува. Това се дължи на срива на двоичните файлове на няколко конкретни програми.

Може да отстраняваме грешки или да се връщаме назад, за да го разрешим, но решението е да поправим повредените пакети чрез прилагане на някои стъпки, които са споменати, както следва:

1. Премахнете заключващите файлове, налични на отделни места.

 $ sudo rm -rvf /var/lib/apt/lists/lock /var/cache/apt/archives/lock /var/lib/dpkg/lock and restart our system 

2. Премахване на кеша на хранилището.

 $ sudo apt-get clean all 

3. Надстройте и актуализирайте нашия кеш на хранилището.

 $ sudo apt-get update 

 $ sudo apt-get upgrade 

4. Сега надстройте нашата дистрибуция, тя ще актуализира нашите пакети.

 $ sudo apt-get dist-upgrade 

5. Претърсете счупените пакети и ги премахнете насила.

 $ sudo dpkg -1 | grep ^..r | apt-get purge 

Чудесен начин, който винаги ще работи, е следният освен командния ред:

1. В режим на стартиране стартирайте Ubuntu, като щракнете върху Esc ключ след рестартиране.
2. Избирам ' Разширени опции за Ubuntu
   
3. В режим на възстановяване стартирайте Ubuntu и ще бъдат споменати няколко опции.
4. Първо изберете „Поправяне на счупени пакети“
   
5. След това изберете „Възобновяване на нормалното зареждане“
   

Сега имаме два начина за разрешаване на GUI и CLI за грешка при сегментиране. Понякога може да се случи и командата, т.е. apt, да не работи поради segfault , така че CLI методът няма да се приложи. В тази ситуация не се притеснявайте, защото GUI методът винаги ще работи за нас.

Грешка при обработка на сегментиране

Задачата по подразбиране за грешка в шината или сегментиране е необичайно прекратяване на процес, който я е срещнал. Може да се създаде основен файл, който да помогне за отстраняване на грешки, и могат също да бъдат изпълнени други зависещи от платформата задачи. Например, много Linux системи, прилагащи grsecurity пач може да регистрира SIGSEGV сигнали за наблюдение за възможни опити за проникване с препълване на буфера.

На няколко системи, като Windows и Linux, е възможно самата програма да управлява грешка в сегментирането. Работещата програма не само може да управлява събитието, но може да извлече някои подробности за състоянието му, като стойностите на регистъра на процесора, получаване на проследяване на стека, реда на изходния код, когато е срещнат, адрес на паметта, до който е бил достъпен невалидно, и дали задачата е била запис или четене в зависимост от операционната система и архитектурата.

Грешката при сегментиране обаче определя, че дадена програма има грешка, която изисква коригиране, също така е възможно умишлено да се причини такава повреда с цел тестване, отстраняване на грешки, а също и да се имитират платформи, в които се изисква директен достъп до паметта. Системата трябва да може да позволи на програмата да се изпълни дори след възникване на грешката в последния случай.

unix създаване на директория

В тази ситуация, когато системата позволява, е възможно да се управлява събитието и да се подобри програмният брояч на процесора 'скок' върху неуспешната инструкция да продължите с изпълнението.

Примери за грешка при сегментиране

Записване в памет само за четене

Възниква дефект на сегментиране. Появява се, когато програмата записва в част от кодовия си сегмент или в частта само за четене от сегмента с данни на нивата на грешка в кода, тъй като те се зареждат чрез операционната система в паметта само за четене.

Дереференция на нулев указател

В C и други C-подобни езици нулевите указатели се използват за значение 'указател към никакъв обект' и като индикатор за грешка и дереферирането в нулевия указател (запис или четене от нулев указател) е много основна програмна грешка.

Стандартът не казва, че нулевият указател е подобен на указателя към 0 адрес на паметта, въпреки че това може да е така. Почти всички операционни системи картографират адреса на нулевия указател така, че използването му води до грешка в сегментирането.

Това поведение не е гарантирано от нито един C стандарт. В C дереферирането на нулевия указател е неопределено поведение , а на съответстваща реализация е разрешено да приеме, че указател, който е дерефериран, не е нулев.

Препълване на буфера

Препълване на стека