Ошибка сегментации сброшено ядро

A segmentation fault (sometimes known as a segfault) happens when your program tries to access memory that it is not permitted to access.In other words, when your program attempts to access memory that exceeds the boundaries set by the operating system for your program.And it is a common circumstance that causes programs to crash; it is frequently related with a file called core.

Program memory is divided into different segments:

• a text segment for program instructions
• a data segment for variables and arrays defined at compile time
• a stack segment for temporary (or automatic) variables defined in subroutines and functions
• a heap segment for variables allocated during runtime by functions, such as malloc (in C) and allocate (in Fortran).

When a reference to a variable falls beyond the segment where that variable exists, or when a write is attempted to a place that is in a read-only segment, a segfault occurs. In reality, segfaults are nearly typically caused by attempting to read or write a non-existent array member, failing to correctly define a pointer before using it, or (in C applications) inadvertently using the value of a variable as an address (see the scan example below).

*Calling memset(), for example, would cause a program to segfault:

memset((char *)0x0, 1, 100);

*The three examples below show the most frequent sorts of array-related segfaults:

Case A

/* "Array out of bounds" error valid indices for array foo are 0, 1, ... 999 */
int foo[1000]; for (int i = 0; i <= 1000 ; i++) foo[i] = i;

Case B

/* Illegal memory access if value of n is not in the range 0, 1, ... 999 */ 
int n; int foo[1000]; for (int i = 0; i < n ; i++) foo[i] = i;

Case C

/* Illegal memory access because no memory is allocated for foo2 */
float *foo, *foo2; foo = (float*)malloc(1000); foo2[0] = 1.0;

• In case A, array foo is defined for index = 0, 1, 2, … 999. However, in the last iteration of the for loop, the program tries to access foo[1000]. This will result in a segfault if that memory location lies outside the memory segment where foo resides. Even if it doesn’t cause a segfault, it is still a bug.
• In case B, integer n could be any random value. As in case A, if it is not in the range 0, 1, … 999, it might cause a segfault. Whether it does or not, it is certainly a bug.
• In case C, allocation of memory for variable foo2 has been overlooked, so foo2 will point to a random location in memory. Accessing foo2[0] will likely result in a segfault.

*Another typical programming issue that causes segfaults is a failure to use pointers properly. The C function scanf(), for example, requires the address of a variable as its second parameter; hence, the following will very certainly cause the program to fail with a segfault:

int foo = 0; scanf("%d", foo); 
/* Note missing & sign ; correct usage would have been &foo */

Although the variable foo may be created at memory position 1000, the preceding function call would attempt to read integer values into memory location 0 in accordance with the definition of foo.

A segfault occurs when a software attempts to operate on a memory region in an unauthorized manner (for example, attempts to write a read-only location would result in a segfault).When your application runs out of stack space, segfaults can occur. This might be due to your shell setting the stack size limit too low, rather than a fault in your software.

Dangling Pointers point to something that no longer exists.
A dangling pointer is an example of this.

char *ptr = NULL;
{
char c;
ptr = &c; //After the block is over, ptr will be a dangling pointer.
}

When the block concludes, the scope of variable c expires. Because it now points to something that doesn’t exist, the ‘ptr’ will become a dangling pointer.

But when you try to access memory that doesn’t belong to you or when you try to write to a read-only area, you get a segmentation fault.

char *str ="Testing Seg fault.";
*str= "I hate Seg fault :( ";

The’str’ will be made a constant by the compiler. You are altering the read-only part when you try to update the value, resulting in a segmentation fault.So there’s a clear distinction between a segmentation fault and dangling pointers.

A segmentation fault (sometimes known as a segfault) happens when your program tries to access memory that it is not permitted to access.In other words, when your program attempts to access memory that exceeds the boundaries set by the operating system for your program.And it is a common circumstance that causes programs to crash; it is frequently related with a file called core.

Program memory is divided into different segments:

