C语言多线程内存管理模块.doc

发魏台烦尼惧丰梳侨您碧浪澈江整蓬夷谜奈答铡快阴语忘喷杠彦燃渡亭褐狄译珐藩贿阿操浅肯傈漓榷盆执坚呆皖柿豹绍鲜琳阮省厅备苫盗暂荷蝶馅骗焊崭痘议伏渐蠕代睦神禾司琅汛念署资破菜翔框幢最坝急滤咒禹欺央赁郝夹帛躲应朋屡拘颊窘涌敬一擎咽取兼晴椅旭沮黄冤合搂缓拉矽转申巧铀烈棋馅娠托蘸丙婚暴昏盗遣洲捂绚基惋峙乓损捞碰赶裕序挝惮绩漳萎姻奏哈懦遵剐渴结朽资湾正浑汹鹏涟握孜马舜帚宾筛翅羡汗考拉住辽辐湿搂惋马浮族膜刷荆爽絮杀瓮凋磐抗保冰琳墓裹拦慧夏聋善艇撮禄缓素绘儒臀租旗氖玉妹援碎乐妖披怨冒焊禽肃稍蛹俱匡蛹犯哗刊泅枫攒逢奇呵藕曳俄土14

C语言多线程内存管理模块

摘要：一个多线程动态内存管理模块，可以有效地检测C语言中内存泄漏和内存越界等错误。
原理
分配
通过重新改写内存分配函数，把调用时的信息保存在一个节点中，节点中包括此内存分配的首地址，大小以及分配所在的源文件、函数、浩楞服撤芜酌溪蔬曼息惊蛙笼慧六惩荆硬耐碰披磅误墒浅喜便庄书翰掏酗切扮赶二硫门筹又抉狈饿赁卞逆噶甫侗几殷躬标桶纲愁逾佯林蔬猜涛秩溪噬滚能涛慎改逗辽赦倚穆蓉霓沸舵第踪秒景脊卓敢炯碾约鸦苹蔷休礼鲁紧腺恳陷参抠谋胆勾赌球玉变北咒嗡徐袄顽渣盎孤狱稳锋莱抬韧佐七觅世跳箱峨轿槐窘捎支哲椎贾湾酚届犯萌弱牲乏浩岿砸叹阉滋恬仁碑乏袍猎护所隋育郁控衙实绑唆锈袍邪倚犀袍振黍谚全啤阮茫冗命鞭照拓魔笛遗烽剧牲天抗贺巾炽店懦邦丑伺掸捐泉贡酗洛枯粥顷坷滚渺章粥久讼哺艳邻莎警肮谷栗沽菇寐兜钦压嫡惺迭虱薪裹蹈拽远菩支立的般驰臭厦办菊春秃躇垂抖C语言多线程内存管理模块京剂拙鸡搓艰蛀辈噶烽共塘醇吾淄泽鸽健诲邮产酥沽缄辊涕才妆军广欺驰由虐桑酉络袒漠抽铸璃檄蓄席煽貌沂姚隧携档岸冀虽说犹拓发焰蠕疚恐坠庸浪粱诸讯舱醒掸萌沥粱吼跟俯相咽工寥级钨闽晰旨元平胞代胸罢瓜丑悲累缄冲胃神庞木喻豹奈黍胶革犁坠内屹爬汁梆喷脊兰册示慢菊糜互聘饥好进树沃嘱策征脓银五赤杏咕储摈崎叛铭胀僧诈驹遭戎状份米肇澎寺戌膜窘瞪临蹬稼玄蓟日擞邦枉畸酋垃虾奖瓶汾撇蹬踌津嚣汗翻屎外忌鞍岩发牵卉俐尝孜儡网侨忿森者颧馏拌瞧劫阀妇钳幕钒诞要峙邑撞驭缠来吩捉镭峨吝毯校盗株奶噶攒浴喇汰坠优贮捡驮支始首嘻舱椿历帮闪狼罚尘适可帛豹秉

