通过 /proc/[pid]/ 查看进程状态

最新推荐文章于 2025-06-06 13:56:39 发布
原创 最新推荐文章于 2025-06-06 13:56:39 发布 · 1.7w 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了如何通过/proc/PID/status文件获取Linux系统中进程的状态信息，包括进程占用的虚拟内存、物理内存等关键指标，并提供了一个示例程序用于自动化获取这些信息。

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

参考资料

[/proc官方手册] http://man7.org/linux/man-pages/man5/proc.5.html
[解读/proc/$PID/status中各种参数] https://my.oschina.net/aiguozhe/blog/125477
[查看Linux & Android中内存占用方法] http://blog.csdn.net/myarrow/article/details/7703296
[Measuring Memory Usage] http://locklessinc.com/articles/memory_usage/
[Linux下的/proc/[pid]目录下的文件分析] https://github.com/NanXiao/gnu-linux-proc-pid-intro
[Linux中查看进程占用内存的情况] http://hutaow.com/blog/2014/08/28/display-process-memory-in-linux/
[内存 /proc/meminfo 之谜]http://linuxperf.com/?p=142

/proc/[pid]/ 目录

在这篇文章中 http://man7.org/linux/man-pages/man5/proc.5.html 详细讲解了/proc 目录下各个文件的意义以及系统调用的方法。
当我们查看进程的时候 #ps –e或#ps可以列举出当前进程ID以及名称。
ps 命令的使用可以参考：http://man7.org/linux/man-pages/man1/ps.1.html
其中PID为1的固定为init进程，2的为kthreadd进程。前面的几个进程基本上都是固定的。在 /proc目录下会有与PID一致的目录名，目录里面的信息就包含该进程的所有信息。对 /proc/[pid]/目录的解释如下：

这里写图片描述

比如说 PID=1的init进程的信息存放在 /proc/1/ 的目录如下。
这里写图片描述

/proc/[pid]/status

这里写图片描述

将 /proc/[pid]/stat和 /proc/[pid]/statm的内容以用户可以直观分析的格式打印出来。这里只列举了其中的几个参数的意义：

* Name: Command run by this process.

* State: Current state of the process.  One of "R (running)",

"S (sleeping)", "D (disk sleep)", "T (stopped)", "T (tracing
stop)", "Z (zombie)", or "X (dead)".

* Pid: Thread ID (see gettid(2)).

* VmPeak: Peak virtual memory size.

* VmSize: Virtual memory size.

* VmLck: Locked memory size (see mlock(3)).

* VmPin: Pinned memory size (since Linux 3.2).  These are
pages that can't be moved because something needs to
directly access physical memory.

* VmHWM: Peak resident set size ("high water mark").

* VmRSS: Resident set size.  Note that the value here is the
sum of RssAnon, RssFile, and RssShmem.

* RssAnon: Size of resident anonymous memory.  (since Linux
4.5).

* RssFile: Size of resident file mappings.  (since Linux 4.5).

* RssShmem: Size of resident shared memory (includes System V
shared memory, mappings from tmpfs(5), and shared anonymous
mappings).  (since Linux 4.5).

* VmData, VmStk, VmExe: Size of data, stack, and text
segments.

* VmLib: Shared library code size.

* VmPTE: Page table entries size (since Linux 2.6.10).

* VmPMD: Size of second-level page tables (since Linux 4.0).

* VmSwap: Swapped-out virtual memory size by anonymous private
pages; shmem swap usage is not included (since Linux
2.6.34).

* Threads: Number of threads in process containing this
thread.
  • VmPeak: 表示进程所占用最大虚拟内存大小
  • VmSize: 表示进程当前虚拟内存大小
  • VmLck: 表示被锁定的内存大小
  • VmHWM: 表示进程所占用物理内存的峰值
  • VmRSS: 表示进程当前占用物理内存的大小(与procrank中的RSS)
  • VmData: 表示进程数据段的大小
  • VmStk: 表示进程堆栈段的大小
  • VmExe: 表示进程代码的大小
  • VmLib: 表示进程所使用共享库的大小
  • VmPTE: 表示进程页表项的大小

