keepalived源码浅析——Memory 内存管理

最新推荐文章于 2021-09-13 23:07:37 发布
原创 最新推荐文章于 2021-09-13 23:07:37 发布 · 1.8k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了Memory模块的功能，包括内存分配和释放的封装，以及在debug模式下如何通过打印文件名、函数名等信息来帮助定位内存泄漏的位置。此外，还提供了Memory模块中关键函数如malloc、free和realloc的具体实现细节。

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

Memory模块的作用：封装了内存申请和释放函数，打印文件、函数、申请内存大小、代码行数等信息，dubug模式下定位内存泄露位置。

Memory.h源码：

#ifndef _MEMORY_H
#define _MEMORY_H

/* system includes */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

/* extern types */
extern unsigned long mem_allocated;
extern void *xalloc(unsigned long size);
extern void *zalloc(unsigned long size);
extern void xfree(void *p);

/* Global alloc macro */
#define ALLOC(n) (xalloc(n))

/* Local defines */
#ifdef _DEBUG_

#define MAX_ALLOC_LIST 2048

#define MALLOC(n)    ( keepalived_malloc((n), \
                      (__FILE__), (char *)(__FUNCTION__), (__LINE__)) )
#define FREE(b)      ( keepalived_free((b), \
                      (__FILE__), (char *)(__FUNCTION__), (__LINE__)) )
#define REALLOC(b,n) ( keepalived_realloc((b), (n), \
                      (__FILE__), (char *)(__FUNCTION__), (__LINE__)) )

/* Memory debug prototypes defs */
extern char *keepalived_malloc(unsigned long, char *, char *, int);
extern int keepalived_free(void *, char *, char *, int);
extern void *keepalived_realloc(void *, unsigned long, char *, char *, int);
extern void keepalived_free_final(char *);

#else

#define MALLOC(n)    (zalloc(n))
#define FREE(p)      (xfree(p))
#define REALLOC(p,n) (realloc((p),(n)))

#endif

/* Common defines */
#define FREE_PTR(P) if((P)) FREE((P));

#endif


 

Memory.c源码：

#include "memory.h"
#include "utils.h"

/* Global var */
unsigned long mem_allocated;	/* Total memory used in Bytes */

void *
xalloc(unsigned long size)
{
	void *mem;
	if ((mem = malloc(size)))
		mem_allocated += size;
	return mem;
}

void *
zalloc(unsigned long size)
{
	void *mem;
	if ((mem = malloc(size))) {
		memset(mem, 0, size);
		mem_allocated += size;
	}
	return mem;
}

void
xfree(void *p)
{
	mem_allocated -= sizeof (p);
	free(p);
	p = NULL;
}

/* KeepAlived memory management. in debug mode,
 * help finding eventual memory leak.
 * Allocation memory types manipulated are :        //内存泄露类型
 *
 * +type+--------meaning--------+
 * ! 0  ! Free slot             !
 * ! 1  ! Overrun               !
 * ! 2  ! free null             !
 * ! 3  ! realloc null          !
 * ! 4  ! Not previus allocated !
 * ! 8  ! Last free list        !
 * ! 9  ! Allocated             !
 * +----+-----------------------+
 *
 * global variabel debug bit 9 ( 512 ) used to
 * flag some memory error.
 *
 */

#ifdef _DEBUG_

typedef struct {
	int type;
	int line;
	char *func;
	char *file;
	void *ptr;
	unsigned long size;
	long csum;
} MEMCHECK;

/* Last free pointers */
static MEMCHECK free_list[256];

static MEMCHECK alloc_list[MAX_ALLOC_LIST];  //结构体数组
static int number_alloc_list = 0;
static int n = 0;		/* Alloc list pointer */
static int f = 0;		/* Free list pointer */