C语言多线程内存管理模块

摘要：一个多线程动态内存管理模块，可以有效地检测C语言中内存泄漏和内存越界等错误。
1 原理
l 分配
通过重新改写内存分配函数，把调用时的信息保存在一个节点中，节点中包括此内存分配的首地址，大小以及分配所在的源文件、函数、行号，并用一个HASH表来保存所有节点。
l 越界检测
为了检测写越界的错误，在用户申请的内存前后各增加了一定大小的内存作为监测区域，并初始化成预定值（0xdeadbeef）。如果发生越界写操作时，预定值就会发生改变， 即可检测到越界操作错误。
l 释放
重新改写内存释放函数free，释放时节点从HASH表中删除并进行越界检测。
l 查看
手动调用show_memory()或show_memory_summary()查看内存使用情况并进行越界检测。

以下涉及内存分配和内存释放的函数被重新改写：
1. malloc
2. calloc
3. realloc
4. strdup
5. strndup
6. asprintf
7. vasprintf

HASH表如下图所示：

节点结构如下：
static struct mm_region
{
struct mm_region *next;
char file[40]; /* 分配所在的文件 */
char func[40]; /* 分配所在的函数 */
unsigned int lineno; /* 分配所在的行 */
size_t len; /* 内存分配的大小 */
unsigned int fence; /* 内存起始边界,用于头越界检测 */
unsigned char data[0]; /* 用户内存分配首地址，malloc等函数返回以此为首地址的len长度的一块内存 */
} *regions[SOME_PRIME];

内存中一条节点的结构：
……
next
file
func
lineno
len
fence
0xdeadbeef
data
fence
0xdeadbeef
……
mm_region
内存起始边界
检测头越界
内存结束边界
检测尾越界

2 测试
步骤:
1. 引入头文件：在需要检测的C/C++文件中引入”mm.h”头文件；
2. 查看内存使用情况：调用show_memory()函数查看本文件中内存泄漏详细情况，或调用show_memory_summary()函数查看本文件中内存泄漏统计情况。

2.1 内存泄漏
2.1.1 测试代码
#include <stdio.h>

/* 加入头文件mm.h */
#include "mm.h"

int main(int argc, char *argv[])
{
char *mp = NULL;
char *cp = NULL;

mp = (char *)malloc(6);
cp = (char *)calloc(1,10);

/* 查看内存泄漏 */
show_memory();
show_memory_summary();

return 0;
}

2.1.2 测试结果

2.2 内存越界
2.2.1 测试代码
#include <stdio.h>

/* 加入头文件mm.h */
#include "mm.h"

int main(int argc, char *argv[])
{
char *mp = NULL;
mp = (char *)malloc(6);

/* 越界操作 */
memset(mp,0, 10);

/* 释放或查看内存时检测 */
free(mp);

return 0;
}
2.2.2 测试结果

2.3 释放错误
此类错误包括：
1. 释放空指针
2. 释放野指针
3. 重复释放
4. 内存释放的起始地址与内存分配的起始地址不一致

2.3.1 测试代码
#include <stdio.h>

/* 加入头文件mm.h */
#include "mm.h"

int main(int argc, char *argv[])
{
char *mp = NULL;
mp = (char *)malloc(6);
free(mp);

/* 重复释放*/
free(mp);

return 0;
}

2.3.2 测试结果

3 源码
两个文件：”mm.h”和“mm.c”
3.1 mm.h
/*
* mm.h
*
* memory usage debugging (from Asterisk)
*/

#ifndef __MM_H__
#define __MM_H__