• a text segment for program instructions
• a data segment for variables and arrays defined at compile time
• a stack segment for temporary (or automatic) variables defined in subroutines and functions
• a heap segment for variables allocated during runtime by functions, such as malloc (in C) and allocate (in Fortran).

When a reference to a variable falls beyond the segment where that variable exists, or when a write is attempted to a place that is in a read-only segment, a segfault occurs. In reality, segfaults are nearly typically caused by attempting to read or write a non-existent array member, failing to correctly define a pointer before using it, or (in C applications) inadvertently using the value of a variable as an address (see the scan example below).

*Calling memset(), for example, would cause a program to segfault:

memset((char *)0x0, 1, 100);

*The three examples below show the most frequent sorts of array-related segfaults:

Case A

/* "Array out of bounds" error valid indices for array foo are 0, 1, ... 999 */
int foo[1000]; for (int i = 0; i <= 1000 ; i++) foo[i] = i;

Case B

/* Illegal memory access if value of n is not in the range 0, 1, ... 999 */ 
int n; int foo[1000]; for (int i = 0; i < n ; i++) foo[i] = i;

Case C

/* Illegal memory access because no memory is allocated for foo2 */
float *foo, *foo2; foo = (float*)malloc(1000); foo2[0] = 1.0;

• In case A, array foo is defined for index = 0, 1, 2, … 999. However, in the last iteration of the for loop, the program tries to access foo[1000]. This will result in a segfault if that memory location lies outside the memory segment where foo resides. Even if it doesn’t cause a segfault, it is still a bug.
• In case B, integer n could be any random value. As in case A, if it is not in the range 0, 1, … 999, it might cause a segfault. Whether it does or not, it is certainly a bug.
• In case C, allocation of memory for variable foo2 has been overlooked, so foo2 will point to a random location in memory. Accessing foo2[0] will likely result in a segfault.

*Another typical programming issue that causes segfaults is a failure to use pointers properly. The C function scanf(), for example, requires the address of a variable as its second parameter; hence, the following will very certainly cause the program to fail with a segfault:

int foo = 0; scanf("%d", foo); 
/* Note missing & sign ; correct usage would have been &foo */

Although the variable foo may be created at memory position 1000, the preceding function call would attempt to read integer values into memory location 0 in accordance with the definition of foo.

A segfault occurs when a software attempts to operate on a memory region in an unauthorized manner (for example, attempts to write a read-only location would result in a segfault).When your application runs out of stack space, segfaults can occur. This might be due to your shell setting the stack size limit too low, rather than a fault in your software.

Dangling Pointers point to something that no longer exists.
A dangling pointer is an example of this.

char *ptr = NULL;
{
char c;
ptr = &c; //After the block is over, ptr will be a dangling pointer.
}

When the block concludes, the scope of variable c expires. Because it now points to something that doesn’t exist, the ‘ptr’ will become a dangling pointer.

But when you try to access memory that doesn’t belong to you or when you try to write to a read-only area, you get a segmentation fault.

char *str ="Testing Seg fault.";
*str= "I hate Seg fault :( ";

The’str’ will be made a constant by the compiler. You are altering the read-only part when you try to update the value, resulting in a segmentation fault.So there’s a clear distinction between a segmentation fault and dangling pointers.

29.12.2019C, C++

Вопрос:

Program received signal SIGSEGV, Segmentation fault.
0x08048edb in state_update2 () at xxx.cpp:333
333     if (rob.head->is_complete == 1 && rob.head->ready_to_retire == 1 )

    if(rob.head->is_complete == 1 && rob.head->ready_to_retire == 1) {
reorder_buffer_node *temp = new reorder_buffer_node[sizeof(struct reorder_buffer_node)];
temp = rob.head;
for(uint64_t i=0; i<f_; i++) {
if(temp->is_complete == 1 && temp->ready_to_retire == 1) {
rob.pop();
retired_inst++;
temp = temp->next;
}
else break;
}
}