如果我们只想要获取其中某几个参数的值，可以使用命令：
#cat /proc/1/status | grep -E 'VmSize|VmRSS'

有这么一个需求：要统计各个进程中占用的物理内存的大小，我总不能一条条去执行cat命令吧，于是我们可以写一个应用程序循环读取每个进程的某个状态值。于是就有了下面的 rdstatus 应用程序

cat /proc/[pid]/stat

stat这个文件包含了很多信息，总共有52个参数。
这里写图片描述

这些内容在内核代码中：<kernel_dir>/fs/proc/array.c中实现。

rdstatus 应用程序

rdstatus.c 只能用来获取 /proc/[pid]/status中的内容。通过读取 /proc目录下的所有文件，然后提取其中[pid]的目录，获取到 /proc/[pid]/status的路径，再组合成 cmd命令传递给system()执行。

#if 1
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <unistd.h>
#include <dirent.h>

#define PROC_DIR_PATH "/proc"
#define DIR_MAX  256
#define DIR_NAME_MAX 40
#define CMD_NAME_MAX 200
#define RD_BUFFER_MAX 512

#if 0 // 介绍目录操作
http://songlee24.github.io/2014/09/20/linux-get-directory/

在头文件<dirent.h>中定义了两种主要的数据类型。

DIR：代表一个目录流的结构。

struct __dirstream
{
    void *__fd;              /* 'struct hurd_fd' pointer for descriptor.*/
    char *__data;            /* Directory block.  */
    int __entry_data;        /* Entry number `__data' corresponds to.*/
    char *__ptr;             /* Current pointer into the block.*/
    int __entry_ptr;         /* Entry number `__ptr' corresponds to.*/
    size_t __allocation;          /* Space allocated for the block.*/
    size_t __size;                /* Total valid data in the block.*/
    __libc_lock_define (, __lock) /* Mutex lock for this structure.*/
};

typedef struct __dirstream DIR;

struct dirent：包含一个文件或目录信息的结构体。

struct dirent
{
    long d_ino;                 /* inode number 索引节点号 */
    off_t d_off;                /* offset to this dirent 在目录文件中的偏移 */
    unsigned short d_reclen;    /* length of this d_name 文件名长 */
    unsigned char d_type;       /* the type of d_name 文件类型 */    
    char d_name [NAME_MAX+1];   /* file name 文件名，最长255字符 */
}

DIR* opendir(const char* dirname);
/* 打开一个目录：
        成功 - 返回指向DIR类型对象的指针。
        失败 - 返回NULL    */

int closedir(DIR *dirp);
/* 关闭目录流：
        成功 - 返回0
        失败 - 返回-1    */

struct dirent *readdir(DIR *dirp);
/* 读取目录流：
        成功 - 返回指向struct dirent对象的指针。
        失败 - 返回NULL（出错或流末尾）  */

int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result);
/* 读取目录流：用 dirp 当前位置的目录初始化entry，并让 result 指向 entry。
        成功 - 返回0
        失败 - 返回error number   */

void rewinddir(DIR *dirp);
/* 重置目录流的位置到开头 */

void seekdir(DIR *dirp, long int loc);
/* 设置目录流的位置，设置以后readdir()会读取到loc位置的目录。 */

long int telldir(DIR *dirp);
/* 返回目录流的当前位置 */

#endif

int translat(char c)
{
	if(c <= '9'&&c >= '0')
		return 1;
	else
		return -1;
}

// 判断字符串是否是数字
int isStringNum(char *str)
{
	int length = strlen(str);
	int i,n=0;
	int cnt=0;
	if(length == 0)
		return 0;
	
	for(i=0; i<length; i++) {
		cnt += translat(str[i]);
	}

	if(cnt == length)
		return 1;
	else
		return -1;
}

