捕捉信号SIGSEGV并回溯栈帧

最新推荐文章于 2024-05-10 09:15:43 发布
最新推荐文章于 2024-05-10 09:15:43 发布
阅读量8k 收藏 25
点赞数 11
分类专栏： C语言基础 系统编程 程序调试 嵌入式基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/astrotycoon/article/details/45315437
版权
本文介绍了一种在嵌入式应用程序开发过程中，当程序发生段错误时，通过捕捉信号SIGSEGV并在其处理函数中打印出函数栈帧链的方法来辅助调试程序的技术。适用于ARM和X86平台。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

引出问题

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

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

回溯栈帧原理

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

                                                                 x86函数栈帧结构

 

                                                                ARM函数栈帧结构

代码sigsegv.c

#ifndef _GNU_SOURCE
	#define _GNU_SOURCE
#endif
#include <stdio.h>
#include <dlfcn.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <ucontext.h>


/* 纯C环境下，不定义宏NO_CPP_DEMANGLE */
#if (!defined(__cplusplus)) && (!defined(NO_CPP_DEMANGLE))
#define NO_CPP_DEMANGLE
#endif

#ifndef NO_CPP_DEMANGLE
    #include <cxxabi.h>
    #ifdef __cplusplus
    	using __cxxabiv1::__cxa_demangle;
    #endif
#endif

#ifdef HAS_ULSLIB
	#include <uls/logger.h>
	#define sigsegv_outp(x)	sigsegv_outp(, gx)
#else
	#define sigsegv_outp(x, ...) 	fprintf(stderr, x"\n", ##__VA_ARGS__)
#endif

#if (defined __x86_64__)
	#define REGFORMAT   "%016lx"	
#elif (defined __i386__)
	#define REGFORMAT   "%08x"
#elif (defined __arm__)
	#define REGFORMAT   "%lx"
#endif

static void print_reg(ucontext_t *uc) 
{
#if (defined __x86_64__) || (defined __i386__)
	int i;
	for (i = 0; i < NGREG; i++) {
		sigsegv_outp("reg[%02d]: 0x"REGFORMAT, i, uc->uc_mcontext.gregs[i]);
	}
#elif (defined __arm__)
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 0, uc->uc_mcontext.arm_r0);
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 1, uc->uc_mcontext.arm_r1);
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 2, uc->uc_mcontext.arm_r2);
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 3, uc->uc_mcontext.arm_r3);
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 4, uc->uc_mcontext.arm_r4);
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 5, uc->uc_mcontext.arm_r5);
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 6, uc->uc_mcontext.arm_r6);
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 7, uc->uc_mcontext.arm_r7);
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 8, uc->uc_mcontext.arm_r8);
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 9, uc->uc_mcontext.arm_r9);
	sigsegv_outp("reg[%02d]		= 0x"REGFORMAT, 10, uc->uc_mcontext.arm_r10);
	sigsegv_outp("FP		= 0x"REGFORMAT, uc->uc_mcontext.arm_fp);
	sigsegv_outp("IP		= 0x"REGFORMAT, uc->uc_mcontext.arm_ip);
	sigsegv_outp("SP		= 0x"REGFORMAT, uc->uc_mcontext.arm_sp);
	sigsegv_outp("LR		= 0x"REGFORMAT, uc->uc_mcontext.arm_lr);
	sigsegv_outp("PC		= 0x"REGFORMAT, uc->uc_mcontext.arm_pc);
	sigsegv_outp("CPSR		= 0x"REGFORMAT, uc->uc_mcontext.arm_cpsr);
	sigsegv_outp("Fault Address	= 0x"REGFORMAT, uc->uc_mcontext.fault_address);
	sigsegv_outp("Trap no		= 0x"REGFORMAT, uc->uc_mcontext.trap_no);
	sigsegv_outp("Err Code	= 0x"REGFORMAT, uc->uc_mcontext.error_code);
	sigsegv_outp("Old Mask	= 0x"REGFORMAT, uc->uc_mcontext.oldmask);
#endif
}