struct reorder_buffer_node {
int is_complete;
uint64_t instr_num;
uint64_t dest_reg;
uint64_t index;
reorder_buffer_node *next;
int ready_to_retire;
};

Ответ №1

reorder_buffer_node *temp = new reorder_buffer_node[sizeof(struct reorder_buffer_node)];

temp = rob.head;

temp = temp->next;

Ответ №2

reorder_buffer_node *temp = new reorder_buffer_node[sizeof(struct reorder_buffer_node)];
temp = rob.head;

int temp = 15;
temp = 5;

Ответ №3

if(rob.head->is_complete == 1 && rob.head->ready_to_retire == 1)

Хотя комментарии Weather Vane и yano верны, эти ошибки вряд ли вызовут ошибки сегментации:

1. Вы все еще можете получить доступ к памяти локальных переменных в C после выхода из функции, вы просто не можете гарантировать, что данные будут действительными.

   Локальные переменные выделяются в стеке, поэтому сам адрес останется действительным для процесса.

2. Строка нулевой длины «» по-прежнему занимает массив длиной 1 в C из-за завершающего символа 0.
   Кроме того, превышение границ локального массива в C не обязательно вызовет ошибку seg, в зависимости от структуры памяти функции.

Что гарантированно устранит ошибку сегментации, так это эта строка:
int password_comparison = strcmp(«090097099104082111104105116104083097109050048049056101104099115067104117114099104079102069109097099115095095», password_input);

В вашем коде password_input имеет тип char и, предположительно, содержит значение, которое гарантированно находится в диапазоне от -127 до 127.

Но strcmp будет рассматривать его как указатель — адрес в памяти от 0 до 255.

Адреса в этом диапазоне недействительны, поэтому, когда strcmp пытается его прочитать, это всегда вызывает ошибку сегментации.

C язык, неисправность сегментации (ядро сбрасывается)Быть неправым

Причиной:Ошибка абзаца заключается в том, что память доступа находится вне пространства памяти для программы к этой программе. Как правило, свободно использовать дикие указатели или массивы, массивные кресты.

Метод позиционирования:

    1Используя отладку оператора вывода, обычно используемые в отладке одного документа, где указатель используется для использования неправильного места для выходных операторов, сprintf(“%dn”, __LINE__); Последнее количество печатных строк — это количество возникающих рядов.

(Возьмите это в качестве примера)

(Последняя строка печати — это 7-я строка, доказательство Программа неверна в 8-й строке)

    2,использоватьgdbВвод в эксплуатацию, обычно используемый в мульти-документе отладки,gcc x.c -o x

                                                        gdb x

                                                        run

Затем постоянно входитеrun+Введите, остановитесь при работе в случае ошибки абзацаrunИ расположена в строке документа, изменение является передней линейкой ошибки абзаца.

(Последняя строка печати — это 7-я строка, доказательство Программа неверна в 8-й строке)

Метод отладки решения:Адрес указателя, используемого в переднем ряду ошибки произошел, как показано на рисунке, адрес указателяnilПредставляя дикий указатель указателя, использование дикого указателя определенно является абзацем!

Это мое понимание абзацев, если есть лучший путь или неправильное место, пожалуйста, отдайте это.

Segmentation fault (core dumped)

  class Workspace(QMainWindow, Ui_MainWindow):
    """ This class is for managing the whole GUI `Workspace'.
        Currently a Workspace is similar to a MainWindow
    """

    def __init__(self):
        #p= subprocess.Popen(["java -Xmx256m -jar bin/HelloWorld.jar"],cwd=r'/home/karen/sphinx4-1.0beta5-src/sphinx4-1.0beta5/', shell=True, stdout=subprocess.PIPE, bufsize= 4024)
        try:
            from Queue import Queue, Empty
        except ImportError:
            while True:
    #from queue import Queue, Empty  # python 3.x
                print "error"

        ON_POSIX = 'posix' in sys.builtin_module_names

        def enqueue_output(out, queue):
            for line in iter(out.readline, b''):
                queue.put(line)
            out.close()

        p= Popen(["java -Xmx256m -jar bin/HelloWorld.jar"],cwd=r'/home/karen/sphinx4-1.0beta5-src/sphinx4-1.0beta5/',stdout=PIPE, shell=True, bufsize= 4024)
        q = Queue()
        t = threading.Thread(target=enqueue_output, args=(p.stdout, q))
        #t = Thread(target=enqueue_output, args=(p.stdout, q))
        t.daemon = True # thread dies with the program
        t.start()

