From 20580d5a1cb2146f0d6addc00c0771cbcc8968ee Mon Sep 17 00:00:00 2001 From: GodKingBS <283805320@qq.com> Date: Mon, 16 Dec 2024 21:39:36 +0800 Subject: [PATCH] alloc Signed-off-by: GodKingBS <283805320@qq.com> --- src/alloc-inl.h | 522 ++++++++++++++++++++---------------------------- 1 file changed, 221 insertions(+), 301 deletions(-) diff --git a/src/alloc-inl.h b/src/alloc-inl.h index 9a68126..7441e9b 100644 --- a/src/alloc-inl.h +++ b/src/alloc-inl.h @@ -36,8 +36,7 @@ #include "types.h" #include "debug.h" -/* User-facing macro to sprintf() to a dynamically allocated buffer. */ - +/* 提供给用户使用的宏，用于将sprintf()的输出到一个动态分配的缓冲区。 */ #define alloc_printf(_str...) ({ \ u8* _tmp; \ s32 _len = snprintf(NULL, 0, _str); \ @@ -47,29 +46,24 @@ _tmp; \ }) -/* Macro to enforce allocation limits as a last-resort defense against - integer overflows. */ - +/* 宏，用于强制执行分配限制，作为防止整数溢出的最后一道防线。 */ #define ALLOC_CHECK_SIZE(_s) do { \ if ((_s) > MAX_ALLOC) \ ABORT("Bad alloc request: %u bytes", (_s)); \ } while (0) -/* Macro to check malloc() failures and the like. */ - +/* 宏，用于检查malloc()失败等情况。 */ #define ALLOC_CHECK_RESULT(_r, _s) do { \ if (!(_r)) \ ABORT("Out of memory: can't allocate %u bytes", (_s)); \ } while (0) -/* Magic tokens used to mark used / freed chunks. */ - -#define ALLOC_MAGIC_C1 0xFF00FF00 /* Used head (dword) */ -#define ALLOC_MAGIC_F 0xFE00FE00 /* Freed head (dword) */ -#define ALLOC_MAGIC_C2 0xF0 /* Used tail (byte) */ - -/* Positions of guard tokens in relation to the user-visible pointer. */ +/* 用于标记已使用/已释放块的魔术标记。 */ +#define ALLOC_MAGIC_C1 0xFF00FF00 /* 已使用头部（双字） */ +#define ALLOC_MAGIC_F 0xFE00FE00 /* 已释放头部（双字） */ +#define ALLOC_MAGIC_C2 0xF0 /* 已使用尾部（字节） */ +/* 与用户可见指针相关的保护标记的位置。 */ #define ALLOC_C1(_ptr) (((u32*)(_ptr))[-2]) #define ALLOC_S(_ptr) (((u32*)(_ptr))[-1]) #define ALLOC_C2(_ptr) (((u8*)(_ptr))[ALLOC_S(_ptr)]) @@ -77,15 +71,13 @@ #define ALLOC_OFF_HEAD 8 #define ALLOC_OFF_TOTAL (ALLOC_OFF_HEAD + 1) -/* Allocator increments for ck_realloc_block(). */ - +/* ck_realloc_block()的分配器增量。 */ #define ALLOC_BLK_INC 256 -/* Sanity-checking macros for pointers. */ - +/* 用于指针的合理性检查宏。 */ #define CHECK_PTR(_p) do { \ if (_p) { \ - if (ALLOC_C1(_p) ^ ALLOC_MAGIC_C1) {\ + if (ALLOC_C1(_p) ^ ALLOC_MAGIC_C1) { \ if (ALLOC_C1(_p) == ALLOC_MAGIC_F) \ ABORT("Use after free."); \ else ABORT("Corrupted head alloc canary."); \ @@ -101,246 +93,206 @@ _tmp; \ }) - -/* Allocate a buffer, explicitly not zeroing it. Returns NULL for zero-sized - requests. */ - +/* 分配一个缓冲区，明确不将其清零。对于零大小的请求返回NULL。 */ static inline void* DFL_ck_alloc_nozero(u32 size) { - void* ret; + void* ret; - if (!size) return NULL; + if (!size) return NULL; - ALLOC_CHECK_SIZE(size); - ret = malloc(size + ALLOC_OFF_TOTAL); - ALLOC_CHECK_RESULT(ret, size); + ALLOC_CHECK_SIZE(size); + ret = malloc(size + ALLOC_OFF_TOTAL); + ALLOC_CHECK_RESULT(ret, size); - ret += ALLOC_OFF_HEAD; + ret += ALLOC_OFF_HEAD; - ALLOC_C1(ret) = ALLOC_MAGIC_C1; - ALLOC_S(ret) = size; - ALLOC_C2(ret) = ALLOC_MAGIC_C2; + ALLOC_C1(ret) = ALLOC_MAGIC_C1; + ALLOC_S(ret) = size; + ALLOC_C2(ret) = ALLOC_MAGIC_C2; - return ret; + return ret; } - -/* Allocate a buffer, returning zeroed memory. */ - +/* 分配一个缓冲区，返回清零后的内存。 */ static inline void* DFL_ck_alloc(u32 size) { - void* mem; + void* mem; - if (!size) return NULL; - mem = DFL_ck_alloc_nozero(size); + if (!size) return NULL; + mem = DFL_ck_alloc_nozero(size); - return memset(mem, 0, size); + return memset(mem, 0, size); } -/* Free memory, checking for double free and corrupted heap. When DEBUG_BUILD - is set, the old memory will be also clobbered with 0xFF. */ - +/* 释放内存，检查是否重复释放和堆损坏。当DEBUG_BUILD被设置时， + 旧内存也会被0xFF覆盖。 */ static inline void DFL_ck_free(void* mem) { + if (!mem) return; /* 如果指针为空，不执行任何操作 */ - if (!mem) return; - - CHECK_PTR(mem); - -#ifdef DEBUG_BUILD - - /* Catch pointer issues sooner. */ - memset(mem, 0xFF, ALLOC_S(mem)); + CHECK_PTR(mem); /* 检查是否重复释放和堆损坏 */ +#ifdef DEBUG_BUILD /* 如果是调试构建，用0xFF覆盖内存 */ + /* 尽早捕捉指针问题。 */ + memset(mem, 0xFF, ALLOC_S(mem)); /* 用0xFF覆盖内存 */ #endif /* DEBUG_BUILD */ - ALLOC_C1(mem) = ALLOC_MAGIC_F; - - free(mem - ALLOC_OFF_HEAD); + ALLOC_C1(mem) = ALLOC_MAGIC_F; /* 标记内存为已释放 */ + free(mem - ALLOC_OFF_HEAD); /* 释放内存，调整头偏移 */ } - -/* Re-allocate a buffer, checking for issues and zeroing any newly-added tail. - With DEBUG_BUILD, the buffer is always reallocated to a new addresses and the - old memory is clobbered with 0xFF. */ - +/* 重新分配缓冲区，检查问题并清零任何新添加的尾部。 + 在DEBUG_BUILD下，缓冲区总是被重新分配到新地址，旧内存被0xFF覆盖。 */ static inline void* DFL_ck_realloc(void* orig, u32 size) { + void* ret; + u32 old_size = 0; - void* ret; - u32 old_size = 0; - - if (!size) { - - DFL_ck_free(orig); - return NULL; - - } - - if (orig) { + if (!size) { + DFL_ck_free(orig); /* 如果新大小为0，释放原始内存 */ + return NULL; + } - CHECK_PTR(orig); + if (orig) { + CHECK_PTR(orig); /* 检查是否重复释放和堆损坏 */ -#ifndef DEBUG_BUILD - ALLOC_C1(orig) = ALLOC_MAGIC_F; +#ifndef DEBUG_BUILD /* 在非调试构建中，可以重用内存 */ + ALLOC_C1(orig) = ALLOC_MAGIC_F; /* 标记内存为已释放 */ #endif /* !DEBUG_BUILD */ - old_size = ALLOC_S(orig); - orig -= ALLOC_OFF_HEAD; - - ALLOC_CHECK_SIZE(old_size); - - } - - ALLOC_CHECK_SIZE(size); - -#ifndef DEBUG_BUILD - - ret = realloc(orig, size + ALLOC_OFF_TOTAL); - ALLOC_CHECK_RESULT(ret, size); - -#else - - /* Catch pointer issues sooner: force relocation and make sure that the - original buffer is wiped. */ - - ret = malloc(size + ALLOC_OFF_TOTAL); - ALLOC_CHECK_RESULT(ret, size); + old_size = ALLOC_S(orig); /* 获取原始大小 */ + orig -= ALLOC_OFF_HEAD; /* 调整指针以适应头部偏移 */ - if (orig) { - - memcpy(ret + ALLOC_OFF_HEAD, orig + ALLOC_OFF_HEAD, MIN(size, old_size)); - memset(orig + ALLOC_OFF_HEAD, 0xFF, old_size); + ALLOC_CHECK_SIZE(old_size); /* 检查原始大小是否有效 */ + } - ALLOC_C1(orig + ALLOC_OFF_HEAD) = ALLOC_MAGIC_F; + ALLOC_CHECK_SIZE(size); /* 检查新大小是否有效 */ - free(orig); +#ifndef DEBUG_BUILD /* 在非调试构建中，尝试原地调整内存大小 */ + ret = realloc(orig, size + ALLOC_OFF_TOTAL); /* 重新分配内存 */ + ALLOC_CHECK_RESULT(ret, size); /* 检查重新分配是否成功 */ +#else /* 在调试构建中，总是分配新内存并清除旧内存 */ + /* 尽早捕捉指针问题：强制重新定位，并确保旧缓冲区被清除。 */ - } + ret = malloc(size + ALLOC_OFF_TOTAL); /* 分配新内存 */ + ALLOC_CHECK_RESULT(ret, size); /* 检查分配是否成功 */ + if (orig) { + memcpy(ret + ALLOC_OFF_HEAD, orig + ALLOC_OFF_HEAD, MIN(size, old_size)); /* 将数据复制到新内存 */ + memset(orig + ALLOC_OFF_HEAD, 0xFF, old_size); /* 用0xFF覆盖旧内存 */ + ALLOC_C1(orig + ALLOC_OFF_HEAD) = ALLOC_MAGIC_F; /* 标记旧内存为已释放 */ + free(orig); /* 释放旧内存 */ + } #endif /* ^!DEBUG_BUILD */ - ret += ALLOC_OFF_HEAD; + ret += ALLOC_OFF_HEAD; /* 调整指针以适应头部偏移 */ - ALLOC_C1(ret) = ALLOC_MAGIC_C1; - ALLOC_S(ret) = size; - ALLOC_C2(ret) = ALLOC_MAGIC_C2; + ALLOC_C1(ret) = ALLOC_MAGIC_C1; /* 标记内存为已使用 */ + ALLOC_S(ret) = size; /* 存储内存块的大小 */ + ALLOC_C2(ret) = ALLOC_MAGIC_C2; /* 标记内存块的结尾 */ - if (size > old_size) - memset(ret + old_size, 0, size - old_size); - - return ret; + if (size > old_size) /* 如果新大小更大，清零新的尾部 */ + memset(ret + old_size, 0, size - old_size); + return ret; /* 返回（可能新的）内存块 */ } -/* Re-allocate a buffer with ALLOC_BLK_INC increments (used to speed up - repeated small reallocs without complicating the user code). */ - +/* 以ALLOC_BLK_INC的增量重新分配缓冲区（用于加速重复的小realloc操作，而不需要复杂化用户代码）。 */ static inline void* DFL_ck_realloc_block(void* orig, u32 size) { #ifndef DEBUG_BUILD - if (orig) { + if (orig) { - CHECK_PTR(orig); + CHECK_PTR(orig); /* 检查原始指针是否有效 */ - if (ALLOC_S(orig) >= size) return orig; + if (ALLOC_S(orig) >= size) return orig; /* 如果当前大小已满足需求，则不进行realloc */ - size += ALLOC_BLK_INC; + size += ALLOC_BLK_INC; /* 增加ALLOC_BLK_INC，以减少频繁的小realloc操作 */ - } + } #endif /* !DEBUG_BUILD */ - return DFL_ck_realloc(orig, size); + return DFL_ck_realloc(orig, size); /* 调用DFL_ck_realloc进行实际的realloc操作 */ } - -/* Create a buffer with a copy of a string. Returns NULL for NULL inputs. */ - +/* 创建一个包含字符串副本的缓冲区。对于NULL输入返回NULL。 */ static inline u8* DFL_ck_strdup(u8* str) { - void* ret; - u32 size; + void* ret; + u32 size; - if (!str) return NULL; + if (!str) return NULL; /* 如果输入字符串为空，则返回NULL */ - size = strlen((char*)str) + 1; + size = strlen((char*)str) + 1; /* 计算字符串长度加1（为'\0'留空间） */ - ALLOC_CHECK_SIZE(size); - ret = malloc(size + ALLOC_OFF_TOTAL); - ALLOC_CHECK_RESULT(ret, size); + ALLOC_CHECK_SIZE(size); /* 检查分配大小是否超出限制 */ + ret = malloc(size + ALLOC_OFF_TOTAL); /* 分配内存 */ + ALLOC_CHECK_RESULT(ret, size); /* 检查内存分配是否成功 */ - ret += ALLOC_OFF_HEAD; + ret += ALLOC_OFF_HEAD; /* 调整指针以适应头部偏移 */ - ALLOC_C1(ret) = ALLOC_MAGIC_C1; - ALLOC_S(ret) = size; - ALLOC_C2(ret) = ALLOC_MAGIC_C2; + ALLOC_C1(ret) = ALLOC_MAGIC_C1; /* 设置头部魔术标记 */ + ALLOC_S(ret) = size; /* 存储分配的大小 */ + ALLOC_C2(ret) = ALLOC_MAGIC_C2; /* 设置尾部魔术标记 */ - return memcpy(ret, str, size); + return memcpy(ret, str, size); /* 复制字符串并返回新指针 */ } - -/* Create a buffer with a copy of a memory block. Returns NULL for zero-sized - or NULL inputs. */ - +/* 创建一个包含内存块副本的缓冲区。对于零大小或NULL输入返回NULL。 */ static inline void* DFL_ck_memdup(void* mem, u32 size) { - void* ret; - - if (!mem || !size) return NULL; + void* ret; - ALLOC_CHECK_SIZE(size); - ret = malloc(size + ALLOC_OFF_TOTAL); - ALLOC_CHECK_RESULT(ret, size); - - ret += ALLOC_OFF_HEAD; + if (!mem || !size) return NULL; /* 如果内存块为空或大小为零，则返回NULL */ - ALLOC_C1(ret) = ALLOC_MAGIC_C1; - ALLOC_S(ret) = size; - ALLOC_C2(ret) = ALLOC_MAGIC_C2; + ALLOC_CHECK_SIZE(size); /* 检查分配大小是否超出限制 */ + ret = malloc(size + ALLOC_OFF_TOTAL); /* 分配内存 */ + ALLOC_CHECK_RESULT(ret, size); /* 检查内存分配是否成功 */ - return memcpy(ret, mem, size); + ret += ALLOC_OFF_HEAD; /* 调整指针以适应头部偏移 */ -} + ALLOC_C1(ret) = ALLOC_MAGIC_C1; /* 设置头部魔术标记 */ + ALLOC_S(ret) = size; /* 存储分配的大小 */ + ALLOC_C2(ret) = ALLOC_MAGIC_C2; /* 设置尾部魔术标记 */ + return memcpy(ret, mem, size); /* 复制内存块并返回新指针 */ -/* Create a buffer with a block of text, appending a NUL terminator at the end. - Returns NULL for zero-sized or NULL inputs. */ +} +/* 创建一个包含文本块的缓冲区，并在末尾追加NUL终止符。对于零大小或NULL输入返回NULL。 */ static inline u8* DFL_ck_memdup_str(u8* mem, u32 size) { - u8* ret; + u8* ret; - if (!mem || !size) return NULL; + if (!mem || !size) return NULL; /* 如果内存块为空或大小为零，则返回NULL */ - ALLOC_CHECK_SIZE(size); - ret = malloc(size + ALLOC_OFF_TOTAL + 1); - ALLOC_CHECK_RESULT(ret, size); - - ret += ALLOC_OFF_HEAD; + ALLOC_CHECK_SIZE(size); /* 检查分配大小是否超出限制 */ + ret = malloc(size + ALLOC_OFF_TOTAL + 1); /* 分配内存，额外+1用于NUL终止符 */ + ALLOC_CHECK_RESULT(ret, size); /* 检查内存分配是否成功 */ - ALLOC_C1(ret) = ALLOC_MAGIC_C1; - ALLOC_S(ret) = size; - ALLOC_C2(ret) = ALLOC_MAGIC_C2; + ret += ALLOC_OFF_HEAD; /* 调整指针以适应头部偏移 */ - memcpy(ret, mem, size); - ret[size] = 0; + ALLOC_C1(ret) = ALLOC_MAGIC_C1; /* 设置头部魔术标记 */ + ALLOC_S(ret) = size; /* 存储分配的大小 */ + ALLOC_C2(ret) = ALLOC_MAGIC_C2; /* 设置尾部魔术标记 */ - return ret; + memcpy(ret, mem, size); /* 复制内存块 */ + ret[size] = 0; /* 设置NUL终止符 */ -} + return ret; /* 返回新指针 */ +} #ifndef DEBUG_BUILD -/* In non-debug mode, we just do straightforward aliasing of the above functions - to user-visible names such as ck_alloc(). */ +/* 在非调试模式下，我们直接将上述函数别名为用户可见的名称，如ck_alloc()。 */ #define ck_alloc DFL_ck_alloc #define ck_alloc_nozero DFL_ck_alloc_nozero @@ -355,223 +307,191 @@ static inline u8* DFL_ck_memdup_str(u8* mem, u32 size) { #else -/* In debugging mode, we also track allocations to detect memory leaks, and the - flow goes through one more layer of indirection. */ +/* 在调试模式下，我们还跟踪内存分配以检测内存泄漏，这个过程会经历更多的间接层。 */ -/* Alloc tracking data structures: */ +/* 分配跟踪数据结构： */ -#define ALLOC_BUCKETS 4096 +#define ALLOC_BUCKETS 4096 /* 定义分配桶的数量 */ struct TRK_obj { - void *ptr; - char *file, *func; - u32 line; + void* ptr; /* 指向分配的内存块 */ + char* file, * func; /* 分配时的文件名和函数名 */ + u32 line; /* 分配时的代码行号 */ }; #ifdef AFL_MAIN -struct TRK_obj* TRK[ALLOC_BUCKETS]; -u32 TRK_cnt[ALLOC_BUCKETS]; +struct TRK_obj* TRK[ALLOC_BUCKETS]; /* 跟踪分配的内存对象数组 */ +u32 TRK_cnt[ALLOC_BUCKETS]; /* 每个桶中跟踪对象的数量 */ -# define alloc_report() TRK_report() +# define alloc_report() TRK_report() /* 定义alloc_report宏为TRK_report函数 */ #else -extern struct TRK_obj* TRK[ALLOC_BUCKETS]; -extern u32 TRK_cnt[ALLOC_BUCKETS]; +extern struct TRK_obj* TRK[ALLOC_BUCKETS]; /* 外部声明跟踪分配的内存对象数组 */ +extern u32 TRK_cnt[ALLOC_BUCKETS]; /* 外部声明每个桶中跟踪对象的数量 */ -# define alloc_report() +# define alloc_report() /* 在非AFL_MAIN环境下，alloc_report宏为空 */ #endif /* ^AFL_MAIN */ -/* Bucket-assigning function for a given pointer: */ - -#define TRKH(_ptr) (((((u32)(_ptr)) >> 16) ^ ((u32)(_ptr))) % ALLOC_BUCKETS) +/* 为给定指针分配桶的函数： */ +#define TRKH(_ptr) (((((u32)(_ptr)) >> 16) ^ ((u32)(_ptr))) % ALLOC_BUCKETS) /* 定义桶分配宏 */ -/* Add a new entry to the list of allocated objects. */ +/* 将新分配的内存对象添加到跟踪列表中。 */ static inline void TRK_alloc_buf(void* ptr, const char* file, const char* func, - u32 line) { - - u32 i, bucket; + u32 line) { + u32 i, bucket; - if (!ptr) return; + if (!ptr) return; /* 如果指针为空，则返回 */ - bucket = TRKH(ptr); + bucket = TRKH(ptr); /* 获取桶编号 */ - /* Find a free slot in the list of entries for that bucket. */ + /* 在该桶的条目列表中找到一个空闲位置。 */ - for (i = 0; i < TRK_cnt[bucket]; i++) - - if (!TRK[bucket][i].ptr) { - - TRK[bucket][i].ptr = ptr; - TRK[bucket][i].file = (char*)file; - TRK[bucket][i].func = (char*)func; - TRK[bucket][i].line = line; - return; - - } - - /* No space available - allocate more. */ + for (i = 0; i < TRK_cnt[bucket]; i++) + if (!TRK[bucket][i].ptr) { /* 如果找到空闲位置 */ + TRK[bucket][i].ptr = ptr; + TRK[bucket][i].file = (char*)file; + TRK[bucket][i].func = (char*)func; + TRK[bucket][i].line = line; + return; + } - TRK[bucket] = DFL_ck_realloc_block(TRK[bucket], - (TRK_cnt[bucket] + 1) * sizeof(struct TRK_obj)); + /* 没有可用空间 - 分配更多空间。 */ - TRK[bucket][i].ptr = ptr; - TRK[bucket][i].file = (char*)file; - TRK[bucket][i].func = (char*)func; - TRK[bucket][i].line = line; + TRK[bucket] = DFL_ck_realloc_block(TRK[bucket], + (TRK_cnt[bucket] + 1) * sizeof(struct TRK_obj)); /* 重新分配桶的大小 */ - TRK_cnt[bucket]++; + TRK[bucket][i].ptr = ptr; + TRK[bucket][i].file = (char*)file; + TRK[bucket][i].func = (char*)func; + TRK[bucket][i].line = line; + TRK_cnt[bucket]++; /* 更新桶中条目的数量 */ } - -/* Remove entry from the list of allocated objects. */ +/* 从分配的内存对象列表中移除条目。 */ static inline void TRK_free_buf(void* ptr, const char* file, const char* func, - u32 line) { - - u32 i, bucket; - - if (!ptr) return; + u32 line) { + u32 i, bucket; - bucket = TRKH(ptr); + if (!ptr) return; /* 如果指针为空，则返回 */ - /* Find the element on the list... */ + bucket = TRKH(ptr); /* 获取桶编号 */ - for (i = 0; i < TRK_cnt[bucket]; i++) + /* 在列表中找到该元素... */ - if (TRK[bucket][i].ptr == ptr) { - - TRK[bucket][i].ptr = 0; - return; - - } - - WARNF("ALLOC: Attempt to free non-allocated memory in %s (%s:%u)", - func, file, line); + for (i = 0; i < TRK_cnt[bucket]; i++) + if (TRK[bucket][i].ptr == ptr) { /* 如果找到匹配的指针 */ + TRK[bucket][i].ptr = 0; /* 将指针设置为NULL */ + return; + } + WARNF("ALLOC: Attempt to free non-allocated memory in %s (%s:%u)", + func, file, line); /* 警告：尝试释放未分配的内存 */ } - -/* Do a final report on all non-deallocated objects. */ +/* 对所有未释放的对象进行最终报告。 */ static inline void TRK_report(void) { + u32 i, bucket; - u32 i, bucket; - - fflush(0); - - for (bucket = 0; bucket < ALLOC_BUCKETS; bucket++) - for (i = 0; i < TRK_cnt[bucket]; i++) - if (TRK[bucket][i].ptr) - WARNF("ALLOC: Memory never freed, created in %s (%s:%u)", - TRK[bucket][i].func, TRK[bucket][i].file, TRK[bucket][i].line); + fflush(0); /* 清空输出缓冲区 */ + for (bucket = 0; bucket < ALLOC_BUCKETS; bucket++) + for (i = 0; i < TRK_cnt[bucket]; i++) + if (TRK[bucket][i].ptr) /* 如果指针不为空 */ + WARNF("ALLOC: Memory never freed, created in %s (%s:%u)", + TRK[bucket][i].func, TRK[bucket][i].file, TRK[bucket][i].line); /* 警告：内存从未释放 */ } - -/* Simple wrappers for non-debugging functions: */ +/* 非调试函数的简单包装器： */ static inline void* TRK_ck_alloc(u32 size, const char* file, const char* func, - u32 line) { - - void* ret = DFL_ck_alloc(size); - TRK_alloc_buf(ret, file, func, line); - return ret; - + u32 line) { + void* ret = DFL_ck_alloc(size); /* 分配内存 */ + TRK_alloc_buf(ret, file, func, line); /* 添加到跟踪列表 */ + return ret; } - static inline void* TRK_ck_realloc(void* orig, u32 size, const char* file, - const char* func, u32 line) { - - void* ret = DFL_ck_realloc(orig, size); - TRK_free_buf(orig, file, func, line); - TRK_alloc_buf(ret, file, func, line); - return ret; - + const char* func, u32 line) { + void* ret = DFL_ck_realloc(orig, size); /* 重新分配内存 */ + TRK_free_buf(orig, file, func, line); /* 从跟踪列表中移除 */ + TRK_alloc_buf(ret, file, func, line); /* 添加到跟踪列表 */ + return ret; } +/* 重新分配内存块，同时更新跟踪信息。 */ static inline void* TRK_ck_realloc_block(void* orig, u32 size, const char* file, - const char* func, u32 line) { - - void* ret = DFL_ck_realloc_block(orig, size); - TRK_free_buf(orig, file, func, line); - TRK_alloc_buf(ret, file, func, line); - return ret; - + const char* func, u32 line) { + void* ret = DFL_ck_realloc_block(orig, size); /* 调用DFL_ck_realloc_block重新分配内存 */ + TRK_free_buf(orig, file, func, line); /* 从跟踪列表中移除原始内存块 */ + TRK_alloc_buf(ret, file, func, line); /* 将新内存块添加到跟踪列表 */ + return ret; /* 返回新内存块 */ } - +/* 复制字符串并分配内存，同时更新跟踪信息。 */ static inline void* TRK_ck_strdup(u8* str, const char* file, const char* func, - u32 line) { - - void* ret = DFL_ck_strdup(str); - TRK_alloc_buf(ret, file, func, line); - return ret; - + u32 line) { + void* ret = DFL_ck_strdup(str); /* 调用DFL_ck_strdup复制字符串 */ + TRK_alloc_buf(ret, file, func, line); /* 将新内存块添加到跟踪列表 */ + return ret; /* 返回新内存块 */ } - +/* 复制内存块并分配内存，同时更新跟踪信息。 */ static inline void* TRK_ck_memdup(void* mem, u32 size, const char* file, - const char* func, u32 line) { - - void* ret = DFL_ck_memdup(mem, size); - TRK_alloc_buf(ret, file, func, line); - return ret; - + const char* func, u32 line) { + void* ret = DFL_ck_memdup(mem, size); /* 调用DFL_ck_memdup复制内存块 */ + TRK_alloc_buf(ret, file, func, line); /* 将新内存块添加到跟踪列表 */ + return ret; /* 返回新内存块 */ } - +/* 复制内存块并添加字符串终止符，同时更新跟踪信息。 */ static inline void* TRK_ck_memdup_str(void* mem, u32 size, const char* file, - const char* func, u32 line) { - - void* ret = DFL_ck_memdup_str(mem, size); - TRK_alloc_buf(ret, file, func, line); - return ret; - + const char* func, u32 line) { + void* ret = DFL_ck_memdup_str(mem, size); /* 调用DFL_ck_memdup_str复制内存块并添加终止符 */ + TRK_alloc_buf(ret, file, func, line); /* 将新内存块添加到跟踪列表 */ + return ret; /* 返回新内存块 */ } - +/* 释放内存并更新跟踪信息。 */ static inline void TRK_ck_free(void* ptr, const char* file, - const char* func, u32 line) { - - TRK_free_buf(ptr, file, func, line); - DFL_ck_free(ptr); - + const char* func, u32 line) { + TRK_free_buf(ptr, file, func, line); /* 从跟踪列表中移除内存块 */ + DFL_ck_free(ptr); /* 释放内存块 */ } -/* Aliasing user-facing names to tracking functions: */ +/* 将用户可见的名称别名为跟踪函数： */ #define ck_alloc(_p1) \ - TRK_ck_alloc(_p1, __FILE__, __FUNCTION__, __LINE__) + TRK_ck_alloc(_p1, __FILE__, __FUNCTION__, __LINE__) /* 定义ck_alloc宏为TRK_ck_alloc */ #define ck_alloc_nozero(_p1) \ - TRK_ck_alloc(_p1, __FILE__, __FUNCTION__, __LINE__) + TRK_ck_alloc_nozero(_p1, __FILE__, __FUNCTION__, __LINE__) /* 定义ck_alloc_nozero宏为TRK_ck_alloc_nozero */ #define ck_realloc(_p1, _p2) \ - TRK_ck_realloc(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) + TRK_ck_realloc(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) /* 定义ck_realloc宏为TRK_ck_realloc */ #define ck_realloc_block(_p1, _p2) \ - TRK_ck_realloc_block(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) + TRK_ck_realloc_block(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) /* 定义ck_realloc_block宏为TRK_ck_realloc_block */ #define ck_strdup(_p1) \ - TRK_ck_strdup(_p1, __FILE__, __FUNCTION__, __LINE__) + TRK_ck_strdup(_p1, __FILE__, __FUNCTION__, __LINE__) /* 定义ck_strdup宏为TRK_ck_strdup */ #define ck_memdup(_p1, _p2) \ - TRK_ck_memdup(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) + TRK_ck_memdup(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) /* 定义ck_memdup宏为TRK_ck_memdup */ #define ck_memdup_str(_p1, _p2) \ - TRK_ck_memdup_str(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) + TRK_ck_memdup_str(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) /* 定义ck_memdup_str宏为TRK_ck_memdup_str */ #define ck_free(_p1) \ - TRK_ck_free(_p1, __FILE__, __FUNCTION__, __LINE__) + TRK_ck_free(_p1, __FILE__, __FUNCTION__, __LINE__) /* 定义ck_free宏为TRK_ck_free */ #endif /* ^!DEBUG_BUILD */ - #endif /* ! _HAVE_ALLOC_INL_H */