捕捉信号SIGSEGV并回溯栈帧backtrace

最新推荐文章于 2025-10-29 16:21:24 发布
转载 最新推荐文章于 2025-10-29 16:21:24 发布 · 2k 阅读 · 8
文章标签：

#回溯栈帧 #backtrace #Segmentation Fault

本文介绍了一种在嵌入式及X86平台下捕捉SIGSEGV信号并打印函数栈帧链的方法，帮助开发者快速定位段错误来源。通过深入剖析栈帧原理及具体代码实现细节，为调试提供有力支持。

引出问题

在嵌入式应用程序开发过程中，调试一直是个老大难问题 -- 由于环境的限制，当程序发生段错误时不能很好的定位到底是哪里出现了错误，如果在程序发生段错误时能够清晰明了地看到程序的栈帧链，那无疑是雪中送炭。本文就捕捉信号SIGSEGV并在该信号的处理函数中打印出函数栈帧链来帮助我们调试程序。

本文的程序适合ARM和X86平台。

回溯栈帧原理

理解函数栈帧的布局后，那么自然明白回溯栈帧的原理了，这里不多解释了，直接上图（来自网络）：

                                                                 x86函数栈帧结构

 

                                                                ARM函数栈帧结构

代码sigsegv.c

[cpp]  view plain  copy
 print ? 在CODE上查看代码片 派生到我的代码片
  1. #ifndef _GNU_SOURCE  
  2.     #define _GNU_SOURCE  
  3. #endif  
  4. #include <stdio.h>  
  5. #include <dlfcn.h>  
  6. #include <stdlib.h>  
  7. #include <signal.h>  
  8. #include <unistd.h>  
  9. #include <string.h>  
  10. #include <ucontext.h>  
  11.   
  12.   
  13. /* 纯C环境下，不定义宏NO_CPP_DEMANGLE */  
  14. #if (!defined(__cplusplus)) && (!defined(NO_CPP_DEMANGLE))  
  15. #define NO_CPP_DEMANGLE  
  16. #endif  
  17.   
  18. #ifndef NO_CPP_DEMANGLE  
  19.     #include <cxxabi.h>  
  20.     #ifdef __cplusplus  
  21.         using __cxxabiv1::__cxa_demangle;  
  22.     #endif  
  23. #endif  
  24.   
  25. #ifdef HAS_ULSLIB  
  26.     #include <uls/logger.h>  
  27.     #define sigsegv_outp(x) sigsegv_outp(, gx)  
  28. #else  
  29.     #define sigsegv_outp(x, ...)    fprintf(stderr, x"\n", ##__VA_ARGS__)  
  30. #endif  
  31.   
  32. #if (defined __x86_64__)  
  33.     #define REGFORMAT   "%016lx"      
  34. #elif (defined __i386__)  
  35.     #define REGFORMAT   "%08x"  
  36. #elif (defined __arm__)  
  37.     #define REGFORMAT   "%lx"  
  38. #endif  
  39.   
  40. static void print_reg(ucontext_t *uc)   
  41. {  
  42. #if (defined __x86_64__) || (defined __i386__)  
  43.     int i;  
  44.     for (i = 0; i < NGREG; i++) {  
  45.         sigsegv_outp("reg[%02d]: 0x"REGFORMAT, i, uc->uc_mcontext.gregs[i]);  
  46.     }  
  47. #elif (defined __arm__)  
  48.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 0, uc->uc_mcontext.arm_r0);  
  49.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 1, uc->uc_mcontext.arm_r1);  
  50.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 2, uc->uc_mcontext.arm_r2);  
  51.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 3, uc->uc_mcontext.arm_r3);  
  52.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 4, uc->uc_mcontext.arm_r4);  
  53.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 5, uc->uc_mcontext.arm_r5);  
  54.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 6, uc->uc_mcontext.arm_r6);  
  55.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 7, uc->uc_mcontext.arm_r7);  
  56.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 8, uc->uc_mcontext.arm_r8);  
  57.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 9, uc->uc_mcontext.arm_r9);  
  58.     sigsegv_outp("reg[%02d]     = 0x"REGFORMAT, 10, uc->uc_mcontext.arm_r10);  
  59.     sigsegv_outp("FP        = 0x"REGFORMAT, uc->uc_mcontext.arm_fp);  
  60.     sigsegv_outp("IP        = 0x"REGFORMAT, uc->uc_mcontext.arm_ip);  
  61.     sigsegv_outp("SP        = 0x"REGFORMAT, uc->uc_mcontext.arm_sp);  
  62.     sigsegv_outp("LR        = 0x"REGFORMAT, uc->uc_mcontext.arm_lr);  
  63.     sigsegv_outp("PC        = 0x"REGFORMAT, uc->uc_mcontext.arm_pc);  
  64.     sigsegv_outp("CPSR      = 0x"REGFORMAT, uc->uc_mcontext.arm_cpsr);  
  65.     sigsegv_outp("Fault Address = 0x"REGFORMAT, uc->uc_mcontext.fault_address);  
  66.     sigsegv_outp("Trap no       = 0x"REGFORMAT, uc->uc_mcontext.trap_no);  
  67.     sigsegv_outp("Err Code  = 0x"REGFORMAT, uc->uc_mcontext.error_code);  
  68.     sigsegv_outp("Old Mask  = 0x"REGFORMAT, uc->uc_mcontext.oldmask);  
  69. #endif  
  70. }  
  71.   
  72. static void print_call_link(ucontext_t *uc)   
  73. {  
  74.     int i = 0;  
  75.     void **frame_pointer = (void **)NULL;  
  76.     void *return_address = NULL;  
  77.     Dl_info dl_info = { 0 };  
  78.   
  79. #if (defined __i386__)  
  80.     frame_pointer = (void **)uc->uc_mcontext.gregs[REG_EBP];  
  81.     return_address = (void *)uc->uc_mcontext.gregs[REG_EIP];  
  82. #elif (defined __x86_64__)  
  83.     frame_pointer = (void **)uc->uc_mcontext.gregs[REG_RBP];  
  84.     return_address = (void *)uc->uc_mcontext.gregs[REG_RIP];  
  85. #elif (defined __arm__)  
  86. /* sigcontext_t on ARM: 
  87.         unsigned long trap_no; 
  88.         unsigned long error_code; 
  89.         unsigned long oldmask; 
  90.         unsigned long arm_r0; 
  91.         ... 
  92.         unsigned long arm_r10; 
  93.         unsigned long arm_fp; 
  94.         unsigned long arm_ip; 
  95.         unsigned long arm_sp; 
  96.         unsigned long arm_lr; 
  97.         unsigned long arm_pc; 
  98.         unsigned long arm_cpsr; 
  99.         unsigned long fault_address; 
  100. */  
  101.     frame_pointer = (void **)uc->uc_mcontext.arm_fp;  
  102.     return_address = (void *)uc->uc_mcontext.arm_pc;  
  103. #endif  
  104.   
  105.     sigsegv_outp("\nStack trace:");  
  106.     while (frame_pointer && return_address) {  
  107.         if (!dladdr(return_address, &dl_info))  break;  
  108.         const char *sname = dl_info.dli_sname;    
  109. #ifndef NO_CPP_DEMANGLE  
  110.         int status;  
  111.         char *tmp = __cxa_demangle(sname, NULL, 0, &status);  
  112.         if (status == 0 && tmp) {  
  113.             sname = tmp;  
  114.         }  
  115. #endif  
  116.         /* No: return address <sym-name + offset> (filename) */  
  117.         sigsegv_outp("%02d: %p <%s + %lu> (%s)", ++i, return_address, sname,   
  118.             (unsigned long)return_address - (unsigned long)dl_info.dli_saddr,   
  119.                                                     dl_info.dli_fname);  
  120. #ifndef NO_CPP_DEMANGLE  
  121.         if (tmp)    free(tmp);  
  122. #endif  
  123.         if (dl_info.dli_sname && !strcmp(dl_info.dli_sname, "main")) {  
  124.             break;  
  125.         }  
  126.   
  127. #if (defined __x86_64__) || (defined __i386__)  
  128.         return_address = frame_pointer[1];  
  129.         frame_pointer = frame_pointer[0];  
  130. #elif (defined __arm__)  
  131.         return_address = frame_pointer[-1];   
  132.         frame_pointer = (void **)frame_pointer[-3];  
  133. #endif  
  134.     }  
  135.     sigsegv_outp("Stack trace end.");  
  136. }  
  137.   
  138. static void sigsegv_handler(int signo, siginfo_t *info, void *context)  
  139. {  
  140.     if (context) {  
  141.         ucontext_t *uc = (ucontext_t *)context;  
  142.   
  143.         sigsegv_outp("Segmentation Fault!");  
  144.         sigsegv_outp("info.si_signo = %d", signo);  
  145.         sigsegv_outp("info.si_errno = %d", info->si_errno);  
  146.         sigsegv_outp("info.si_code  = %d (%s)", info->si_code,   
  147.             (info->si_code == SEGV_MAPERR) ? "SEGV_MAPERR" : "SEGV_ACCERR");  
  148.         sigsegv_outp("info.si_addr  = %p\n", info->si_addr);  
  149.   
  150.         print_reg(uc);  
  151.         print_call_link(uc);  
  152.     }  
  153.   
  154.     _exit(0);  
  155. }  
  156.   
  157. #define SETSIG(sa, sig, fun, flags)     \  
  158.         do {                            \  
  159.             sa.sa_sigaction = fun;      \  
  160.             sa.sa_flags = flags;        \  
  161.             sigemptyset(&sa.sa_mask);   \  
  162.             sigaction(sig, &sa, NULL);  \  
  163.         } while(0)  
  164.   
  165. static void __attribute((constructor)) setup_sigsegv(void)   
  166. {  
  167.     struct sigaction sa;  
  168.   
  169.     SETSIG(sa, SIGSEGV, sigsegv_handler, SA_SIGINFO);   
  170. #if 0  
  171.     memset(&sa, 0, sizeof(struct sigaction));  
  172.     sa.sa_sigaction = sigsegv_handler;  
  173.     sa.sa_flags = SA_SIGINFO;  
  174.     if (sigaction(SIGSEGV, &sa, NULL) < 0) {  
  175.         perror("sigaction: ");  
  176.     }  
  177. #endif  
  178. }  
  179.   
  180. #if 1  
  181. void func3(void)  
  182. {  
  183.     char *p = (char *)0x12345678;  
  184.     *p = 10;  
  185. }  
  186.   
  187. void func2(void)  
  188. {  
  189.     func3();      
  190. }  
  191.   
  192. void func1(void)  
  193. {  
  194.     func2();  
  195. }  
  196.   
  197. int main(int argc, const char *argv[])  
  198. {  
  199.     func1();      
  200.     exit(EXIT_SUCCESS);  
  201. }  
  202. #endif  
