捕捉信号SIGSEGV并回溯栈帧

最新推荐文章于 2025-04-04 22:45:33 发布
最新推荐文章于 2025-04-04 22:45:33 发布
阅读量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开发环境实现函数栈追踪》

core文件的原理是啥
二进制君
06-08 39
Core Dump（核心转储）是操作系统在程序崩溃（如段错误、非法指令等）时自动生成的一个文件，它包含了程序崩溃瞬间的。通过 core dump，开发者可以像“时间回溯”一样检查程序崩溃瞬间的状态，是调试复杂问题的利器！终止时，Linux 内核会生成 core 文件。不会生成 core dump，因为它们是“优雅终止”信号。这样 core 文件会直接压缩存储，节省磁盘空间。的文件（类似可执行文件），可以用。Core 文件本质上是一个。
Unix调试器GDB教程
weixin_42397177的博客
09-14 580
一、GDB概论 gdb是GNU debugger的缩写，是编程调试工具。 UNIX及UNIX-like（Linux）下的调试工具。或许，各位比较喜欢那种图形界面方式的，像VC、BCB等IDE的调试，但如果你是在 UNIX平台下做软件，你会发现GDB这个调试工具相比于VC的优点是具有修复网络断点以及恢复链接等功能，比BCB的图形化调试器有更强大的功能。所谓"尺有所短，寸有所长"就是这个道理。 只有一...
C++利用SIGSEGV信号处理实现发生segment fault后不崩溃的代码
踏莎行的博客
06-28 719
C++代码发生段错误后系统会抛出SIGSEGV 信号 ，之后 调用默认的信号处理函数 ，产生core文件 ，然后关闭程序。让程序不挂掉的办法就是捕获这个中断信号，调用自定义的信号处理函数，并且叠加一些代码跳转的方法。这里展示了一种方法。这里用到两个函数sigsetjmp和siglongjmp，前者会保存当前的信号屏蔽表 (signal mask)，后者跳转的时候会恢复线程的屏蔽表。有效的做法是在发生段错误的代码之前保存程序执行上下文，信号捕捉后通过跳转函数直接跳过段错误的代码，从而达到程序继续执行的目的。
以SIGSEGV为例详解信号处理(与栈回溯)
weixin_34018202的博客
02-22 720
以SIGSEGV为例详解信号处理(与栈回溯) 信号是内核提供的向用户态进程发送信息的机制, 常见的有使用SIGUSR1唤醒用户进程执行子程序或发生段错误时使用SIGSEGV保存用户错误现场. 本文以SIGSEGV为例, 详细分析信号使用方法, 内核信号的发送与接收机制. 1. 信号处理例程 以下是一个SiGEGV处理例程, 主程序注册一个信号量并创建一个线程, 线程中故意访问空指针, 引发段错...
Linux错误(6)X64向量指令访问地址未对齐引起SIGSEGV
最新发布
Once_day的回忆
04-04 1202
X64设备上，如果定义一个结构体，其包含连续的整数字段，并且存在类似的算术操作，编译会自动优化代码，生成向量指令SSE/AVX(xmm0)，但是由于这些结构体的地址没有对齐到16字节，读取数据时会触发SIGSEGV错误，造成coredump。/* 禁止内联 */// data128_add函数二进制反汇编如下GDB调试运行结果如下，可以清晰看到执行的指令、代码行和数据地址信息:/* 禁止内联 */// -O3 编译会生成如下代码// 申请一段内存, 64字节。
SIGSEGV信号
woshikalz的专栏
11-13 892
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 504
使用 backtrace 调测 SIGSEGV 信号
SIGSEGV (Segmentation fault)
weixin_35750747的博客
01-08 5072
SIGSEGV 是一种类型的信号，表示计算机程序发生了段错误。段错误通常是由于程序访问了不属于它的内存空间，导致系统触发了保护机制而发送信号。这通常是由于程序中存在 bug，或者是由于系统内存分配出现问题所致。解决 SIGSEGV 错误通常需要调试程序并修复 bug，或者重新配置系统内存以解决内存分配问题。 ...
自己动手实现arm函数栈帧回溯
uffgfbft的博客
02-12 320
自己动手实现arm函数栈帧回溯
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 将暂停执行并向用户提供提示。 #### ...
arm栈帧回溯
02-13
arm栈帧回溯，自己实现arm-linux下的栈帧回溯，没有使用glibc的backstrace()和backtrace_symbols()，可以很好的调试segment fault问题。
linux 程序收到sigsegv信号_Linux下的LWP（轻量级进程）
weixin_39980234的博客
12-02 235
一、定义再看正文之前我要先强调一下几点：1. Linux中没有真正的线程，但windows中确实有线程2. Linux中没有的线程是由进程来模拟实现的(又称作：轻量级进程)3. 所以在Linux中(在CPU角度看)进程被称作轻量级进程(LWP)由于Linux下没有真正的线程，只有所谓的用户级线程，线程在CPU地址空间内运行关于进程(PCB)、轻量级进程(LWP)、线程(TCB)、用户线程、内核线程...
Fatal signal XX (SIGSEGV) 常见解决思路 backtrace
Venus 的博客
12-07 2675
Fatal signal XX (SIGSEGV)常用解决思路
信号
lyq_csdn的博客
06-02 390
来自：https://blog.csdn.net/dawn_sf/article/details/74177899信号与中断的区别：信号与中断的相似点：（1）采用了相同的异步通信方式；（2）当检测出有信号或中断请求时，都暂停正在执行的程序而转去执行相应的处理程序；（3）都在处理完毕后返回到原来的断点；（4）对信号或中断都可进行屏蔽。信号与中断的区别：（1）中断有优先级，而信号没有优先级，所有的信号...
linux SIGSEGV 信号捕捉，保证发生段错误后程序不崩溃
chenzhjlf的专栏
05-05 2510
在linux中编程的时候 有时候 try catch 可能满足不了我们的需求。因为碰到类似数组越界 ，非法内存访问之类的 ，这样的错误无法捕获。下面我们介绍一种使用捕获信号实现的异常 用来保证诸如段错误之类的错误发生时程序不会崩溃，而是跳过代码继续执行。首先我们来看看发生段错误之后系统的处理。 发生段错误后系统会抛出 SIGSEGV 信号 ，之后 调用默认的信号处理函数 ，产生core文件 ，然后关闭程序 。 那有没有一种办法可以保证程序不会死掉呢，当然是...
SIGSEGV 段错误
sunfanup的博客
02-21 2620
SIGSEGV是在Unix/Linux系统中表示"Segmentation Fault"（分段错误）的信号。当一个进程访问未分配给它的内存、访问超出其内存边界或者访问不允许的内存区域时，就会产生SIGSEGV信号，导致进程被操作系统终止。
如何才能让进程先捕捉SIGSEGV信号，打印出有用的方便定位问题的信息，然后再优雅地退出呢？
m0_47104421的博客
03-30 591
不过！！！你会发现程序一般不会对SIGSEGV信号进行处理，那是因为SIGSEGV是不可靠信号(1-31)不可靠信号无法保证一定会被处理！！！所以在程序崩溃段错误这种情况下，用了也可能是白用。。。。。。
Linux系统中段错误信号sigsegv的捕获
qq_40464599的博客
04-02 961
但是，在某些情况下，我们希望能够捕获这个信号，并进行一些特定的处理，比如打印出错信息、记录日志或者进行资源清理等，而不是让程序立即退出。在上述代码中，为了简化，我们没有包含这部分内容，但在实际开发过程中，这是非常重要的一步。的错误，例如，确保指针在使用前已经被正确初始化，数组访问不超过其边界等。在信号处理函数中，我们可以进行错误处理，比如打印相关信息或者清理资源。在Linux系统中，当程序试图访问它没有权限访问的内存区域时，操作系统会发送一个。在上面的代码中，我们使用。在实际的应用中，处理。
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`参数，可精准定位段错误根源，提升调试效率。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值