static void print_call_link(ucontext_t *uc) 
{
	int i = 0;
	void **frame_pointer = (void **)NULL;
	void *return_address = NULL;
	Dl_info	dl_info = { 0 };

#if (defined __i386__)
	frame_pointer = (void **)uc->uc_mcontext.gregs[REG_EBP];
	return_address = (void *)uc->uc_mcontext.gregs[REG_EIP];
#elif (defined __x86_64__)
	frame_pointer = (void **)uc->uc_mcontext.gregs[REG_RBP];
	return_address = (void *)uc->uc_mcontext.gregs[REG_RIP];
#elif (defined __arm__)
/* sigcontext_t on ARM:
        unsigned long trap_no;
        unsigned long error_code;
        unsigned long oldmask;
        unsigned long arm_r0;
        ...
        unsigned long arm_r10;
        unsigned long arm_fp;
        unsigned long arm_ip;
        unsigned long arm_sp;
        unsigned long arm_lr;
        unsigned long arm_pc;
        unsigned long arm_cpsr;
        unsigned long fault_address;
*/
	frame_pointer = (void **)uc->uc_mcontext.arm_fp;
	return_address = (void *)uc->uc_mcontext.arm_pc;
#endif

	sigsegv_outp("\nStack trace:");
	while (frame_pointer && return_address) {
		if (!dladdr(return_address, &dl_info))	break;
		const char *sname = dl_info.dli_sname;	
#ifndef NO_CPP_DEMANGLE
		int status;
		char *tmp = __cxa_demangle(sname, NULL, 0, &status);
		if (status == 0 && tmp) {
			sname = tmp;
		}
#endif
		/* No: return address <sym-name + offset> (filename) */
		sigsegv_outp("%02d: %p <%s + %lu> (%s)", ++i, return_address, sname, 
			(unsigned long)return_address - (unsigned long)dl_info.dli_saddr, 
													dl_info.dli_fname);
#ifndef NO_CPP_DEMANGLE
		if (tmp)	free(tmp);
#endif
		if (dl_info.dli_sname && !strcmp(dl_info.dli_sname, "main")) {
			break;
		}

#if (defined __x86_64__) || (defined __i386__)
		return_address = frame_pointer[1];
		frame_pointer = frame_pointer[0];
#elif (defined __arm__)
		return_address = frame_pointer[-1];	
		frame_pointer = (void **)frame_pointer[-3];
#endif
	}
	sigsegv_outp("Stack trace end.");
}

static void sigsegv_handler(int signo, siginfo_t *info, void *context)
{
	if (context) {
		ucontext_t *uc = (ucontext_t *)context;

   		sigsegv_outp("Segmentation Fault!");
    	sigsegv_outp("info.si_signo = %d", signo);
    	sigsegv_outp("info.si_errno = %d", info->si_errno);
    	sigsegv_outp("info.si_code  = %d (%s)", info->si_code, 
			(info->si_code == SEGV_MAPERR) ? "SEGV_MAPERR" : "SEGV_ACCERR");
    	sigsegv_outp("info.si_addr  = %p\n", info->si_addr);

		print_reg(uc);
		print_call_link(uc);
	}

	_exit(0);
}

#define SETSIG(sa, sig, fun, flags)     \
        do {                            \
            sa.sa_sigaction = fun;      \
            sa.sa_flags = flags;        \
            sigemptyset(&sa.sa_mask);   \
            sigaction(sig, &sa, NULL);  \
        } while(0)

static void __attribute((constructor)) setup_sigsegv(void) 
{
	struct sigaction sa;

	SETSIG(sa, SIGSEGV, sigsegv_handler, SA_SIGINFO); 
#if 0
	memset(&sa, 0, sizeof(struct sigaction));
	sa.sa_sigaction = sigsegv_handler;
	sa.sa_flags = SA_SIGINFO;
	if (sigaction(SIGSEGV, &sa, NULL) < 0) {
		perror("sigaction: ");
	}
#endif
}

#if 1
void func3(void)
{
	char *p = (char *)0x12345678;
	*p = 10;
}

void func2(void)
{
	func3();	
}

