Не всегда программы в Linux запускаются как положено. Иногда, в силу разных причин программа вместо нормальной работы выдает ошибку. Но нам не нужна ошибка, нам нужна программа, вернее, та функция, которую она должна выполнять. Сегодня мы поговорим об одной из самых серьезных и непонятных ошибок. Это ошибка сегментации Ubuntu. Если такая ошибка происходит только один раз, то на нее можно не обращать внимания, но если это регулярное явление нужно что-то делать.
Конечно, случается эта проблема не только в Ubuntu, а во всех Linux дистрибутивах, поэтому наша инструкция будет актуальна для них тоже. Но сосредоточимся мы в основном на Ubuntu. Рассмотрим что такое ошибка сегментирования linux, почему она возникает, а также как с этим бороться и что делать.
Что такое ошибка сегментации?
Ошибка сегментации, Segmentation fault, или Segfault, или SIGSEGV в Ubuntu и других Unix подобных дистрибутивах, означает ошибку работы с памятью. Когда вы получаете эту ошибку, это значит, что срабатывает системный механизм защиты памяти, потому что программа попыталась получить доступ или записать данные в ту часть памяти, к которой у нее нет прав обращаться.
Чтобы понять почему так происходит, давайте рассмотрим как устроена работа с памятью в Linux, я попытаюсь все упростить, но приблизительно так оно и работает.
Допустим, в вашей системе есть 6 Гигабайт оперативной памяти, каждой программе нужно выделить определенную область, куда будет записана она сама, ее данные и новые данные, которые она будет создавать. Чтобы дать возможность каждой из запущенных программ использовать все шесть гигабайт памяти был придуман механизм виртуального адресного пространства. Создается виртуальное пространство очень большого размера, а из него уже выделяется по 6 Гб для каждой программы. Если интересно, это адресное пространство можно найти в файле /proc/kcore, только не вздумайте никуда его копировать.
Выделенное адресное пространство для программы называется сегментом. Как только программа попытается записать или прочитать данные не из своего сегмента, ядро отправит ей сигнал SIGSEGV и программа завершится с нашей ошибкой. Более того, каждый сегмент поделен на секции, в некоторые из них запись невозможна, другие нельзя выполнять, если программа и тут попытается сделать что-то запрещенное, мы опять получим ошибку сегментации Ubuntu.
Почему возникает ошибка сегментации?
И зачем бы это порядочной программе лезть, куда ей не положено? Да в принципе, незачем. Это происходит из-за ошибки при написании программ или несовместимых версиях библиотек и ПО. Часто эта ошибка встречается в программах на Си или C++. В этом языке программисты могут вручную работать с памятью, а язык со своей стороны не контролирует, чтобы они это делали правильно, поэтому одно неверное обращение к памяти может обрушить программу.
Почему может возникать эта ошибка при несовместимости библиотек? По той же причине — неверному обращению к памяти. Представим, что у нас есть библиотека linux (набор функций), в которой есть функция, которая выполняет определенную задачу. Для работы нашей функции нужны данные, поэтому при вызове ей нужно передать строку. Наша старая версия библиотеки ожидает, что длина строки будет до 256 символов. Но программа была обновлена формат записи поменялся, и теперь она передает библиотеке строку размером 512 символов. Если обновить программу, но оставить старую версию библиотеки, то при передаче такой строки 256 символов запишутся нормально в подготовленное место, а вот вторые 256 перезапишут данные программы, и возможно, попытаются выйти за пределы сегмента, тогда и будет ошибка сегментирования linux.
Что делать если возникла ошибка сегментирования?
Если вы думаете, что это ошибка в программе, то вам остается только отправить отчет об ошибке разработчикам. Но вы все-таки еще можете попытаться что-то сделать.
Например, если падает с ошибкой сегментации неизвестная программа, то мы можем решить что это вина разработчиков, но если с такой ошибкой падает chrome или firefox при запуске возникает вопрос, может мы делаем что-то не так? Ведь это уже хорошо протестированные программы.
Первое, что нужно сделать — это обновить систему до самой последней версии, возможно, был баг и его уже исправили, а может у вас установлены старые версии библиотек и обновление решит проблему. В Ubuntu это делается так:
sudo apt update
sudo apt full-upgrade
Если это не помогло, нужно обнулить настройки программы до значений по умолчанию, возможно, удалить кэш. Настройки программ в Linux обычно содержатся в домашней папке, скрытых подкаталогах с именем программы. Также, настройки и кэш могут содержаться в каталогах ~/.config и ~/.cache. Просто удалите папки программы и попробуйте снова ее запустить. Если и это не помогло, вы можете попробовать полностью удалить программу, а потом снова ее установить, возможно, какие-нибудь зависимости были повреждены:
sudo apt remove пакет_программы
sudo apt autoremove
sudo apt install пакет_программы
Если есть возможность, попробуйте установить программу из другого источника, например, не из PPA, а более старую версию, из официальных репозиториев.
Когда вы все это выполнили, скорее всего, проблема не в вашем дистрибутиве, а в самой программе. Нужно отправлять отчет разработчикам. В Ubuntu это можно сделать с помощью программы apport-bug. Обычно Ubuntu предлагает это сделать сразу, после того как программа завершилась с ошибкой сегментирования. Если же ошибка сегментирования Ubuntu встречается не в системной программе, то вам придется самим искать разработчиков и вручную описывать что произошло.
Чтобы помочь разработчикам решить проблему, недостаточно отправить им только сообщение что вы поймали Segmentation Fault, нужно подробно описать проблему, действия, которые вы выполняли перед этим, так чтобы разработчик мог их воспроизвести. Также, желательно прикрепить к отчету последние функции, которые вызывала программа (стек вызовов функций), это может очень сильно помочь разработчикам.
Рассмотрим, как его получить. Это не так уж сложно. Сначала запустите вашу программу, затем узнайте ее PID с помощью команды:
pgrep программа
Дальше запускаем отладчик gdb:
sudo gdb -q
Подключаемся к программе:
(gdb) attach ваш_pid
После подключения программа станет на паузу, продолжаем ее выполнение командой:
(gdb) continue
Затем вам осталось только вызвать ошибку:
И набрать команду, которая выведет стек последних вызовов:
(gdb) backtrace
Вывод этой команды и нужно отправлять разработчикам. Чтобы отключиться от программы и выйти наберите:
(gdb) detach
(gdb) quit
Дальше остается отправить отчет и ждать исправления ошибки. Если вы не уверены, что ошибка в программе, можете поспрашивать на форумах. Когда у вас есть стек вызовов, уже можно попытаться, если не понять в чем проблема, то попытаться узнать, не сталкивался ли с подобной проблемой еще кто-то.
Выводы
Теперь у вас есть приблизительный план действий, что нужно делать, когда появляется ошибка сегментирования сделан дамп памяти ubuntu. Если вы знаете другие способы решить эту проблему, напишите в комментариях!
Обнаружили ошибку в тексте? Сообщите мне об этом. Выделите текст с ошибкой и нажмите Ctrl+Enter.
Статья распространяется под лицензией Creative Commons ShareAlike 4.0 при копировании материала ссылка на источник обязательна .
Не всегда программы в Linux запускаются как положено. Иногда, в силу разных причин программа вместо нормальной работы выдает ошибку. Но нам не нужна ошибка, нам нужна программа, вернее, та функция, которую она должна выполнять. Сегодня мы поговорим об одной из самых серьезных и непонятных ошибок. Это ошибка сегментации Ubuntu. Если такая ошибка происходит только один раз, то на нее можно не обращать внимания, но если это регулярное явление нужно что-то делать.
Конечно, случается эта проблема не только в Ubuntu, а во всех Linux дистрибутивах, поэтому наша инструкция будет актуальна для них тоже. Но сосредоточимся мы в основном на Ubuntu. Рассмотрим что такое ошибка сегментирования linux, почему она возникает, а также как с этим бороться и что делать.
Что такое ошибка сегментации?
Ошибка сегментации, Segmentation fault, или Segfault, или SIGSEGV в Ubuntu и других Unix подобных дистрибутивах, означает ошибку работы с памятью. Когда вы получаете эту ошибку, это значит, что срабатывает системный механизм защиты памяти, потому что программа попыталась получить доступ или записать данные в ту часть памяти, к которой у нее нет прав обращаться.
Чтобы понять почему так происходит, давайте рассмотрим как устроена работа с памятью в Linux, я попытаюсь все упростить, но приблизительно так оно и работает.
Допустим, в вашей системе есть 6 Гигабайт оперативной памяти, каждой программе нужно выделить определенную область, куда будет записана она сама, ее данные и новые данные, которые она будет создавать. Чтобы дать возможность каждой из запущенных программ использовать все шесть гигабайт памяти был придуман механизм виртуального адресного пространства. Создается виртуальное пространство очень большого размера, а из него уже выделяется по 6 Гб для каждой программы. Если интересно, это адресное пространство можно найти в файле /proc/kcore, только не вздумайте никуда его копировать.
Выделенное адресное пространство для программы называется сегментом. Как только программа попытается записать или прочитать данные не из своего сегмента, ядро отправит ей сигнал SIGSEGV и программа завершится с нашей ошибкой. Более того, каждый сегмент поделен на секции, в некоторые из них запись невозможна, другие нельзя выполнять, если программа и тут попытается сделать что-то запрещенное, мы опять получим ошибку сегментации Ubuntu.
Почему возникает ошибка сегментации?
И зачем бы это порядочной программе лезть, куда ей не положено? Да в принципе, незачем. Это происходит из-за ошибки при написании программ или несовместимых версиях библиотек и ПО. Часто эта ошибка встречается в программах на Си или C++. В этом языке программисты могут вручную работать с памятью, а язык со своей стороны не контролирует, чтобы они это делали правильно, поэтому одно неверное обращение к памяти может обрушить программу.
Почему может возникать эта ошибка при несовместимости библиотек? По той же причине — неверному обращению к памяти. Представим, что у нас есть библиотека linux (набор функций), в которой есть функция, которая выполняет определенную задачу. Для работы нашей функции нужны данные, поэтому при вызове ей нужно передать строку. Наша старая версия библиотеки ожидает, что длина строки будет до 256 символов. Но программа была обновлена формат записи поменялся, и теперь она передает библиотеке строку размером 512 символов. Если обновить программу, но оставить старую версию библиотеки, то при передаче такой строки 256 символов запишутся нормально в подготовленное место, а вот вторые 256 перезапишут данные программы, и возможно, попытаются выйти за пределы сегмента, тогда и будет ошибка сегментирования linux.
Что делать если возникла ошибка сегментирования?
Если вы думаете, что это ошибка в программе, то вам остается только отправить отчет об ошибке разработчикам. Но вы все-таки еще можете попытаться что-то сделать.
Например, если падает с ошибкой сегментации неизвестная программа, то мы можем решить что это вина разработчиков, но если с такой ошибкой падает chrome или firefox при запуске возникает вопрос, может мы делаем что-то не так? Ведь это уже хорошо протестированные программы.
Первое, что нужно сделать — это обновить систему до самой последней версии, возможно, был баг и его уже исправили, а может у вас установлены старые версии библиотек и обновление решит проблему. В Ubuntu это делается так:
sudo apt update
sudo apt full-upgrade
Если это не помогло, нужно обнулить настройки программы до значений по умолчанию, возможно, удалить кэш. Настройки программ в Linux обычно содержатся в домашней папке, скрытых подкаталогах с именем программы. Также, настройки и кэш могут содержаться в каталогах ~/.config и ~/.cache. Просто удалите папки программы и попробуйте снова ее запустить. Если и это не помогло, вы можете попробовать полностью удалить программу, а потом снова ее установить, возможно, какие-нибудь зависимости были повреждены:
sudo apt remove пакет_программы
sudo apt autoremove
sudo apt install пакет_программы
Если есть возможность, попробуйте установить программу из другого источника, например, не из PPA, а более старую версию, из официальных репозиториев.
Когда вы все это выполнили, скорее всего, проблема не в вашем дистрибутиве, а в самой программе. Нужно отправлять отчет разработчикам. В Ubuntu это можно сделать с помощью программы apport-bug. Обычно Ubuntu предлагает это сделать сразу, после того как программа завершилась с ошибкой сегментирования. Если же ошибка сегментирования Ubuntu встречается не в системной программе, то вам придется самим искать разработчиков и вручную описывать что произошло.
Чтобы помочь разработчикам решить проблему, недостаточно отправить им только сообщение что вы поймали Segmentation Fault, нужно подробно описать проблему, действия, которые вы выполняли перед этим, так чтобы разработчик мог их воспроизвести. Также, желательно прикрепить к отчету последние функции, которые вызывала программа (стек вызовов функций), это может очень сильно помочь разработчикам.
Рассмотрим, как его получить. Это не так уж сложно. Сначала запустите вашу программу, затем узнайте ее PID с помощью команды:
pgrep программа
Дальше запускаем отладчик gdb:
sudo gdb -q
Подключаемся к программе:
(gdb) attach ваш_pid
После подключения программа станет на паузу, продолжаем ее выполнение командой:
(gdb) continue
Затем вам осталось только вызвать ошибку:
И набрать команду, которая выведет стек последних вызовов:
(gdb) backtrace
Вывод этой команды и нужно отправлять разработчикам. Чтобы отключиться от программы и выйти наберите:
(gdb) detach
(gdb) quit
Дальше остается отправить отчет и ждать исправления ошибки. Если вы не уверены, что ошибка в программе, можете поспрашивать на форумах. Когда у вас есть стек вызовов, уже можно попытаться, если не понять в чем проблема, то попытаться узнать, не сталкивался ли с подобной проблемой еще кто-то.
Выводы
Теперь у вас есть приблизительный план действий, что нужно делать, когда появляется ошибка сегментирования сделан дамп памяти ubuntu. Если вы знаете другие способы решить эту проблему, напишите в комментариях!
Статья распространяется под лицензией Creative Commons ShareAlike 4.0 при копировании материала ссылка на источник обязательна .
Содержание:
- Handling
- Overview
- Causes
- Что такое ошибка сегментации?
- Additional Information
- Examples
- Writing to read-only memory
- Null pointer dereference
- Stack overflow
Handling
The default action for a segmentation fault or bus error is abnormal termination of the process that triggered it. A core file may be generated to aid debugging, and other platform-dependent actions may also be performed. For example, Linux systems using the grsecurity patch may log SIGSEGV signals in order to monitor for possible intrusion attempts using buffer overflows.
On some systems, like Linux and Windows, it is possible for the program itself to handle a segmentation fault.. Depending on the architecture and operating system, the running program can not only handle the event but may extract some information about its state like getting a stack trace, processor register values, the line of the source code when it was triggered, memory address that was invalidly accessed and whether the action was a read or a write.
Although a segmentation fault generally means that the program has a bug that needs fixing, it is also possible to intentionally cause such failure for the purposes of testing, debugging and also to emulate platforms were direct access to memory is needed. On the latter case, the system must be able to allow the program to run even after the fault occurs. In this case, when the system allows, it is possible to handle the event and increment the processor program counter to «jump» over the failing instruction to continue the execution.
Overview
Example of human generated signal
A null pointer dereference on Windows 8
A segmentation fault occurs when a program attempts to access a memory location that it is not allowed to access, or attempts to access a memory location in a way that is not allowed (for example, attempting to write to a read-only location, or to overwrite part of the operating system).
The term «segmentation» has various uses in computing; in the context of «segmentation fault», a term used since the 1950s, it refers to the address space of a program.[citation needed] With memory protection, only the program’s own address space is readable, and of this, only the stack and the read/write portion of the data segment of a program are writable, while read-only data and the code segment are not writable. Thus attempting to read outside of the program’s address space, or writing to a read-only segment of the address space, results in a segmentation fault, hence the name.
On systems using hardware memory segmentation to provide virtual memory, a segmentation fault occurs when the hardware detects an attempt to refer to a non-existent segment, or to refer to a location outside the bounds of a segment, or to refer to a location in a fashion not allowed by the permissions granted for that segment. On systems using only paging, an invalid page fault generally leads to a segmentation fault, and segmentation faults and page faults are both faults raised by the virtual memory management system. Segmentation faults can also occur independently of page faults: illegal access to a valid page is a segmentation fault, but not an invalid page fault, and segmentation faults can occur in the middle of a page (hence no page fault), for example in a buffer overflow that stays within a page but illegally overwrites memory.
At the hardware level, the fault is initially raised by the memory management unit (MMU) on illegal access (if the referenced memory exists), as part of its memory protection feature, or an invalid page fault (if the referenced memory does not exist). If the problem is not an invalid logical address but instead an invalid physical address, a bus error is raised instead, though these are not always distinguished.
At the operating system level, this fault is caught and a signal is passed on to the offending process, activating the process’s handler for that signal. Different operating systems have different signal names to indicate that a segmentation fault has occurred. On Unix-like operating systems, a signal called SIGSEGV (abbreviated from segmentation violation) is sent to the offending process. On Microsoft Windows, the offending process receives a STATUS_ACCESS_VIOLATION exception.
Causes
The conditions under which segmentation violations occur and how they manifest themselves are specific to hardware and the operating system: different hardware raises different faults for given conditions, and different operating systems convert these to different signals that are passed on to processes. The proximate cause is a memory access violation, while the underlying cause is generally a software bug of some sort. Determining the root cause – debugging the bug – can be simple in some cases, where the program will consistently cause a segmentation fault (e.g., dereferencing a null pointer), while in other cases the bug can be difficult to reproduce and depend on memory allocation on each run (e.g., dereferencing a dangling pointer).
The following are some typical causes of a segmentation fault:
- Attempting to access a nonexistent memory address (outside process’s address space)
- Attempting to access memory the program does not have rights to (such as kernel structures in process context)
- Attempting to write read-only memory (such as code segment)
These in turn are often caused by programming errors that result in invalid memory access:
- Dereferencing a null pointer, which usually points to an address that’s not part of the process’s address space
- Dereferencing or assigning to an uninitialized pointer (wild pointer, which points to a random memory address)
- Dereferencing or assigning to a freed pointer (dangling pointer, which points to memory that has been freed/deallocated/deleted)
- A buffer overflow
- A stack overflow
- Attempting to execute a program that does not compile correctly. (Some compilers will output an executable file despite the presence of compile-time errors.)
In C code, segmentation faults most often occur because of errors in pointer use, particularly in C dynamic memory allocation. Dereferencing a null pointer will always result in a segmentation fault, but wild pointers and dangling pointers point to memory that may or may not exist, and may or may not be readable or writable, and thus can result in transient bugs. For example:
char *p1 = NULL; // Null pointer
char *p2; // Wild pointer: not initialized at all.
char *p3 = malloc(10 * sizeof(char)); // Initialized pointer to allocated memory
// (assuming malloc did not fail)
free(p3); // p3 is now a dangling pointer, as memory has been freed
Now, dereferencing any of these variables could cause a segmentation fault: dereferencing the null pointer generally will cause a segfault, while reading from the wild pointer may instead result in random data but no segfault, and reading from the dangling pointer may result in valid data for a while, and then random data as it is overwritten.
Что такое ошибка сегментации?
Ошибка сегментации, Segmentation fault, или Segfault, или SIGSEGV в Ubuntu и других Unix подобных дистрибутивах, означает ошибку работы с памятью. Когда вы получаете эту ошибку, это значит, что срабатывает системный механизм защиты памяти, потому что программа попыталась получить доступ или записать данные в ту часть памяти, к которой у нее нет прав обращаться.
Чтобы понять почему так происходит, давайте рассмотрим как устроена работа с памятью в Linux, я попытаюсь все упростить, но приблизительно так оно и работает.
Допустим, в вашей системе есть 6 Гигабайт оперативной памяти, каждой программе нужно выделить определенную область, куда будет записана она сама, ее данные и новые данные, которые она будет создавать. Чтобы дать возможность каждой из запущенных программ использовать все шесть гигабайт памяти был придуман механизм виртуального адресного пространства. Создается виртуальное пространство очень большого размера, а из него уже выделяется по 6 Гб для каждой программы. Если интересно, это адресное пространство можно найти в файле /proc/kcore, только не вздумайте никуда его копировать.
Выделенное адресное пространство для программы называется сегментом. Как только программа попытается записать или прочитать данные не из своего сегмента, ядро отправит ей сигнал SIGSEGV и программа завершится с нашей ошибкой. Более того, каждый сегмент поделен на секции, в некоторые из них запись невозможна, другие нельзя выполнять, если программа и тут попытается сделать что-то запрещенное, мы опять получим ошибку сегментации Ubuntu.
Additional Information
BackgroundModern general purpose hardware includes a «memory management unit» (or MMU). This hardware feature is used by operating systems like Linux to implement memory protection, i.e. to prevent different processes from accessing or modifying each other’s memory (except in a strictly controlled fashion through specific APIs). This simplifies troubleshooting and increases resilience as processes are carefully contained and separated from one another.A «segmentation violation» signal is sent to a process of which the memory management unit detected an attempt to use a memory address that does not belong to it.Common cause: programming errorIf a process tries to access memory through a pointer which has not been properly initialised, or which is pointing to memory that has previously been deallocated, this will likely result in a segfault. In this case, the segfault is occurring with a specific process or binary, possibly under a specific set of circumstances.To deal with this type of segfault, begin by applying all relevant service packs and maintenance updates. Next, if the problem is still reproducible with current code, try to capture an application core dump for analysis. Details for this are found in TID 3054866 — How to obtain application core dumps.If the problematic binary is shipped by Novell as part of the product, open a service request with Novell Technical services, supplying
- a description of the circumstances under which the core dump was generated,
- a supportconfig -v report for the affected system (supportconfig home page), and
- the core dump file itself, if smaller than 50 MB. If it is larger, wait for the service request to be assigned to an engineer and then work with the engineer to transfer it.
If the problematic binary was supplied by a third party, contact that party’s support department for assistance.Common cause: mismatched binary and librariesSegfaults can occur with processes that combine binaries and shared libraries which aren’t (fully) compatible. This can occur, for instance, when a library is updated in a way that changes the library’s ABI (application binary interface), but the library’s internal version number is not updated to reflect this. A binary that was built against an older version of the library may start to segfault when loaded against the newer version.This case may be difficult to recognise, and there is no step list for dealing with it. When this case is suspected, some things to consider are:
- Checking the system for file corruption (e.g. using the rpm-verify.txt file in a supportconfig -v report)
- Checking the system’s settings that relate to shared libraries, like the /etc/ld.so.conf and /etc/ld.so.conf.d/* configuration files and the LD_LIBRARY_PATH and LD_PRELOAD environment variables.
- Using the objdump tool to check the binary for a built-in library search path override (RPATH).
Common cause: hardware or hardware configuration issueWhen segfaults are occurring frequently, or with different processes or without a clear pattern to them, this can indicate that a system’s hardware (memory subsystem) is problematic, or that low-level system configuration settings are inappropriate. Please refer to TID 3301593 — Linux system hangs or is unstable for more information on how to handle this situation.
+ Upgrading to Open Enterprise Server 2 SP1 Linux
+ Open Enterprise Server 2 SP1 Migration Strategies
Examples
Segmentation fault on an EMV keypad
Writing to read-only memory
Writing to read-only memory raises a segmentation fault. At the level of code errors, this occurs when the program writes to part of its own code segment or the read-only portion of the data segment, as these are loaded by the OS into read-only memory.
Here is an example of ANSI C code that will generally cause a segmentation fault on platforms with memory protection. It attempts to modify a string literal, which is undefined behavior according to the ANSI C standard. Most compilers will not catch this at compile time, and instead compile this to executable code that will crash:
int main(void)
{
char *s = "hello world";
*s = 'H';
}
When the program containing this code is compiled, the string «hello world» is placed in the rodata section of the program executable file: the read-only section of the data segment. When loaded, the operating system places it with other strings and constant data in a read-only segment of memory. When executed, a variable, s, is set to point to the string’s location, and an attempt is made to write an H character through the variable into the memory, causing a segmentation fault. Compiling such a program with a compiler that does not check for the assignment of read-only locations at compile time, and running it on a Unix-like operating system produces the following runtime error:
$ gcc segfault.c -g -o segfault $ ./segfault Segmentation fault
Backtrace of the core file from GDB:
Program received signal SIGSEGV, Segmentation fault. 0x1c0005c2 in main () at segfault.c6 6 *s = 'H';
This code can be corrected by using an array instead of a character pointer, as this allocates memory on stack and initializes it to the value of the string literal:
char s[] = "hello world"; s = 'H'; // equivalently, *s = 'H';
Even though string literals should not be modified (this has undefined behavior in the C standard), in C they are of type, so there is no implicit conversion in the original code (which points a at that array), while in C++ they are of type, and thus there is an implicit conversion, so compilers will generally catch this particular error.
Null pointer dereference
In C and C-like languages, null pointers are used to mean «pointer to no object» and as an error indicator, and dereferencing a null pointer (a read or write through a null pointer) is a very common program error. The C standard does not say that the null pointer is the same as the pointer to memory address 0, though that may be the case in practice. Most operating systems map the null pointer’s address such that accessing it causes a segmentation fault. This behavior is not guaranteed by the C standard. Dereferencing a null pointer is undefined behavior in C, and a conforming implementation is allowed to assume that any pointer that is dereferenced is not null.
int *ptr = NULL;
printf("%d", *ptr);
This sample code creates a null pointer, and then tries to access its value (read the value). Doing so causes a segmentation fault at runtime on many operating systems.
Dereferencing a null pointer and then assigning to it (writing a value to a non-existent target) also usually causes a segmentation fault:
int *ptr = NULL; *ptr = 1;
The following code includes a null pointer dereference, but when compiled will often not result in a segmentation fault, as the value is unused and thus the dereference will often be optimized away by dead code elimination:
int *ptr = NULL; *ptr;
Stack overflow
Another example is recursion without a base case:
int main(void)
{
main();
return ;
}
which causes the stack to overflow which results in a segmentation fault. Infinite recursion may not necessarily result in a stack overflow depending on the language, optimizations performed by the compiler and the exact structure of a code. In this case, the behavior of unreachable code (the return statement) is undefined, so the compiler can eliminate it and use a tail call optimization that might result in no stack usage. Other optimizations could include translating the recursion into iteration, which given the structure of the example function would result in the program running forever, while probably not overflowing its stack.
я написал вот такую программку:
//includes
#include <iostream>
#include <chrono>
#include <string>
#include <ctime>
//namespaces
using namespace std;
using namespace chrono;
//defines
#define RETURN return 0
//main
int main() {
setlocale(LC_ALL,"ru"); //locale
const auto _BEFORE_ = high_resolution_clock::now(); //start timer (for time account)
srand(time(0));
//Create Array
int CountArrayIn_arr2D = 2;
int CountElementsIn_arr1D = 3;
int **arr2D = new int*[CountArrayIn_arr2D];
//Generate Array
for(int i = 0; i < CountArrayIn_arr2D; i++) {
for(int j = 0; j < CountElementsIn_arr1D; j++) {
arr2D[i][j] = rand() % 30 + 1;
}
}
//Print Array
for(int i = 0; i < CountArrayIn_arr2D; i++) {
for(int j = 0; j < CountElementsIn_arr1D; j++) {
cout<<"33[34m"<<arr2D[i][j]<<"33[0mt";
}
cout<<endl;
}
/*Clean memory*/
for(int i = 0; i < CountArrayIn_arr2D; i++) {
delete[] arr2D[i];
}
delete[] arr2D;
//time account
const auto _AFTER_ = high_resolution_clock::now();
const float TIME_FOR_PROGRAM = duration_cast<milliseconds>(_AFTER_-_BEFORE_).count();
cout<<"nn Programm completed in "<<TIME_FOR_PROGRAM<<"ms"<<endl;
RETURN;
}
и пишет: 
у меня 2 вопроса.
1) что значит стек сброшен на диск? на жесткий диск? удалится ли он самостоятельно? если нет то как удалить?
2) как это решить и почему это вообще произошло?
задан 29 окт 2019 в 14:44
Данил ПерелыгинДанил Перелыгин
1301 золотой знак1 серебряный знак8 бронзовых знаков
2
«Стек памяти сброшен на диск» — это [весьма-а вольный] перевод фразы «Core dumped». На диске в текущем каталоге создаётся файл с именем «core». Сам он не удалится, но он — самый обычный файл, который вы можете удалить когда захотите.
Файл core также сам по себе является кратчайшим путём к ответу на вопрос номер 2. Если ваш бинарник собран с опцией компилятора «-g», то вы можете запустить отладчик с командной строкой в виде «gdb -c core main.exe». Отладчик автоматически окажется на той строке, которая вызвала segmentation fault. О работе в gdb рекомендую почитать его документацию, она обширна и исчерпывающа.
ответ дан 29 окт 2019 в 15:03
user_587user_587
2,5321 золотой знак11 серебряных знаков20 бронзовых знаков
5
У вас явная ошибка работы с памятью. Вызов new происходит один раз, а вызов delete?
Здесь происходит выделение массива указателей на int:
int **arr2D = new int*[CountArrayIn_arr2D];
Чтобы получить двумерный массив, нужно еще в каждый указатель выделить свой блок памяти:
for (int i = 0; i < CountArrayIn_arr2D; i++)
{
arr2D[i] = new int[CountElementsIn_arr1D];
// ^^^^^^^
for (int j = 0; j < CountElementsIn_arr1D; j++)
{
// делаем что нужно
}
}
ответ дан 29 окт 2019 в 14:51
1
чел, ты забыл объявить элементы массивов в массиве)
ответ дан 29 окт 2019 в 14:55
- Печать
Страницы: [1] Вниз
Тема: Ошибка сегментирования (стек памяти сброшен на диск) [Решено] (Прочитано 10590 раз)
0 Пользователей и 1 Гость просматривают эту тему.
DANNNNN
Привет всем.
Есть программа. Она устанавливается из архива, который предварительно скачивается и после устанавливается.
Программа очень специфичная. Ты ей подсовываешь файл с командами, она его рассчитывает ( математического уклона программа) и выдаёт файл типа out.
И вот вчера при попытке запустить программу она выдаёт:
dan@dan-B450-AORUS-PRO:~/opt/2$ $GAUSS_EXEDIR/g16 NiFeSi2New33.inpЕстественно у меня всего один файл в папке из которой происходит запуск.
Unable to open input file "NiFeSi2New33.inp" or "NiFeSi2New33.inp".
Ошибка сегментирования (стек памяти сброшен на диск)
Что я делал. Я на создавал кучу входных файлов ( вот этот 3-ий был) и всё равно прога почему-то видит какой-то второй такой- же файл. 
Я обновлял Ubuntu, я перестановил программу поверх старой. Ничего не помогает(.
Помогите кто чем может.
« Последнее редактирование: 18 Марта 2020, 11:41:50 от zg_nico »
bezbo
Ошибка сегментирования (стек памяти сброшен на диск)
Ошибка сегментации, Segmentation fault, или Segfault, или SIGSEGV в Ubuntu и других Unix подобных дистрибутивах, означает ошибку работы с памятью. Когда вы получаете эту ошибку, это значит, что срабатывает системный механизм защиты памяти, потому что программа попыталась получить доступ или записать данные в ту часть памяти, к которой у нее нет прав обращаться.
Помогите кто чем может
вам остается только отправить отчет об ошибке разработчикам
или запустите программу отладчиком sudo gdb -q
ReNzRv
И вот вчера
До этого система обновлялась?
Автоматическое обновление системы включено в настройках?
DANNNNN
Проблема решилась(
Очень странно. Но я взял файл, который до этого запускался и немного изменил в неём параметры на те которые нужны. И всё заработало.
До этого файлы были созданы как копии того файла, который был создан на другом ПК и перенесён на этот комп через флэшку. Все копии этого файла и выдавали ошибку, не смотря на то, что некоторые из них также я переносил и на другие диски, там редактриовали переносил обратно.
Что это было- не понятно.
Короче ошибка в файле О_о.
Системе обновлялась конечно же.
P.S. До написание сюда я просидел часов 5 над проблемой.
« Последнее редактирование: 16 Ноября 2019, 10:18:29 от DANNNNN »
andytux
«Разруха в головах, а не в клозетах.»
перенесён на этот комп через флэшку. …Короче ошибка в файле
Права на файл.
- Печать
Страницы: [1] Вверх
|
# |
|
|
Темы: 11 Сообщения: 114 Участник с: 30 ноября 2018 |
показывает 0-3
скачал поставил, пишет «Недопустимая инструкция (стек памяти сброшен на диск)» |
|
vs220 |
# |
|
Темы: 22 Сообщения: 8100 Участник с: 16 августа 2009 |
Да, и новая версия и старая( откат на 30.04)
Можно глянуть лог пакмана /var/log/pacman.log. Если помните после какого обновления перестал работать. В крайнем случае можно откатить систему на нужное число |
|
vasek |
# (отредактировано 2 года, 11 месяцев назад) |
|
Темы: 47 Сообщения: 11588 Участник с: 17 февраля 2013 |
Проверил, blender работает нормально и проблема не в самом пакете, а проблема возможно аппаратная — проверь, поддерживает ли процессор инструкции sse4.1 если в выводе не будет красного текста, значит не поддерживает, тогда пробуй откатить openimagedenoise, как отмечено в Bug Report PS — но сначала рекомендую подчистить свои эксперименты с откатами — # pacman -Rsn blender … возможно придется подчистить в ручную и установить по новой Ошибки не исчезают с опытом — они просто умнеют |
|
Mutagen |
# (отредактировано 2 года, 11 месяцев назад) |
|
Темы: 11 Сообщения: 114 Участник с: 30 ноября 2018 |
вот лог того обновления
|
|
vs220 |
# |
|
Темы: 22 Сообщения: 8100 Участник с: 16 августа 2009 |
Попробуйте как vasek говорит откатить openimagedenoise |
|
Mutagen |
# |
|
Темы: 11 Сообщения: 114 Участник с: 30 ноября 2018 |
не поддерживает
заработало P.S. пора обновлять железо( |
я написал вот такую программку:
//includes
#include <iostream>
#include <chrono>
#include <string>
#include <ctime>
//namespaces
using namespace std;
using namespace chrono;
//defines
#define RETURN return 0
//main
int main() {
setlocale(LC_ALL,"ru"); //locale
const auto _BEFORE_ = high_resolution_clock::now(); //start timer (for time account)
srand(time(0));
//Create Array
int CountArrayIn_arr2D = 2;
int CountElementsIn_arr1D = 3;
int **arr2D = new int*[CountArrayIn_arr2D];
//Generate Array
for(int i = 0; i < CountArrayIn_arr2D; i++) {
for(int j = 0; j < CountElementsIn_arr1D; j++) {
arr2D[i][j] = rand() % 30 + 1;
}
}
//Print Array
for(int i = 0; i < CountArrayIn_arr2D; i++) {
for(int j = 0; j < CountElementsIn_arr1D; j++) {
cout<<"33[34m"<<arr2D[i][j]<<"33[0mt";
}
cout<<endl;
}
/*Clean memory*/
for(int i = 0; i < CountArrayIn_arr2D; i++) {
delete[] arr2D[i];
}
delete[] arr2D;
//time account
const auto _AFTER_ = high_resolution_clock::now();
const float TIME_FOR_PROGRAM = duration_cast<milliseconds>(_AFTER_-_BEFORE_).count();
cout<<"nn Programm completed in "<<TIME_FOR_PROGRAM<<"ms"<<endl;
RETURN;
}
и пишет:
у меня 2 вопроса.
1) что значит стек сброшен на диск? на жесткий диск? удалится ли он самостоятельно? если нет то как удалить?
2) как это решить и почему это вообще произошло?
Ответы (3 шт):
У вас явная ошибка работы с памятью. Вызов new происходит один раз, а вызов delete?
Здесь происходит выделение массива указателей на int:
int **arr2D = new int*[CountArrayIn_arr2D];
Чтобы получить двумерный массив, нужно еще в каждый указатель выделить свой блок памяти:
for (int i = 0; i < CountArrayIn_arr2D; i++)
{
arr2D[i] = new int[CountElementsIn_arr1D];
// ^^^^^^^
for (int j = 0; j < CountElementsIn_arr1D; j++)
{
// делаем что нужно
}
}
→ Ссылка
Автор решения: Alexander Prokoshev
«Стек памяти сброшен на диск» — это [весьма-а вольный] перевод фразы «Core dumped». На диске в текущем каталоге создаётся файл с именем «core». Сам он не удалится, но он — самый обычный файл, который вы можете удалить когда захотите.
Файл core также сам по себе является кратчайшим путём к ответу на вопрос номер 2. Если ваш бинарник собран с опцией компилятора «-g», то вы можете запустить отладчик с командной строкой в виде «gdb -c core main.exe». Отладчик автоматически окажется на той строке, которая вызвала segmentation fault. О работе в gdb рекомендую почитать его документацию, она обширна и исчерпывающа.
→ Ссылка
Здравствуйте. Помогите пожалуйста. Есть ноутбук:
OS: Fedora 33 (Workstation Edition) x86_64
Host: 80XR Lenovo ideapad 320-15IAP
Kernel: 5.9.12-200.fc33.x86_64
Packages: 2713 (rpm), 6 (flatpak)
Shell: bash 5.0.17
Resolution: 1366×768
DE: GNOME 3.38.2
Terminal: gnome-terminal
CPU: Intel Pentium N4200 (4) @ 2.500GHz
GPU: AMD ATI Radeon R7 M260/M265 / M340/M360 / M440/M445 / 530/535 / 620/625 Mobile
GPU: Intel Celeron N3350/Pentium N4200/Atom E3900 Series
Memory: 1069MiB / 3752MiB
После очередного включения, как я понял после небольшого обновления, начала появляться ошибка: Ошибка сегментирования (стек памяти сброшен на диск).
Появляется она в терминале после любой команды содержавшую SUDO. Тоесть то немногое что я за гуглил по этой ошибке, я не могу использовать.
Стандартные примеры для QT5/webengine вызывают ошибку сегментирования .
Диагностика
- Добавить в проект флаг
export QT_DEBUG_PLUGINS=1. - Запустить ПО с помощью отладчика
gdb. -
Проверить
traceна наличие следующей записи:loaded library "/usr/lib/x86_64-linux-gnu/qt5/qml/QtWebEngine/libqtwebengineplugin.so" QFactoryLoader::QFactoryLoader() checking directory path "/usr/lib/x86_64-linux-gnu/qt5/plugins/accessiblebridge" ... QFactoryLoader::QFactoryLoader() checking directory path "/home/sa/prj/webengine/build-minimal-Desktop-Debug/accessiblebridge" ... Ошибка сегментирования (стек памяти сброшен на диск)CODE
Возможные причины
This error may strike your Ubuntu at any point at the moment. A few days ago when I was doing my routine work in my Ubuntu laptop, suddenly I encountered with an error “Segmentation fault ( core dumped)” then I got to know that, this error can strike you Ubuntu or any other operating system at any point of the moment as binaries crashing doesn’t depend on us.
Segmentation fault is when your system tries to access a page of memory that doesn’t exist. Core dumped means when a part of code tries to perform read and write operation on a read-only or free location. Segfaults are generally associated with the file named core and It generally happens during up-gradation.
While running some commands during the core-dump situation you may encounter with “Unable to open lock file” this is because the system is trying to capture a bit block which is not existing, This is due to the crashing of binaries of some specific programs.
You may do backtracking or debugging to resolve it but the solution is to repair the broken packages and we can do it by performing the below-mentioned steps:
Command-line:
Step 1: Remove the lock files present at different locations.
sudo rm -rf /var/lib/apt/lists/lock /var/cache/apt/archives/lock /var/lib/dpkg/lock and restart your system h.cdccdc
Step 2: Remove repository cache.
Step 3: Update and upgrade your repository cache.
sudo apt-get update && sudo apt-get upgrade
Step 4: Now upgrade your distribution, it will update your packages.
sudo apt-get dist-upgrade
Step 5: Find the broken packages and delete them forcefully.
sudo dpkg -l | grep ^..r | apt-get purge
Apart from the command line, the best way which will always work is:
Step 1: Run Ubuntu in startup mode by pressing the Esc key after the restart.
Step 2: Select Advanced options for Ubuntu
Step 3: Run Ubuntu in the recovery mode and you will be listed with many options.
Step 4: First select “Repair broken packages”
Step 5: Then select “Resume normal boot”
So, we have two methods of resolving segmentation fault: CLI and the GUI. Sometimes, it may also happen that the “apt” command is not working because of segfault, so our CLI method will not work, in that case also don’t worry as the GUI method gonna work for us always.