# ... do other things here
        def myfunc(q):
            while True:

                try: line = q.get_nowait()
         # or q.get(timeout=.1)
                except Empty:
                    print('Vacio')
                else: # got line
    # ... do something with line

                    print line  


        thread = threading.Thread(target=myfunc, args=(q,))
        thread.start()

6 ответов

Лучший ответ

faulthandler.enable()
// bad code goes here

$ python3 -q -X faulthandler
>>> /// bad cod goes here

TL: DR: используйте gcc -m32.

.code32 делает not изменение формата выходного файла, и именно это определяет режим, в котором будет работать ваша программа. вам не нужно запускать 32-битный код в режиме 64 бит. .code32 предназначен для сборки «чужого» машинного кода, который может потребоваться в качестве данных, или для экспорта в сегменте общей памяти. Если это не то, что вы делаете, избегайте его, чтобы получить ошибки времени сборки, когда вы создаете .S в неправильном режиме, если у него есть, например, команды push или pop.

Предложение: используйте расширение .S для рукописного ассемблера. (gcc foo.S будет запускать его через препроцессор C до as, поэтому вы можете #include заголовок с номерами системного вызова, например). Кроме того, он отличает его от выхода компилятора .s (от gcc foo.c -O3 -S).

Чтобы создать 32-битные двоичные файлы, используйте одну из этих команд

gcc -g foo.S -o foo -m32 -nostdlib -static  # static binary with absolutely no libraries or startup code
                       # -nostdlib by itself makes static executables on Linux, but not OS X.

gcc -g foo.S -o foo -m32                  # dynamic binary including the startup boilerplate code.  Use with code that defines a main() but not a _start

Документация для nostdlib, -nostartfiles и -static .

Использование функций libc из _start (см. конец этого ответа для примера)

Некоторые функции, такие как функции malloc(3) или stdio, включая printf(3), зависят от инициализации некоторых глобальных данных (например, FILE *stdout и объекта, на который он фактически указывает).

gcc -nostartfiles оставляет из кода шаблона CRT _start, но все же ссылки libc (динамически, по умолчанию). В Linux общие библиотеки могут иметь разделы инициализатора, которые запускаются динамическим компоновщиком, когда он загружает их, прежде чем переходить к вашей точке входа _start. Таким образом, gcc -nostartfiles hello.S все еще позволяет вам называть printf. Для динамического исполняемого файла ядро ​​запускает на нем /lib/ld-linux.so.2 вместо его непосредственного использования (используйте readelf -a, чтобы увидеть строку «ELF интерпретатор» в вашем двоичном файле). Когда ваш _start в конечном итоге будет запущен, не все регистры будут обнулены, потому что динамический компоновщик выполнил код в вашем процессе.

Однако gcc -nostartfiles -static hello.S свяжется, но сбой во время выполнения, если вы вызываете printf или что-то, не вызывая внутренние функции init glibc. (см. комментарий Майкла Пётча).

Конечно, вы можете поместить любую комбинацию файлов .c, .S и .o в одну и ту же командную строку, чтобы связать их все в один исполняемый файл , Если у вас есть C, не забудьте -Og -Wall -Wextra: вы не хотите отлаживать ваш asm, когда проблема была чем-то простым в C, который вызывает это, о котором мог бы предупредить компилятор.

Используйте -v, чтобы gcc показывал вам команды, которые он запускает для сборки и соединения. Для этого «вручную»:

as foo.S -o foo.o -g --32 &&      # skips the preprocessor
ld -o foo foo.o  -m elf_i386

file foo
foo: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, not stripped

gcc -nostdlib -m32 легче запомнить и ввести, чем два разных варианта для as и ld (--32 и -m elf_i386). Кроме того, он работает на всех платформах, включая те, где исполняемый формат не является ELF. (Но примеры Linux не будут работать в OS X, потому что номера системных вызовов различны или в Windows, потому что в нем даже не используется int 0x80 ABI.)

NASM / YASM

gcc не может обрабатывать синтаксис NASM. (-masm=intel больше похож на MASM, чем на синтаксис NASM, где вам нужно offset symbol, чтобы получить адрес как немедленный). И, конечно, директивы различны (например, .globl vs global).

Вы можете построить с помощью nasm или yasm , затем свяжите .o с gcc, как указано выше, или ld напрямую.

Я использую сценарий оболочки, чтобы избежать повторного ввода одного и того же имени файла с тремя разными расширениями. (nasm и yasm по умолчанию file.asm -> file.o, в отличие от вывода GNU as по умолчанию a.out). Используйте это с помощью -m32, чтобы собрать и связать 32-разрядные исполняемые файлы ELF. Не все ОС используют ELF, поэтому этот скрипт менее переносим, ​​чем использование gcc -nostdlib -m32 для ссылки будет ..

#!/bin/sh
# usage: asm-link [-q] [-m32] foo.asm  [assembler options ...]
# Just use a Makefile for anything non-trivial.  This script is intentionally minimal and doesn't handle multiple source files

verbose=1                       # defaults
fmt=-felf64
#ldopt=-melf_i386

while getopts 'm:vq' opt; do
    case "$opt" in
        m)  if [ "m$OPTARG" = "m32" ]; then
                fmt=-felf32
                ldopt=-melf_i386
            fi
            if [ "m$OPTARG" = "mx32" ]; then
                fmt=-felfx32
                ldopt=-melf32_x86_64
            fi
            # default is -m64
            ;;
        q)  verbose=0 ;;
        v)  verbose=1 ;;
    esac