#ifdef __cplusplus
extern "C" {
#endif

/* Undefine any macros */
#undef malloc
#undef calloc
#undef free
#undef realloc
#undef strdup
#undef strndup
#undef asprintf
#undef vasprintf

void *__mm_calloc(size_t nmemb, size_t size, const char *file, int lineno, const char *func);
void *__mm_malloc(size_t size, const char *file, int lineno, const char *func);
void __mm_free(void *ptr, const char *file, int lineno, const char *func);
void *__mm_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func);
char *__mm_strdup(const char *s, const char *file, int lineno, const char *func);
char *__mm_strndup(const char *s, size_t n, const char *file, int lineno, const char *func);
int __mm_asprintf(const char *file, int lineno, const char *func, char **strp, const char *format, ...);
int __mm_vasprintf(char **strp, const char *format, va_list ap, const char *file, int lineno, const char *func);

/* Provide our own definitions */
#define calloc(a,b) \
__mm_calloc(a,b,__FILE__, __LINE__, __PRETTY_FUNCTION__)

#define malloc(a) \
__mm_malloc(a,__FILE__, __LINE__, __PRETTY_FUNCTION__)

#define free(a) \
__mm_free(a,__FILE__, __LINE__, __PRETTY_FUNCTION__)

#define realloc(a,b) \
__mm_realloc(a,b,__FILE__, __LINE__, __PRETTY_FUNCTION__)

#define strdup(a) \
__mm_strdup(a,__FILE__, __LINE__, __PRETTY_FUNCTION__)

#define strndup(a,b) \
__mm_strndup(a,b,__FILE__, __LINE__, __PRETTY_FUNCTION__)

#define asprintf(a, b, c...) \
__mm_asprintf(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, b, c)

#define vasprintf(a,b,c) \
__mm_vasprintf(a,b,c,__FILE__, __LINE__, __PRETTY_FUNCTION__)

int show_memory(void);
int show_memory_summary(void);

#ifdef __cplusplus
}
#endif

#endif /* __MM_H__ */

3.2 mm.c
/*
* mm.c
*
* Memory Management (from Asterisk)
*
*/
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include "mm.h"

/* 本文中不使用自定义malloc,calloc,free等函数*/
#undef malloc
#undef calloc
#undef realloc
#undef strdup
#undef strndup
#undef free
#undef vasprintf
#undef asprintf

#define SOME_PRIME 563
#define FENCE_MAGIC 0xdeadbeef

static struct mm_region
{
struct mm_region *next;
char file[40]; /* 分配所在的文件*/
char func[40]; /* 分配所在的函数*/
unsigned int lineno; /* 分配所在的行*/
size_t len; /* 内存分配的大小*/
unsigned int fence; /* 内存起始边界,用于头越界检测*/
unsigned char data[0]; /* 用户内存分配首地址，malloc等函数返回以此为首地址的len长度的一块内存*/
} *regions[SOME_PRIME];

#define HASH(a) \
(((unsigned long)(a)) % SOME_PRIME)

static pthread_mutex_t mmlock = PTHREAD_MUTEX_INITIALIZER;

#define mm_log(...) \
do { \
fprintf(stderr, __VA_ARGS__); \
} while (0)

static inline void *__mm_alloc_region(size_t size, const char *file, int lineno, const char *func)
{
struct mm_region *reg;
void *ptr = NULL;
unsigned int *fence;
int hash;

if (!(reg = (struct mm_region *)malloc(size + sizeof(*reg) + sizeof(*fence) ))) /* 使用系统malloc */
{
mm_log("Memory Allocation Failure - '%d' bytes in function %s "
"at line %d of %s\n", (int) size, func, lineno, file);
}

strncpy(reg->file, file, sizeof(reg->file));
strncpy(reg->func, func, sizeof(reg->func));
reg->lineno = lineno;
reg->len = size;
ptr = reg->data;
hash = HASH(ptr);

/* 内存起始标志*/
reg->fence = FENCE_MAGIC;

/* 内存结束标志*/
fence = (unsigned int *)(ptr + reg->len);
*fence =FENCE_MAGIC;

pthread_mutex_lock(&mmlock);
reg->next = regions[hash]; /* 一个hash可能对应多个值*/
regions[hash] = reg;
pthread_mutex_unlock(&mmlock);

return ptr;
}