void ShowHelp(void)
{
	printf("show this help:\n");
	printf("  -h : show this help\n");
	printf("  -a : cat all pid all message\n");
	printf("  -c : cycle yes or not, 0 for not, 1 for yes\n");
	printf("  -n : process name\n");
	printf("  -p : pid number\n");
	printf("  -r : pid rang, pid_min ~ pid_max\n");
	printf("  -s : cat status, VmSize VmRSS VmPeak etc\n");
	printf("\n");
	
	// 命令控制只能采用以下的格式
	printf("for example:\n");
	printf("  ./rdstatus -h\n");		// flag = 1
	printf("  ./rdstatus -c 1 -a\n");	// flag = 2
	printf("  ./rdstatus -c 1 -n init -s VmSize\n");// flag = 3
	printf("  ./rdstatus -c 1 -p 1 -s VmSize\n");		// flag = 4
	printf("  ./rdstatus -c 1 -r 51 77 -s VmSize\n");	// flag = 5
	printf("\n");
	
	printf("argument number must 1 & 4 & 7 or more & 8 or more\n");
}

int GetRdFlag(int l_argc, char **l_argv)
{
	int flag = 1;

	if(l_argc == 2)
		flag = 1;
	else if(l_argc == 4)
		flag = 2;
	else if((l_argc >= 7) && (!strcmp(l_argv[3], "-n")))
		flag = 3;
	else if((l_argc >= 7) && (!strcmp(l_argv[3], "-p")))
		flag = 4;
	else if((l_argc >= 8) && (!strcmp(l_argv[3], "-r")))
		flag = 5;
	else
		flag = 1;

	return flag;
}


// 通过 process name 判断与当前 pid 是否匹配
int isProcessMatchPid(char *pid, char *name)
{
	char path[CMD_NAME_MAX];
	int ret = 0;
	int fd = 0;
	char rd_buf[RD_BUFFER_MAX];

	//printf("pid = %s, process_name = %s\n", pid, name);
	sprintf(path, "/proc/%s/status", pid);
	//printf("path = %s\n", path);

	fd = open(path, O_RDWR);
	if(fd < 0) {
		printf("open %s error\n", path);
		return -1;
	}
	ret = read(fd, rd_buf, 30);
	//printf("rd_buf = %s\n", rd_buf);
	if(strstr(rd_buf, name) != NULL){
		//printf("Match process name ok\n");
		close(fd);
		return 1;
	} else {
		//printf("Match process name failure\n");
		close(fd);
		return -1;
	}
	
}


void SetCmd(int l_argc, char **l_argv, char *path, char *cmd, char *name)
{
	int j = 0;
	strcpy(path, PROC_DIR_PATH);		// 调用 strcpy() 可重新定位到 status_path 的开头处
	strcat(path, "/");
	strcat(path, name);
	strcat(path, "/");
	strcat(path, "status");				// 只支持读取 /proc/[pid]/status 的内容

	// 确定执行的命令
	strcpy(cmd, "cat ");
	strcat(cmd, path);

	strcat(cmd, "| grep -E 'Name");		// 固定显示 Name 字段
	strcat(cmd, "|");
	for(j=6; j<l_argc; j++) {
		strcat(cmd, l_argv[j]);			// 获取 -s 之后的内容
		if(j != (l_argc-1))			// 最后不添加 '|'
			strcat(cmd, "|");
	}
	strcat(cmd, "'");
	//printf("cmd = %s\n", cmd);
}