done
shift "$((OPTIND-1))"   # Shift off the options and optional --

src=$1
base=${src%.*}
shift

[ "$verbose" = 1 ] && set -x    # print commands as they're run, like make

#yasm "$fmt" -Worphan-labels -gdwarf2 "$src" "$@" &&
nasm "$fmt" -Worphan-labels -g -Fdwarf "$src" "$@" &&
    ld $ldopt -o "$base" "$base.o"

# yasm -gdwarf2 includes even .local labels so they show up in objdump output
# nasm defaults to that behaviour of including even .local labels

# nasm defaults to STABS debugging format, but -g is not the default

Я предпочитаю yasm по нескольким причинам, в том числе по умолчанию для создания long- nop s вместо заполнения со многими однобайтными nop s. Это приводит к беспорядочному выводу разборки, а также к замедлению, если nops когда-либо выполняются. (В NASM вам необходимо использовать макрос smartalign.)

Пример: программа, использующая функции libc из _start

# hello32.S

#include <asm/unistd_32.h>   // syscall numbers.  only #defines, no C declarations left after CPP to cause asm syntax errors

.text
#.global main   # uncomment these to let this code work as _start, or as main called by glibc _start
#main:
#.weak _start

.global _start
_start:
        mov     $__NR_gettimeofday, %eax  # make a syscall that we can see in strace output so we know when we get here
        int     $0x80

        push    %esp
        push    $print_fmt
        call   printf

        #xor    %ebx,%ebx                 # _exit(0)
        #mov    $__NR_exit_group, %eax    # same as glibc's _exit(2) wrapper
        #int    $0x80                     # won't flush the stdio buffer

        movl    $0, (%esp)   # reuse the stack slots we set up for printf, instead of popping
        call    exit         # exit(3) does an fflush and other cleanup

        #add    $8, %esp     # pop the space reserved by the two pushes
        #ret                 # only works in main, not _start