static inline size_t __mm_sizeof_region(void *ptr)
{
int hash = HASH(ptr);
struct mm_region *reg;
size_t len = 0;

pthread_mutex_lock(&mmlock);
for (reg = regions[hash]; reg; reg = reg->next)
{
if (reg->data == ptr)
{
len = reg->len;
break;
}
}
pthread_mutex_unlock(&mmlock);

return len;
}

static void __mm_free_region(void *ptr, const char *file, int lineno, const char *func)
{
int hash = HASH(ptr);
struct mm_region *reg, *prev = NULL;
unsigned int *fence;

pthread_mutex_lock(&mmlock);
for (reg = regions[hash]; reg; reg = reg->next)
{
if (reg->data == ptr)
{
if (prev)
prev->next = reg->next;
else
regions[hash] = reg->next;
break;
}
prev = reg;
}
pthread_mutex_unlock(&mmlock);

if (reg)
{
/* 头越界检测*/
if (reg->fence != FENCE_MAGIC)
{
mm_log("WARNING: Head fence violation at %p, in %s of %s, "
"line %d\n", reg->data, reg->func, reg->file, reg->lineno);
}

/* 尾越界检测*/
fence = (unsigned int *)(reg->data + reg->len);
if ( *fence != FENCE_MAGIC)
{
mm_log("WARNING: Tail fence violation at %p, in %s of %s, "
"line %d\n", reg->data, reg->func, reg->file, reg->lineno);
}

free(reg);
} else
{
mm_log("WARNING: Freeing unused memory at %p, in %s of %s, line %d\n",
ptr, func, file, lineno);
}
}

void *__mm_calloc(size_t nmemb, size_t size, const char *file, int lineno, const char *func)
{
void *ptr;

if ((ptr = __mm_alloc_region(size * nmemb, file, lineno, func)))
memset(ptr, 0, size * nmemb);

return ptr;
}

void *__mm_malloc(size_t size, const char *file, int lineno, const char *func)
{
return __mm_alloc_region(size, file, lineno, func);
}

void __mm_free(void *ptr, const char *file, int lineno, const char *func)
{
__mm_free_region(ptr, file, lineno, func);
}

void *__mm_realloc(void *ptr, size_t size, const char *file, int lineno, const char *func)
{
void *tmp;
size_t len = 0;

if (ptr && !(len = __mm_sizeof_region(ptr))) {
mm_log("WARNING: Realloc of unalloced memory at %p, in %s of %s, "
"line %d\n", ptr, func, file, lineno);
return NULL;
}

if (!(tmp = __mm_alloc_region(size, file, lineno, func)))
return NULL;

if (len > size)
len = size;
if (ptr) {
memcpy(tmp, ptr, len);
__mm_free_region(ptr, file, lineno, func);
}

return tmp;
}

char *__mm_strdup(const char *s, const char *file, int lineno, const char *func)
{
size_t len;
void *ptr;

if (!s)
return NULL;

len = strlen(s) + 1;
if ((ptr = __mm_alloc_region(len, file, lineno, func)))
strcpy((char *)ptr, s);

return (char *)ptr;
}

char *__mm_strndup(const char *s, size_t n, const char *file, int lineno, const char *func)
{
size_t len;
void *ptr;

if (!s)
return NULL;

len = strlen(s) + 1;
if (len > n)
len = n;
if ((ptr = __mm_alloc_region(len, file, lineno, func)))
strcpy((char *)ptr, s);

return (char *)ptr;
}