void func1(void)
{
	func2();
}

int main(int argc, const char *argv[])
{
	func1();	
	exit(EXIT_SUCCESS);
}
#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》（需要翻墙）

《通过截取signal输出程序崩溃时的backtrace》

《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开发环境实现函数栈追踪》

C++利用SIGSEGV信号处理实现发生segment fault后不崩溃的代码
踏莎行的博客
06-28 649
C++代码发生段错误后系统会抛出SIGSEGV 信号 ，之后 调用默认的信号处理函数 ，产生core文件 ，然后关闭程序。让程序不挂掉的办法就是捕获这个中断信号，调用自定义的信号处理函数，并且叠加一些代码跳转的方法。这里展示了一种方法。这里用到两个函数sigsetjmp和siglongjmp，前者会保存当前的信号屏蔽表 (signal mask)，后者跳转的时候会恢复线程的屏蔽表。有效的做法是在发生段错误的代码之前保存程序执行上下文，信号捕捉后通过跳转函数直接跳过段错误的代码，从而达到程序继续执行的目的。
自己动手实现arm函数栈帧回溯
uffgfbft的博客
02-12 311
自己动手实现arm函数栈帧回溯
以SIGSEGV为例详解信号处理(与栈回溯)
weixin_34018202的博客
02-22 713
以SIGSEGV为例详解信号处理(与栈回溯) 信号是内核提供的向用户态进程发送信息的机制, 常见的有使用SIGUSR1唤醒用户进程执行子程序或发生段错误时使用SIGSEGV保存用户错误现场. 本文以SIGSEGV为例, 详细分析信号使用方法, 内核信号的发送与接收机制. 1. 信号处理例程 以下是一个SiGEGV处理例程, 主程序注册一个信号量并创建一个线程, 线程中故意访问空指针, 引发段错...
SIGSEGV信号
woshikalz的专栏
11-13 888
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-      
使用 backtrace 调测 SIGSEGV 信号
xiaozhi
05-10 493
使用 backtrace 调测 SIGSEGV 信号
SIGSEGV (Segmentation fault)
weixin_35750747的博客
01-08 5046
SIGSEGV 是一种类型的信号，表示计算机程序发生了段错误。段错误通常是由于程序访问了不属于它的内存空间，导致系统触发了保护机制而发送信号。这通常是由于程序中存在 bug，或者是由于系统内存分配出现问题所致。解决 SIGSEGV 错误通常需要调试程序并修复 bug，或者重新配置系统内存以解决内存分配问题。 ...
pykeopssegmentation fault (core dumped)
最新发布
01-10
### PyKeOps 导致的段错误问题分析 当遇到由 PyKeOps 引发的 `Segmentation fault (core dumped)` 错误时，这通常表明存在非法内存访问操作[^...# 当捕获到信号SIGSEGV之后查看回溯栈帧获取更多信息 (gdb) bt full ```
QT GDB 查看段错误崩溃
12-28
为了让 GDB 捕捉到导致段错误的 SIGSEGV 信号，可以在进入 `run` 命令之前设置如下配置： ```bash (gdb) handle SIGSEGV stop print nopass ``` 这使得每当发生段错误时，GDB 将暂停执行并向用户提供提示。 #### ...
Unix调试器GDB教程
weixin_42397177的博客
09-14 572
一、GDB概论 gdb是GNU debugger的缩写，是编程调试工具。 UNIX及UNIX-like（Linux）下的调试工具。或许，各位比较喜欢那种图形界面方式的，像VC、BCB等IDE的调试，但如果你是在 UNIX平台下做软件，你会发现GDB这个调试工具相比于VC的优点是具有修复网络断点以及恢复链接等功能，比BCB的图形化调试器有更强大的功能。所谓"尺有所短，寸有所长"就是这个道理。 只有一...
VxWorks异常处理与调试：捕获与分析异常事件（异常事件不再是问题）
![VxWorks异常处理与... # 摘要 VxWorks异常处理是保障实时操作系统稳定运行的关键技术。本文详细介绍了VxWorks异常处理的机制，包括异常事件的捕获、异常信号的处理以及自定义异常处理器的设计。同时，本文探讨了异
arm栈帧回溯
02-13
arm栈帧回溯，自己实现arm-linux下的栈帧回溯，没有使用glibc的backstrace()和backtrace_symbols()，可以很好的调试segment fault问题。
linux 程序收到sigsegv信号_Linux下的LWP（轻量级进程）
weixin_39980234的博客
12-02 230
一、定义再看正文之前我要先强调一下几点：1. Linux中没有真正的线程，但windows中确实有线程2. Linux中没有的线程是由进程来模拟实现的(又称作：轻量级进程)3. 所以在Linux中(在CPU角度看)进程被称作轻量级进程(LWP)由于Linux下没有真正的线程，只有所谓的用户级线程，线程在CPU地址空间内运行关于进程(PCB)、轻量级进程(LWP)、线程(TCB)、用户线程、内核线程...
Fatal signal XX (SIGSEGV) 常见解决思路 backtrace
Venus 的博客
12-07 2662
Fatal signal XX (SIGSEGV)常用解决思路
信号
lyq_csdn的博客
06-02 379
来自：https://blog.csdn.net/dawn_sf/article/details/74177899信号与中断的区别：信号与中断的相似点：（1）采用了相同的异步通信方式；（2）当检测出有信号或中断请求时，都暂停正在执行的程序而转去执行相应的处理程序；（3）都在处理完毕后返回到原来的断点；（4）对信号或中断都可进行屏蔽。信号与中断的区别：（1）中断有优先级，而信号没有优先级，所有的信号...
linux SIGSEGV 信号捕捉，保证发生段错误后程序不崩溃
chenzhjlf的专栏
05-05 2444
在linux中编程的时候 有时候 try catch 可能满足不了我们的需求。因为碰到类似数组越界 ，非法内存访问之类的 ，这样的错误无法捕获。下面我们介绍一种使用捕获信号实现的异常 用来保证诸如段错误之类的错误发生时程序不会崩溃，而是跳过代码继续执行。首先我们来看看发生段错误之后系统的处理。 发生段错误后系统会抛出 SIGSEGV 信号 ，之后 调用默认的信号处理函数 ，产生core文件 ，然后关闭程序 。 那有没有一种办法可以保证程序不会死掉呢，当然是...
SIGSEGV 段错误
sunfanup的博客
02-21 2499
SIGSEGV是在Unix/Linux系统中表示"Segmentation Fault"（分段错误）的信号。当一个进程访问未分配给它的内存、访问超出其内存边界或者访问不允许的内存区域时，就会产生SIGSEGV信号，导致进程被操作系统终止。
如何才能让进程先捕捉SIGSEGV信号，打印出有用的方便定位问题的信息，然后再优雅地退出呢？
m0_47104421的博客
03-30 565
不过！！！你会发现程序一般不会对SIGSEGV信号进行处理，那是因为SIGSEGV是不可靠信号(1-31)不可靠信号无法保证一定会被处理！！！所以在程序崩溃段错误这种情况下，用了也可能是白用。。。。。。
Linux系统中段错误信号sigsegv的捕获
qq_40464599的博客
04-02 906
但是，在某些情况下，我们希望能够捕获这个信号，并进行一些特定的处理，比如打印出错信息、记录日志或者进行资源清理等，而不是让程序立即退出。在上述代码中，为了简化，我们没有包含这部分内容，但在实际开发过程中，这是非常重要的一步。的错误，例如，确保指针在使用前已经被正确初始化，数组访问不超过其边界等。在信号处理函数中，我们可以进行错误处理，比如打印相关信息或者清理资源。在Linux系统中，当程序试图访问它没有权限访问的内存区域时，操作系统会发送一个。在上面的代码中，我们使用。在实际的应用中，处理。
stm32 栈帧回溯
vipchenvip的博客
01-02 1031
// hard fault handler in C, // with stack frame location as input parameter void hard_fault_handler_c (unsigned int * hardfault_args) { unsigned int stacked_r0; unsigned i...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值