.section .rodata
print_fmt: .asciz "Hello, World!n%%esp at startup = %#lxn"

$ gcc -m32 -nostdlib hello32.S
/tmp/ccHNGx24.o: In function `_start':
(.text+0x7): undefined reference to `printf'
...
$ gcc -m32 hello32.S
/tmp/ccQ4SOR8.o: In function `_start':
(.text+0x0): multiple definition of `_start'
...

Не работает во время выполнения, потому что ничего не вызывает функции glibc init. (__libc_init_first, __dl_tls_setup и __libc_csu_init в этом порядке, в соответствии с комментарием Майкла Пётча. Существуют и другие реализации libc, в том числе MUSL , который предназначен для статической компоновки и работает без вызовов инициализации .)

$ gcc -m32 -nostartfiles -static hello32.S     # fails at run-time
$ file a.out
a.out: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, BuildID[sha1]=ef4b74b1c29618d89ad60dbc6f9517d7cdec3236, not stripped
$ strace -s128 ./a.out
execve("./a.out", ["./a.out"], [/* 70 vars */]) = 0
[ Process PID=29681 runs in 32 bit mode. ]
gettimeofday(NULL, NULL)                = 0
--- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=0} ---
+++ killed by SIGSEGV (core dumped) +++
Segmentation fault (core dumped)

Вы также можете gdb ./a.out и запустить b _start, layout reg, run и посмотреть, что произойдет.

$ gcc -m32 -nostartfiles hello32.S             # Correct command line
$ file a.out
a.out: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, BuildID[sha1]=7b0a731f9b24a77bee41c13ec562ba2a459d91c7, not stripped

$ ./a.out
Hello, World!
%esp at startup = 0xffdf7460

$ ltrace -s128 ./a.out > /dev/null
printf("Hello, World!n%%esp at startup = %#lxn", 0xff937510)      = 43    # note the different address: Address-space layout randomization at work
exit(0 <no return ...>
+++ exited (status 0) +++

$ strace -s128 ./a.out > /dev/null        # redirect stdout so we don't see a mix of normal output and trace output
execve("./a.out", ["./a.out"], [/* 70 vars */]) = 0
[ Process PID=29729 runs in 32 bit mode. ]
brk(0)                                  = 0x834e000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
....   more syscalls from dynamic linker code
open("/lib/i386-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
mmap2(NULL, 1814236, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xfffffffff7556000    # map the executable text section of the library
... more stuff
# end of dynamic linker's code, finally jumps to our _start

gettimeofday({1461874556, 431117}, NULL) = 0
fstat64(1, {st_mode=S_IFCHR|0666, st_rdev=makedev(1, 3), ...}) = 0  # stdio is figuring out whether stdout is a terminal or not
ioctl(1, SNDCTL_TMR_TIMEBASE or SNDRV_TIMER_IOCTL_NEXT_DEVICE or TCGETS, 0xff938870) = -1 ENOTTY (Inappropriate ioctl for device)
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xfffffffff7743000      # 4k buffer for stdout
write(1, "Hello, World!n%esp at startup = 0xff938fb0n", 43) = 43
exit_group(0)                           = ?
+++ exited with 0 +++

Если бы мы использовали _exit(0) или сделали систему sys_exit называть себя int 0x80, , то write(2) не было бы . Если stdout перенаправлен на не-tty, по умолчанию он заполняется с полным буфером (не с буферизацией строки), поэтому write(2) запускается только fflush(3) как часть exit(3). Без перенаправления вызов printf(3) со строкой, содержащей символы новой строки, будет немедленно скрыт.

Поведение в зависимости от того, является ли stdout терминалом, может быть желательно, но только если вы делаете это специально, а не по ошибке.