编译时请加上-rdynamic -ldl选项！

代码地址：https://github.com/astrotycoon/sigsegv/blob/master/sigsegv.c


2016-1-17 18:29:33补充知识如下：

今天无意中发现原来gcc

相关阅读：

《 linux下利用backtrace追踪函数调用堆栈以及定位段错误》

《Stack Backtracing Inside Your Program》

《Obtaining a stack trace in C upon SIGSEGV》

参考链接：

《利用堆栈回溯、addr2line和Graphviz生成运行时函数调用图》

《Stack backtrace 的实现》

《linux backtrace()详细使用说明，分析Segmentation fault》

《Backtracing from code in ARM》（需要翻墙）

《Programmatic access to the call stack in C++》

《Stack unwinding (stack trace) with GCC》

《浅析ARM汇编语言子例程设计方法》

《自己动手实现arm函数栈帧回溯》

《Pre-mortem Backtracing》

《C++ Code Snippet - Print Stack Backtrace Programmatically with Demangled Function Names》

《内存泄露调试代码 可以解析C++ symbol》

《将信号用作 Linux 调试工具》

《Get an exception from a segfault on linux (x86 and x86_64), using some black magic !》

《broadcom6838开发环境实现函数栈追踪》

使用 backtrace 调测 SIGSEGV 信号
xiaozhi
05-10 561
使用 backtrace 调测 SIGSEGV 信号
自己动手实现arm函数栈帧回溯
uffgfbft的博客
02-12 357
自己动手实现arm函数栈帧回溯
捕捉信号SIGSEGV并回溯栈帧
astrotycoon
04-27 8084
引出问题在嵌入式应用程序开发过程中，调试一直是个老大难问题 -- 由于环境的限制，当程序发生段错误时不能很好的定位到底是哪里出现了错误，如果在程序发生段错误时能够清晰明了地看到程序的栈帧链，那无疑是雪中送炭。本文就捕捉信号SIGSEGV并在该信号的处理函数中打印出函数栈帧链来帮助我们调试程序。本文的程序适合ARM和X86平台。回溯栈帧原理理解函数栈帧的布局后，那么自然明白回溯栈帧的原理了，这里不多...
C程序员必须掌握的信号处理技能：signal捕获SIGSEGV的陷阱与最佳实践
最新发布
QuickTrans的博客
10-29 894
掌握C语言signal函数捕获SIGSEGV信号的方法，有效应对程序崩溃难题。适用于调试段错误、提升程序健壮性，详解信号处理机制与恢复执行的关键技巧。规避常见陷阱，实现稳定异常处理，值得收藏。
以SIGSEGV为例详解信号处理(与栈回溯)
weixin_34018202的博客
02-22 807
以SIGSEGV为例详解信号处理(与栈回溯) 信号是内核提供的向用户态进程发送信息的机制, 常见的有使用SIGUSR1唤醒用户进程执行子程序或发生段错误时使用SIGSEGV保存用户错误现场. 本文以SIGSEGV为例, 详细分析信号使用方法, 内核信号的发送与接收机制. 1. 信号处理例程 以下是一个SiGEGV处理例程, 主程序注册一个信号量并创建一个线程, 线程中故意访问空指针, 引发段错...
SIGSEGV信号
woshikalz的专栏
11-13 923
According to POSIX, the behaviour of a  process  is  unde-        fined after it ignores a SIGFPE, SIGILL, or SIGSEGV signal        that was not generated by the kill() or the raise()  func-      
SIGSEGV (Segmentation fault)
weixin_35750747的博客
01-08 5124
SIGSEGV 是一种类型的信号，表示计算机程序发生了段错误。段错误通常是由于程序访问了不属于它的内存空间，导致系统触发了保护机制而发送信号。这通常是由于程序中存在 bug，或者是由于系统内存分配出现问题所致。解决 SIGSEGV 错误通常需要调试程序并修复 bug，或者重新配置系统内存以解决内存分配问题。 ...
CrashKit：捕获异常与信号并发送至开发者邮箱或错误数据库
一旦检测到信号触发，CrashKit 能够保存当前的寄存器状态、调用栈回溯（backtrace）以及内存映射信息，从而构建出一份完整的崩溃现场快照。这种对信号级别的监控是实现全面崩溃捕获的关键，尤其适用于排查内存管理...
嵌入式之交叉栈回溯
weixin_40732273的博客
09-14 1703
背景简介 段错误的调试有很多方式，比如gdb工具，栈回溯的backtrace依赖于-g选项等， 1、栈回溯原理介绍 栈回溯是arm架构基于fp寄存器的栈回溯，通过fp寄存器和lr寄存器数据的关系，可以依次找出每个函数栈中存储的lr寄存器地址，即函数返回地址。通过函数dladdr()去获取函数返回地址的符号信息，即可得到函数符号名与加载模块的名称（动态库名），从而找出每一级函数调用关系。平台不同，fp寄存器和lr寄存器的关系也不相同，只要找出fp寄存器和lr寄存器的关系，就可以找出每一级函数调用关系。下面将介
使用backtrace追踪程序的异常退出
抱猫人的博客
04-12 586
输出程序的堆栈 backtrace函数 在linux系统中，我们可以通过如下三个库函数来获取程序的调用堆栈，可以通过man 3 backtrace查看。它们由GUN C Library提供。 #include <execinfo.h> /* Store up to SIZE return address of the current program state in ARRAY and return the exact number of values stored. */ int
ARM平台(海思)unwind栈回溯的实现
Callon_H的博客
01-17 9606
本文在撰写前尝试了约三四天的时间来实现海思平台的栈回溯，最终仅以此文作为记录，帮助更多的人。
arm栈帧回溯
02-13
arm栈帧回溯，自己实现arm-linux下的栈帧回溯，没有使用glibc的backstrace()和backtrace_symbols()，可以很好的调试segment fault问题。
linux 程序收到sigsegv信号_Linux下的LWP（轻量级进程）
weixin_39980234的博客
12-02 265
一、定义再看正文之前我要先强调一下几点：1. Linux中没有真正的线程，但windows中确实有线程2. Linux中没有的线程是由进程来模拟实现的(又称作：轻量级进程)3. 所以在Linux中(在CPU角度看)进程被称作轻量级进程(LWP)由于Linux下没有真正的线程，只有所谓的用户级线程，线程在CPU地址空间内运行关于进程(PCB)、轻量级进程(LWP)、线程(TCB)、用户线程、内核线程...
Fatal signal XX (SIGSEGV) 常见解决思路 backtrace
Venus 的博客
12-07 2797
Fatal signal XX (SIGSEGV)常用解决思路
信号
lyq_csdn的博客
06-02 459
来自：https://blog.youkuaiyun.com/dawn_sf/article/details/74177899信号与中断的区别：信号与中断的相似点：（1）采用了相同的异步通信方式；（2）当检测出有信号或中断请求时，都暂停正在执行的程序而转去执行相应的处理程序；（3）都在处理完毕后返回到原来的断点；（4）对信号或中断都可进行屏蔽。信号与中断的区别：（1）中断有优先级，而信号没有优先级，所有的信号...
段错误：SIGSEGV
weixin_43862733的博客
06-21 962
SIGSEGV是在访问内存时发生的错误，它属于内存管理的范畴 SIGSEGV是一个用户态的概念，是操作系统在用户态程序错误访问内存时所做出的处理。 当用户态程序访问（访问表示读、写或执行）不允许访问的内存时，产生SIGSEGV。 当用户态程序以错误的方式访问允许访问的内存时，产生SIGSEGV...
C++利用SIGSEGV信号处理实现发生segment fault后不崩溃的代码
踏莎行的博客
06-28 961
C++代码发生段错误后系统会抛出SIGSEGV 信号 ，之后 调用默认的信号处理函数 ，产生core文件 ，然后关闭程序。让程序不挂掉的办法就是捕获这个中断信号，调用自定义的信号处理函数，并且叠加一些代码跳转的方法。这里展示了一种方法。这里用到两个函数sigsetjmp和siglongjmp，前者会保存当前的信号屏蔽表 (signal mask)，后者跳转的时候会恢复线程的屏蔽表。有效的做法是在发生段错误的代码之前保存程序执行上下文，信号捕捉后通过跳转函数直接跳过段错误的代码，从而达到程序继续执行的目的。
linux SIGSEGV 信号捕捉，保证发生段错误后程序不崩溃
chenzhjlf的专栏
05-05 2666
在linux中编程的时候 有时候 try catch 可能满足不了我们的需求。因为碰到类似数组越界 ，非法内存访问之类的 ，这样的错误无法捕获。下面我们介绍一种使用捕获信号实现的异常 用来保证诸如段错误之类的错误发生时程序不会崩溃，而是跳过代码继续执行。首先我们来看看发生段错误之后系统的处理。 发生段错误后系统会抛出 SIGSEGV 信号 ，之后 调用默认的信号处理函数 ，产生core文件 ，然后关闭程序 。 那有没有一种办法可以保证程序不会死掉呢，当然是...
SIGSEGV 段错误
sunfanup的博客
02-21 3087
SIGSEGV是在Unix/Linux系统中表示"Segmentation Fault"（分段错误）的信号。当一个进程访问未分配给它的内存、访问超出其内存边界或者访问不允许的内存区域时，就会产生SIGSEGV信号，导致进程被操作系统终止。
c++捕捉到信号SIGSEGV时，处理函数中的siginfo_t参数详细说明
03-01
<think>好的，我现在要回答用户关于C++中处理SIGSEGV信号时siginfo_t参数的详细说明。首先，我需要回忆一下相关的知识，确保信息的准确性。 用户的问题是关于在捕获SIGSEGV信号时，处理函数中的siginfo_t结构体的详细说明。我需要先确认siginfo_t的结构以及各个字段的含义，特别是与SIGSEGV相关的部分。 首先，SIGSEGV是段错误信号，通常是由于无效的内存访问引起的，比如访问未分配的内存、写入只读内存等。当使用sigaction函数设置信号处理函数，并且使用了SA_SIGINFO标志时，处理函数会接收到三个参数：int signo, siginfo_t *info, void *context。用户关心的是其中的siginfo_t *info参数。 接下来，我需要详细说明siginfo_t结构体中与SIGSEGV相关的字段。根据POSIX标准，siginfo_t包含多个成员，但不同的信号可能填充不同的字段。对于SIGSEGV来说，主要的字段包括： - si_signo：信号编号，这里应该是SIGSEGV的值。 - si_errno：错误码，通常为0，除非有相关的系统错误。 - si_code：指示错误的类型，比如SEGV_MAPERR（地址未映射到对象）或SEGV_ACCERR（无效的权限访问）。 - si_addr：引发错误的内存地址。 此外，可能还有其他字段，比如发送信号的进程ID等，但对于SIGSEGV来说，这些可能不适用。需要确认这些信息是否正确，可能需要查阅相关文档或手册页。 然后，我需要解释每个字段的具体含义和可能的取值。例如，si_code的不同值对应的错误类型，SEGV_MAPERR表示访问的地址没有映射到进程的地址空间，而SEGV_ACCERR表示试图以不允许的方式访问内存（如写入只读区域）。si_addr字段则给出了导致错误的地址，这对于调试非常有用。 还需要提醒用户，在处理SIGSEGV时，信号处理函数应该尽量简单，避免调用非异步信号安全的函数，以免导致未定义行为。此外，段错误通常意味着程序存在严重问题，处理完信号后可能无法安全地继续执行，可能需要终止程序或记录信息后退出。 可能需要检查是否有遗漏的字段或需要进一步解释的部分。比如，是否还有其他si_code的可能值，或者si_addr在某些情况下的有效性。例如，在某些架构或系统上，si_addr可能无法正确获取，或者某些情况下si_code可能有其他值，但通常对于SIGSEGV来说，主要是这两个si_code。 最后，总结这些信息，以清晰的结构呈现给用户，确保他们能够理解每个字段的作用和如何利用这些信息进行调试或错误处理。</think>在C++中处理SIGSEGV信号时，通过`siginfo_t`参数可以获取详细的错误信息。以下是关键字段说明及使用示例： --- ### **siginfo_t 核心字段（SIGSEGV专用）** 1. **si_signo** - 类型：`int` - 说明：信号编号，固定为`SIGSEGV`（值为11）。 2. **si_code** - 类型：`int` - 说明：错误类型标识，具体取值： - `SEGV_MAPERR`：访问未映射的内存地址（如空指针解引用） - `SEGV_ACCERR`：权限错误（如写入只读内存） 3. **si_addr** - 类型：`void*` - 说明：触发错误的访问地址（如`0x0`表示访问NULL指针） 4. **si_errno** - 类型：`int` - 说明：通常为0，系统错误码（较少使用） --- ### **代码示例：信号处理器** ```cpp #include <signal.h> #include <stdio.h> #include <stdlib.h> void segv_handler(int signo, siginfo_t* info, void* context) { fprintf(stderr, "=== SIGSEGV 错误信息 ===\n"); fprintf(stderr, "信号编号: %d\n", info->si_signo); fprintf(stderr, "错误地址: %p\n", info->si_addr); switch (info->si_code) { case SEGV_MAPERR: fprintf(stderr, "原因: 访问未映射的内存\n"); break; case SEGV_ACCERR: fprintf(stderr, "原因: 内存访问权限错误\n"); break; default: fprintf(stderr, "未知错误类型\n"); } // 立即终止程序（避免不可恢复状态） abort(); } int main() { struct sigaction sa{}; sa.sa_sigaction = segv_handler; sa.sa_flags = SA_SIGINFO; // 必须设置此标志以获取siginfo sigaction(SIGSEGV, &sa, nullptr); // 触发段错误（示例） int* ptr = nullptr; *ptr = 42; // 触发SIGSEGV return 0; } ``` --- ### **输出示例** ``` === SIGSEGV 错误信息 === 信号编号: 11 错误地址: 0x0 原因: 访问未映射的内存 Aborted (core dumped) ``` --- ### **注意事项** 1. **异步信号安全** 处理函数中只能调用异步信号安全函数（如`write`，避免`printf`）。示例中使用`fprintf`仅为演示，实际应谨慎处理。 2. **程序终止** SIGSEGV通常意味着程序状态已损坏，建议在记录信息后调用`abort()`或`_exit()`终止。 3. **调试用途** 结合`si_addr`和调试器（如GDB）可快速定位问题代码。 通过分析`siginfo_t`参数，可精准定位段错误根源，提升调试效率。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值