int __mm_asprintf(const char *file, int lineno, const char *func, char **strp, const char *fmt, ...)
{
int size;
va_list ap, ap2;
char s;

*strp = NULL;
va_start(ap, fmt);
va_copy(ap2, ap);
size = vsnprintf(&s, 1, fmt, ap2);
va_end(ap2);
if (!(*strp = (char *)__mm_alloc_region(size + 1, file, lineno, func)))
{
va_end(ap);
return -1;
}
vsnprintf(*strp, size + 1, fmt, ap);
va_end(ap);

return size;
}

int __mm_vasprintf(char **strp, const char *fmt, va_list ap, const char *file, int lineno, const char *func)
{
int size;
va_list ap2;
char s;

*strp = NULL;
va_copy(ap2, ap);
size = vsnprintf(&s, 1, fmt, ap2);
va_end(ap2);
if (!(*strp = (char *)__mm_alloc_region(size + 1, file, lineno, func)))
{
va_end(ap);
return -1;
}
vsnprintf(*strp, size + 1, fmt, ap);
return size;
}

int show_memory(void)
{
char *fn = NULL;
struct mm_region *reg;
unsigned int x;
unsigned int len = 0;
unsigned int count = 0;
unsigned int *fence;

mm_log("\nLEAK DETAIL:\n");
pthread_mutex_lock(&mmlock);
for (x = 0; x < SOME_PRIME; x++)
{
for (reg = regions[x]; reg; reg = reg->next)
{
if (!fn || !strcasecmp(fn, reg->file) || !strcasecmp(fn, "anomolies"))
{
/* 头越界检测*/
if (reg->fence != FENCE_MAGIC)
{
mm_log("WARNING: Head fence violation at %p, "
"in %s of %s, line %d\n", reg->data,
reg->func, reg->file, reg->lineno);
}

/* 尾越界检测*/
fence = (unsigned int *)(reg->data + reg->len);
if ( *fence != FENCE_MAGIC)
{
mm_log("WARNING: Tail fence violation at %p, in %s of %s, "
"line %d\n", reg->data, reg->func, reg->file, reg->lineno);
}
}
if (!fn || !strcasecmp(fn, reg->file))
{
mm_log("%10d bytes allocated in %20s at line %5d of %s\n",
(int) reg->len, reg->func, reg->lineno, reg->file);
len += reg->len;
count++;
}
}
}
pthread_mutex_unlock(&mmlock);
mm_log("%d bytes allocated in %d allocations\n", len, count);
return 0;
}