char *
keepalived_malloc(unsigned long size, char *file, char *function, int line) //内存申请
{
	void *buf;
	int i = 0;
	long check;

	buf = zalloc(size + sizeof (long));

	check = 0xa5a5 + size;
	*(long *) ((char *) buf + size) = check;

	while (i < number_alloc_list) {
		if (alloc_list[i].type == 0)
			break;
		i++;
	}

	if (i == number_alloc_list)
		number_alloc_list++;

	assert(number_alloc_list < MAX_ALLOC_LIST);

	alloc_list[i].ptr = buf;
	alloc_list[i].size = size;
	alloc_list[i].file = file;
	alloc_list[i].func = function;
	alloc_list[i].line = line;
	alloc_list[i].csum = check;
	alloc_list[i].type = 9;

	if (debug & 1)
		printf("zalloc[%3d:%3d], %p, %4ld at %s, %3d, %s\n",
		       i, number_alloc_list, buf, size, file, line,
		       function);

	n++;
	return buf;
}

int
keepalived_free(void *buffer, char *file, char *function, int line)  //内存释放
{
	int i = 0;
	void *buf;

	/* If nullpointer remember */
	if (buffer == NULL) {
		i = number_alloc_list++;

		assert(number_alloc_list < MAX_ALLOC_LIST);

		alloc_list[i].ptr = buffer;
		alloc_list[i].size = 0;
		alloc_list[i].file = file;
		alloc_list[i].func = function;
		alloc_list[i].line = line;
		alloc_list[i].type = 2;
		if (debug & 1)
			printf("free NULL in %s, %3d, %s\n", file,
			       line, function);

		debug |= 512;	/* Memory Error detect */

		return n;
	} else
		buf = buffer;

	while (i < number_alloc_list) {
		if (alloc_list[i].type == 9 && alloc_list[i].ptr == buf) {
			if (*
			    ((long *) ((char *) alloc_list[i].ptr +
				       alloc_list[i].size)) ==
			    alloc_list[i].csum)
				alloc_list[i].type = 0;	/* Release */
			else {
				alloc_list[i].type = 1;	/* Overrun */
				if (debug & 1) {
					printf("free corrupt, buffer overrun [%3d:%3d], %p, %4ld at %s, %3d, %s\n",
					       i, number_alloc_list,
					       buf, alloc_list[i].size, file,
					       line, function);
					dump_buffer(alloc_list[i].ptr,
						    alloc_list[i].size + sizeof (long));
					printf("Check_sum\n");
					dump_buffer((char *) &alloc_list[i].csum,
						    sizeof(long));

					debug |= 512;	/* Memory Error detect */
				}
			}
			break;
		}
		i++;
	}

	/*  Not found */
	if (i == number_alloc_list) {
		printf("Free ERROR %p\n", buffer);
		number_alloc_list++;

		assert(number_alloc_list < MAX_ALLOC_LIST);

		alloc_list[i].ptr = buf;
		alloc_list[i].size = 0;
		alloc_list[i].file = file;
		alloc_list[i].func = function;
		alloc_list[i].line = line;
		alloc_list[i].type = 4;
		debug |= 512;

		return n;
	}

	if (buffer != NULL)
		xfree(buffer);

	if (debug & 1)
		printf("free  [%3d:%3d], %p, %4ld at %s, %3d, %s\n",
		       i, number_alloc_list, buf,
		       alloc_list[i].size, file, line, function);

	free_list[f].file = file;
	free_list[f].line = line;
	free_list[f].func = function;
	free_list[f].ptr = buffer;
	free_list[f].type = 8;
	free_list[f].csum = i;	/* Using this field for row id */

	f++;
	f &= 255;
	n--;

	return n;
}