int main(int argc, char **argv)
{
	DIR *dp;
	struct dirent *dirp;
	int dir_num = 0;						// /proc 目录下总的文件数
	int i = 0;
	int j = 0;
	int ret = 0;
	int pid_min = 0;						// pid 进程最大值
	int pid_max = 0;						// pid 进程最大值
	int pid = 0;
	int temp_pid = 0;
	int rd_flag = 0;						// 读取的方式标记
	int cycle_flag = 0;					// 循环读取标记
	char dir_name[DIR_MAX][DIR_NAME_MAX];	// 存放 /proc 目录下所有的文件名
	char temp_name[DIR_NAME_MAX];
	char process_name[DIR_NAME_MAX];		// 进程名称
	char status_path[DIR_NAME_MAX];			// 保存 /proc/[pid]/status 的路径
	char cmd[CMD_NAME_MAX];					// 执行的命令

	rd_flag = GetRdFlag(argc, argv);
	if(rd_flag <= 1) {
		ShowHelp();
		return 0;
	}
	//printf("rd_flag = %d\n", rd_flag);

	// 获取循环标记
	cycle_flag = atoi(argv[2]);
	//printf("cycle_flag = %d\n", cycle_flag);
	if(cycle_flag < 0 || cycle_flag > 1) {
		printf("cycle_flag error, please check it!\n");
		return -1;
	}
	
	switch(rd_flag) {
		case 3:
			strcpy(process_name, argv[4]);
			//printf("process = %s\n", process_name);
			break;
		case 4:
			pid = atoi(argv[4]);
			//printf("pid = %d\n", pid);
			break;
		case 5:
			pid_min = atoi(argv[4]);
			pid_max = atoi(argv[5]);
			//printf("pid_min = %d, pid_max = %d\n", pid_min, pid_max);
			if(pid_min > pid_max){
				printf("pid range error, please check it\n");
				return -1;
			}
			break;
		default:
			break;
	}

	if((dp = opendir(PROC_DIR_PATH)) == NULL)
		printf("Can't open %s\n", PROC_DIR_PATH);

	while((dirp = readdir(dp)) != NULL) {
		strcpy(&dir_name[dir_num++][0], dirp->d_name);
	}

	//printf("dir_num = %d\n", dir_num);

	do {
		for(i=0; i<dir_num; i++) {
			strcpy(temp_name, &dir_name[i][0]);
			ret = isStringNum(temp_name);
			if(ret == 1) {								// 获取 /proc/[pid] 成功
				temp_pid = atoi(temp_name);
				//printf("temp_pid = %d\n", temp_pid);
				if(rd_flag == 3) {
					ret = isProcessMatchPid(temp_name, argv[4]);
					if(ret > 0) {
						//printf("Process match pid ok\n");
						SetCmd(argc, argv, status_path, cmd, temp_name);
						system(cmd);
						printf("\n");
						break;
					}
				}
				else if(rd_flag == 4 && temp_pid == pid) {	// 通过 pid 来 cat 状态
					SetCmd(argc, argv, status_path, cmd, temp_name);
					system(cmd);
					printf("\n");
					break;
				}else if(rd_flag == 5 && (temp_pid >= pid_min && temp_pid <= pid_max)) {	// 通过 pid 范围 cat 状态
					SetCmd(argc, argv, status_path, cmd, temp_name);
					system(cmd);
					printf("\n");
				}
			}
		}
		sleep(1);
		printf("===================\n");
	}while(cycle_flag == 1);
	
	closedir(dp);
	return 0;
}
#endif
深入理解/proc/pid进程目录
悦分享
10-17 232
Linux 内核提供了一种通过 proc 文件系统，在运行时访问内核内部数据结构、改变内核设置的机制。proc 文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。用户和应用程序可以通过 proc 得到系统的信息，并可以改变内核的某些参数。由于系统的信息，如进程，是动态改变的，所以用户或应用程序读取 proc 文件时，proc 文件系统是动态从系统内核读出所需信息并提交的。
解析进程 /proc/pid/maps 和 /proc/pid/smaps
weixin_42136255的博客
03-08 3928
就是当进程申请内存的时候，Linux会给他先分配页，但是并不会区建立页与页框的映射关系，意思就是说并不会分配物理内存，而当真正使用的时候，就会产生一个缺页异常，硬件跳转page fault处理程序执行，在其中分配物理内存，然后修改页表(创建页表项)。查看该page的引用数，如果引用>1，则归为shared，如果是1，则归为private，同时也查看该page的flag，是否标记为_PAGE_DIRTY，如果不是，则认为干净的。对匿名映射来说，因为没有文件在磁盘上，所以没有设备号，始终为00:00。
Linux proc/%d/stat文件详解
xhh198781的专栏
04-18 2273
Linux stat文件。也终于弄明白了这一堆堆砌的数字的意思。 　　[root@localhost ~]# cat /proc/6873/stat 　　6873 (a.out) R 6723 6873 6723 34819 6873 8388608 77 0 0 0 41958 31 0 0 25 0 3 0 5882654 1409024 56 4294967295 134512640 1
Linux查询进程名称命令
最新发布
Leon_Jinhai_Sun的博客
06-06 582
或将<PID>替换为你要查询的实际进程ID即可。
Linux /proc/pid目录下相应文件的信息说明和含义
热门推荐
Enweitech Software Works
11-29 2万+
Proc是一个虚拟文件系统，在Linux系统中它被挂载于/proc目录之上。Proc有多个功能 ，这其中包括用户可以通过它访问内核信息或用于排错，这其中一个非常有 用的功能，也是Linux变得更加特别的功能就是以文本流的形式来访问进程信息。很Linux命令(比如 ps、toPpstree等)都需要使用这个文件系统的信息。注意，本文就是向用户介绍一些访问这些信息的方法 。需要说明的是，本文所述的内容
Linux系统下/proc/[pid] 目录各文件简析
Enweitech Software Works
12-27 1873
Linux 内核提供了一种通过 proc 文件系统，在运行时访问内核内部数据结构、改变内核设置的机制。proc 文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。 用户和应用程序可以通过 proc 得到系统的信息，并可以改变内核的某些参数。由于系统的信息，如进程，是动态改变的，所以用户或应用程序读取 proc 文件时，proc
使用proc查看进程属性
唐顺才的博客
09-30 1406
写本篇博客的初衷 我有一个阿里云ECS，给一个师妹也开了一个账号，最近发现可能重启比较严重。刚好在测试自己写的一个文件存储网络，ssh断开后一下子忘记了源码目录了。 ssh重连后，发现进程是daemon。这就放心了。可执行文件还在，那么源码应该也是在的。 先获取进程id [root@localhost ~]# ps -aux | grep ipfs root 13115 0.0 0.0...
/proc/$pid/目录的内核源码实现
leiyanjie8995的博客
03-06 653
而我们的/proc/$pid/stat里的RSS，没有包括换出的页面，所以是当前实际占用的物理内存。proc_tgid_stat又调用了do_task_stat接口，这个接口里可以与我们实际cat /proc/$pid/stat的结果相对应。get_mm_rss(mm)的实现接口如下。以/proc/$pid/stat为例，找到"stat"这一项，stat的数据就是通过proc_tgid_stat命令生成。/proc/$pid/目录作为基础的proc文件系统操作，是在fs/proc中注册的。
Linux中 /proc/＜pid＞/stat文件解释
u011002533的博客
04-07 1731
本文解释了 /proc伪文件系统中每个进程目录下stat文件中参数的意义。 系统环境: Ubuntu18.04 内核版本：忘了 以下是一个例子： /proc/<pid>/stat 646 (process-exporte) S 1 646 646 0 -1 1077936384 3792 0 76 0 14826 4425 0 0 20 0 5 0 559 437231616 5297 18446744073709551615 4194304 8660528 1407230905278.
android进程分析,android单进程CPU使用/proc/[pid]/stat文件分析
weixin_29219539的博客
05-25 795
pid=6873 进程(包括轻量级进程，即线程)号comm=a.out 应用程序或命令的名字task_state=R 任务的状态，R:runnign, S:sleeping (TASK_INTERRUPTIBLE),D:disk sleep (TASK_UNINTERRUPTIBLE), T: stopped, T:tracingstop,Z:zombie, X:deadppid=6723 父进程...
认识/proc/[pid]/
Gean的博客
05-06 399
/proc/[pid]/是干什么的？ 系统中当前运行的每一个进程都有对应的一个目录在proc下，以进程的PID号为目录名，它们是读取进程信息的接口。 /proc/[pid]/下的文件作用 参考《Linux就该这么学》 我这里稍微提一下： cmdline、exe 这两个可以找到执行的参数与执行的程序位置(就算已经被删除也能看到)。 environ 可以看到这个进程所使用的环境变量 fd 这个目录可...
/proc/pid目录下文件的含义
唐武的博客
12-27 558
attr: 进程的属性   cmdline： 启动进程时执行的命令   cwd: 指向进程当前工作目录的软链   environ： 进程执行时使用的环境变量，文件内容使用null字节（'\0'）分隔，然后以null字节结束。因此获取进程使用的环境变量使用如下： (cat /proc/pid/environ; echo) | tr '\000' '\n'   fd:  此...
【安全】【Linux】通过/proc/pid/获取进程信息
追寻梦想的青春
11-30 2725
proc/pid中包含了进程的许多信息，这些信息可以供用户查看，也可以供程序读取，程序可以从这里获取到进程的文件、网络等信息并进行分析，但是，频繁读取也可能影响业务性能。
/proc/pid文件夹理解--转
legend050709的专栏
11-15 266
111
了解/proc/{pid}/目录
wt_better的博客
01-20 659
在Linux系统中，每个运行中的进程在/proc/{pid}/目录下都有一些虚拟文件，用于提供进程的各种信息。
深度剖析Linux进程的内部机制：一探/proc/pid的奥秘
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
03-28 4880
深度剖析Linux进程的内部机制：一探/proc/pid的奥秘
Linux /proc/pid 文件目录解析
Jogger_Ling的专栏
04-26 1573
Linux 内核提供了一种通过 proc 文件系统，在运行时访问内核内部数据结构、改变内核设置的机制。proc 文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。 用户和应用程序可以通过 proc 得到系统的信息，并可以改变内核的某些参数。由于系统的信息，如进程，是动态改变的，所以用户或应用程序读取 proc 文件时，proc 文件系统是动态从系统内核读出所需信息并提交的。 /proc/[pid]/auxv 包含传递给进程的 ELF 解释
/proc/{pid}/stat 文件说明
QCZL_CC的博客
01-26 5002
在 Linux 系统中，/proc是一个虚拟文件系统，它提供了大量关于系统和正在运行的进程的信息。是其中一个文件，它提供了关于指定进程 ID（PID）的详细状态信息。
linux查看进程信息proc,linux怎么查看进程启动,用户的工作目录,pwdx,/proc/11256/cwd
weixin_29061509的博客
05-02 999
#pwdx pid号1 [pid2] ....在linux实际操作命令中，查看pid的方式有很多种，通过pid找程序路径的方式也有好几个，但是可能大家都忽略的一个很简单也是很实用的命令：pwdx.比如要查找某个java编写的程序运行情况可通过jps命令查看，然后可以通过显示的pid进行程序定位如下图，红色框框为jps命令和pwdx命令，一目了然：------------------------...
/proc 查看进程详细信息 怎么查看
08-17
要查看特定进程的详细信息，你可以使用以下命令： 1. 首先，使用`ps`命令来获取正在运行的进程的PID（进程ID）列表。例如，`ps aux | grep <进程名称>`可以列出与指定进程名称相关的进程。注意，`<进程名称>`要替换为你要查找的实际进程名称。 2. 一旦你获得了要查看的进程的PID，你可以使用`/proc/<PID>`目录来查看该进程的详细信息。例如，要查看PID为1234的进程的信息，可以运行`cat /proc/1234/status`来查看该进程的状态信息。 在`/proc/<PID>`目录下，你可以找到很多有用的文件，包括： - `status`：包含有关进程状态、内存使用等的信息。 - `cmdline`：显示进程启动时的命令行参数。 - `cwd`：显示进程当前工作目录。 - `exe`：指向进程可执行文件的符号链接。 - `environ`：包含进程环境变量的文件。 请注意，`/proc`目录下的文件和目录仅对具有足够权限的用户可见。此外，注意确保你查看的是正确的进程信息，以免对系统造成不必要的影响。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值