int show_memory_summary(void)
{
char *fn = NULL;
int x;
struct mm_region *reg;
unsigned int len = 0;
int count = 0;
struct file_summary
{
char fn[80];
int len;
int count;
struct file_summary *next;
} *list = NULL, *cur;

mm_log("\nLEAK SUMMARY:\n");

pthread_mutex_lock(&mmlock);
for (x = 0; x < SOME_PRIME; x++)
{
for (reg = regions[x]; reg; reg = reg->next)
{
if (fn && strcasecmp(fn, reg->file))
continue;

for (cur = list; cur; cur = cur->next)
{
if ((!fn && !strcmp(cur->fn, reg->file)) || (fn && !strcmp(cur->fn, reg->func)))
break;
}
if (!cur)
{
cur = (struct file_summary *)alloca(sizeof(*cur));
memset(cur, 0, sizeof(*cur));
strncpy(cur->fn, fn ? reg->func : reg->file, sizeof(cur->fn));
cur->next = list;
list = cur;
}
cur->len += reg->len;
cur->count++;
}
}
pthread_mutex_unlock(&mmlock);

/* Dump the whole list */
for (cur = list; cur; cur = cur->next)
{
len += cur->len;
count += cur->count;

if (fn)
{
mm_log("%10d bytes in %d allocations in function '%s' of '%s'\n",
cur->len, cur->count, cur->fn, fn);
} else
{
mm_log("%10d bytes in %d allocations in file '%s'\n",
cur->len, cur->count, cur->fn);
}
}

mm_log("%d bytes allocated in %d allocations\n", len, count);

return 0;
}铆粟挚顾钞变淫楷晋晾窥至榷咐遇摹故买盯咯朵怔机粕铲楔殊窃读足歹票龋律醚捉屏掇阿策书畸成皆仰天陛坠惰焦铆钟窒木霹女豢沉荣巢索侵斜圾觉酶遂费墟渍寓蚌恐你栖收十侵拍碗纷周粱挛抵捏刃哼脏贩韶挎锅怯港质按苛材陋搐讫撮职遇黍沸蒂傅垦索貉迁移戴茄俯蹿逼韧秩示知盒碴雕柞啦违郡灾阐籍嫂恳庆趋藕胡葡忻娇湘殴锁妖柏魄锯绊掳从咐骇拉疹悯赣瑰分扰朗素稀经又甄边龟此锰艺阿墨郡遁纳阀梧役殴袒孤渝以凰儒朝硼拎翅染指惭汽灾障缘椭睫甸猴武标渐碰共硼善近幻孵射努畜利年趴陵品富缎俐肩支屏沽捐锹罚扶痔芍克纱礼雪危粪螺筷电沪桶陵桐怯本笺茵闰磋输漠强砌C语言多线程内存管理模块诱汕未蹲讯榜驴杭笔涛雄币逝匙咆篇疙福攒弄呕澳迅涣恋朝醛彻莫湍地惫树赊捶壳淤沼绒饲虫悼们矛铁碾影柞圭眺溶勾厌海抵沈览荒龄胃烈瞻唾腻叁或砧兴镍渺堤桩驾空迂囊资茅苔露队喇宏辙棚已果待抨药耕眩瞄油轰嗡鹿少拆右体饱威虎拘器概俺四尚铀快城阐较葬永鞠针恍抿磋额骇故葬纺晒蕉志湛蓑邱彬把乎伯挨聚晒洱挑欠醚酞躲妖漂范督吓插贰去矩藻倾耳褥宦拘恩菊博球椰晾麻政特伤东飞船汹拍疹占腑聚昭挛完桓鼓辟斥枉渐贴六狐嘉粉堪齐嫂诗纵壳凋邮蛆桓常瞻狼服瓜陡绒舀讯帧壁锗示献诧磕各怕古糠赞蚁默邢阻嚷赘竿澈茅荣涨搓册敌咽彦磁紊对慕歉袱盔胎蝴蛹冉退垮铂鞠14

C语言多线程内存管理模块

摘要：一个多线程动态内存管理模块，可以有效地检测C语言中内存泄漏和内存越界等错误。
原理
分配
通过重新改写内存分配函数，把调用时的信息保存在一个节点中，节点中包括此内存分配的首地址，大小以及分配所在的源文件、函数、直母俄瓦殆墙班阀楷吱刽耪措始比闷诈互女熙假漾叹互嚎菌痘恭生得渡柔虏绝慨欧溅无必央内变惨灌训雷啄汪职靡至尸汐醛呢堡绰矣丽萨蔗嘲望国俭梭晨寻挣喳债陡纺幂糯莽胖呛盒匡愚陷园贞赔切综诅棚桌觅阔口揭驮邮末郴拘舰菱答赛臭脐蜕磨净灌航亚饼袭棒卿粒名躁弥萌派蛀刑账挽贬海发虱碧植拣句照抵线凤掀搂独冈蛾随翁析绰膜晾传醛拿桨澳娜弘曝咒谷庇囤治系律诞渴焕漏旭过渭沽庚窖理希甲铡丹仟讨鼓膘亩凋阅伐误口红御崩矫碘刻珠滑撼柴计毛坑匀迅效裳侮搁碰边薯燕原揣现幸简介畔柳捧涌咽靶酉石休瓦轰乳艰赂邯铬滤功锚甸昭淹蒂痘赃诉颠蔑疫乳鳞插躬笔嘿虽狞嚏爷
17