void
keepalived_free_final(char *banner) //定位内存泄露位置
{
	unsigned int sum = 0, overrun = 0, badptr = 0;
	int i, j;
	i = 0;

	printf("\n---[ Keepalived memory dump for (%s)]---\n\n", banner);

	while (i < number_alloc_list) {
		switch (alloc_list[i].type) {
		case 3:
			badptr++;
			printf
			    ("null pointer to realloc(nil,%ld)! at %s, %3d, %s\n",
			     alloc_list[i].size, alloc_list[i].file,
			     alloc_list[i].line, alloc_list[i].func);
			break;
		case 4:
			badptr++;
			printf
			    ("pointer not found in table to free(%p) [%3d:%3d], at %s, %3d, %s\n",
			     alloc_list[i].ptr, i, number_alloc_list,
			     alloc_list[i].file, alloc_list[i].line,
			     alloc_list[i].func);
			for (j = 0; j < 256; j++)
				if (free_list[j].ptr == alloc_list[i].ptr)
					if (free_list[j].type == 8)
						printf
						    ("  -> pointer allready released at [%3d:%3d], at %s, %3d, %s\n",
						     (int) free_list[j].csum,
						     number_alloc_list,
						     free_list[j].file,
						     free_list[j].line,
						     free_list[j].func);
			break;
		case 2:
			badptr++;
			printf("null pointer to free(nil)! at %s, %3d, %s\n",
			       alloc_list[i].file, alloc_list[i].line,
			       alloc_list[i].func);
			break;
		case 1:
			overrun++;
			printf("%p [%3d:%3d], %4ld buffer overrun!:\n",
			       alloc_list[i].ptr, i, number_alloc_list,
			       alloc_list[i].size);
			printf(" --> source of malloc: %s, %3d, %s\n",
			       alloc_list[i].file, alloc_list[i].line,
			       alloc_list[i].func);
			break;
		case 9:
			sum += alloc_list[i].size;
			printf("%p [%3d:%3d], %4ld not released!:\n",
			       alloc_list[i].ptr, i, number_alloc_list,
			       alloc_list[i].size);
			printf(" --> source of malloc: %s, %3d, %s\n",
			       alloc_list[i].file, alloc_list[i].line,
			       alloc_list[i].func);
			break;
		}
		i++;
	}

	printf("\n\n---[ Keepalived memory dump summary for (%s) ]---\n", banner);
	printf("Total number of bytes not freed...: %d\n", sum);
	printf("Number of entries not freed.......: %d\n", n);
	printf("Maximum allocated entries.........: %d\n", number_alloc_list);
	printf("Number of bad entries.............: %d\n", badptr);
	printf("Number of buffer overrun..........: %d\n\n", overrun);

	if (sum || n || badptr || overrun)
		printf("=> Program seems to have some memory problem !!!\n\n");
	else
		printf("=> Program seems to be memory allocation safe...\n\n");
}

void *
keepalived_realloc(void *buffer, unsigned long size, char *file, char *function,
		   int line)
{
	int i = 0;
	void *buf, *buf2;
	long check;

	if (buffer == NULL) {
		printf("realloc %p %s, %3d %s\n", buffer, file, line, function);
		i = number_alloc_list++;

		assert(number_alloc_list < MAX_ALLOC_LIST);

		alloc_list[i].ptr = NULL;
		alloc_list[i].size = 0;
		alloc_list[i].file = file;
		alloc_list[i].func = function;
		alloc_list[i].line = line;
		alloc_list[i].type = 3;
		return keepalived_malloc(size, file, function, line);
	}

	buf = buffer;

	while (i < number_alloc_list) {
		if (alloc_list[i].ptr == buf) {
			buf = alloc_list[i].ptr;
			break;
		}
		i++;
	}

	/* not found */
	if (i == number_alloc_list) {
		printf("realloc ERROR no matching zalloc %p \n", buffer);
		number_alloc_list++;

		assert(number_alloc_list < MAX_ALLOC_LIST);

		alloc_list[i].ptr = buf;
		alloc_list[i].size = 0;
		alloc_list[i].file = file;
		alloc_list[i].func = function;
		alloc_list[i].line = line;
		alloc_list[i].type = 9;
		debug |= 512;	/* Memory Error detect */
		return NULL;
	}

	buf2 = ((char *) buf) + alloc_list[i].size;

	if (*(long *) (buf2) != alloc_list[i].csum) {
		alloc_list[i].type = 1;
		debug |= 512;	/* Memory Error detect */
	}
	buf = realloc(buffer, size + sizeof (long));

	check = 0xa5a5 + size;
	*(long *) ((char *) buf + size) = check;
	alloc_list[i].csum = check;

	if (debug & 1)
		printf("realloc [%3d:%3d] %p, %4ld %s %d %s -> %p %4ld %s %d %s\n",
		       i, number_alloc_list, alloc_list[i].ptr,
		       alloc_list[i].size, file, line, function, buf, size,
		       alloc_list[i].file, alloc_list[i].line,
		       alloc_list[i].func);

	alloc_list[i].ptr = buf;
	alloc_list[i].size = size;
	alloc_list[i].file = file;
	alloc_list[i].line = line;
	alloc_list[i].func = function;

	return buf;
}

#endif



调用位置

main.c中的stop_keepalived函数

#ifdef _DEBUG_
	keepalived_free_final("Parent process");
#endif


check_daemon.c中的stop_check函数

#ifdef _DEBUG_
 keepalived_free_final("Healthcheck child process");
#endif


 

vrrp_daemon.c中的stop_vrrp函数

#ifdef _DEBUG_
	keepalived_free_final("VRRP Child process");
#endif



 

 


 

2、keepalived安装及高可用配置
xuebo1129927648的博客
05-24 397
bash。
keep-alive的源码解析
weixin_48485503的博客
10-23 1314
​ keep-alive是一个vue内置组件，但是是一个抽象组件，不会出现在父组件链中，也不会在DOM中渲染
keepalived源码解析 —— main()
傲然君
02-10 1875
1、入口函数 /* keepalived/main.c */ int main(int argc, char **argv) { return keepalived_main(argc, argv); } /* ./keepalived/core/main.c */ /* Entry point */ int keepalived_main(int argc, char **argv) { ...
keepalived源码浅析——Html
wdt3385的专栏
07-23 1383
Html.h 源码： parse.c中包含 check中的http方式中用到 #ifndef _HTML_H #define _HTML_H /* HTTP header tag */ #define CONTENT_LENGTH "Content-Length:" // HTTP头标志 例如Content-Length:682L 后面接着换行 /* Prototy
keepalived源码浅析——日志
wdt3385的专栏
07-23 2103
源码： #include #include #include /* Boolean flag - send messages to console as well as syslog */ static int log_console = 0; //是否发送信息到控制台 void enable_console_log(void) { log_console = 1; } void
keep-alive源码分析
weixin_45645373的博客
09-13 539
keep-alive的源码不到两百行，比较简单，这里做一个简单的源码分析 vue/src/component/keep-alive.js keep-alive允许传入include,exclude,以及max缓存的最大数量 props: { include: patternTypes, exclude: patternTypes, max: [String, Number] }, 在初始化时，定义一个cache对象和一个keys数组 created () { this.
keepalived源码解析 —— vrrp_dispatcher_read()
傲然君
02-07 646
vrrp 线程会不断调用 vrrp_dispatcher_read() 获取 vrrp 通告： 1、调用 recvmsg()，获取 vrrp 通告； 2、获取 vrrp 头； 3、根据 vrrp 头中的 VRID，判断本端 vrrp 与 对端 vrrp 是否处于同一个虚拟路由； 4、若两端不处于同一个虚拟路由下，则丢弃该通告； 5、根据本端 vrrp 当前状态（master/back），对通告进行...
keepalived源码解析 —— vrrp_dispatcher_read_timeout
傲然君
02-12 1261
当 vrrp socket 发生 读超时时，会调用函数：vrrp_dispatcher_read_timeout()。 1、依据当前 master/back 状态，进行处理。若 back 发生读超时，则尝试将本端 vrrp 切换到 master； /* Handle dispatcher read timeout */ static int vrrp_dispatcher_read_timeout...
keepalived源码解析 —— start_vrrp()
傲然君
02-05 1138
/* 启动 vrrp 1、清除配置 2、初始化全局对象 global_data 3、创建 vrrp_data_t *vrrp 4、读取配置文件 5、创建 event（vrrp_dispatcher_init为回调函数），并添加至 master->event 所指向的双向链表中 */ static void start_vrrp(data_t *prev_global_data) { /* ...
keepalived源码解析 —— vrrp_state_backup()
傲然君
02-08 917
功能： 1、分析收到的 vrrp 包。若包分析返回结果：VRRP_PACKET_OK，则直接返回 false； 2、若未开启抢占模式（抢占模式只在 back 状态下有效） 或 对端 vrrp 优先级 >= 本端 vrrp 优先级， 则将对端 vrrp address 与优先级标记为为 master address 与优先级，同时本端 vrrp 继续保持 back 状态； 3、若开启了抢占模式...
keepalived源码浅析——Global_data全局数据解析
wdt3385的专栏
07-23 2207
全局定义模块作用：解析全局模块数据 #全局定义块 global_defs {    notification_email {  #指定keepalived在发生切换时需要发送email到的对象，一行一个     sysadmin@fire.loc    }    notification_email_from Alexandre.Cassen@firewall.loc #指定发件人
keepalived源码浅析——SSL engine
wdt3385的专栏
07-23 1865
ssl.h源码： #ifndef _SSL_H #define _SSL_H #include /* Prototypes */ extern void init_ssl(void); extern int ssl_connect(thread_t *); extern int ssl_printerr(int); extern int ssl_send_request(
keepalived源码浅析——sock
wdt3385的专栏
07-23 1698
sock.h 源码   #ifndef _SOCK_H #define _SOCK_H /* system includes */ #include //需包含openssl库 #include /* Engine socket pool element structure */ //sock 池 元素的结构体 typedef struct { int fd;
keepalived源码解析 —— alloc_global_data()
傲然君
02-03 463
alloc_global_data() 用于初始化全局对象：struct data_t global_data。（global_data.c） 其中，包括 set_default_mcast_group() 设置 vrrp 使用的IPV4（224.0.0.18）与 IPV6（ff02::12）组播地址。（global_data.c， data_t.vrrp_mcast_group4、data_t....
keepalived源码解析 —— start_vrrp_child()
傲然君
02-03 1215
/* 创建vrrp子进程，实现vrrp协议，负责keepalived主要的事件的调度。*/ int start_vrrp_child(void) { #ifndef _ONE_PROCESS_DEBUG_ pid_t pid; const char *syslog_ident; /* Initialize child process */ #ifdef ENABLE_LOG_TO_FILE...
keep-alive 源码的理解
看把你给能的。
08-12 694
keep-alive 概念 keep-alive 是 Vue 的内置组件，当它包裹动态组件时，会缓存不活动的组件实例，而不是销毁它们。keep-alive 是一个抽象组件：它自身不会渲染成一个 DOM 元素，也不会出现在父组件链中。 keep-alive 组件中name选项作用 项目使用 keep-alive 时，可搭配组件 name 进行缓存过滤 DOM 做递归组件时需要调用自身 name vue-devtools 调试工具里显示的组见名称是由vue中组件name决定的 keep-alive 基础用法
keepalived源码浅析——Daemon进程
wdt3385的专栏
07-24 2741
守护进程，也就是通常说的Daemon进程，是Linux中的后台服务进程。它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程常常在系统引导装入时启动，在系统关闭时终止。Linux系统有很多守护进程，大多数服务都是通过守护进程实现的，同时，守护进程还能完成许多系统任务，例如，作业规划进程crond、打印进程lqd等（这里的结尾字母d就是Daemon的
keepalived源码解析 —— parser.c
傲然君
02-04 893
1、strspn 与 strcspn： size_t strspn(const char *str1, const char *str2)：查找 str1 中第一个不出现在 str2 的字符的下标。 size_t strcspn(const char *s, const char * reject)：从字符串 s 的第一个字符开始，计算连续多少个字符不在 reject 所指的字符串中。返回值：连续...
守护进程的创建-keepalived源码解析
xuzhouweihao的专栏
11-09 1978
在keepalived处理中，包含三个进程，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值