char *myrealloc(char *ptr, ssize_t len) { MBLOCK *real_ptr; ssize_t old_len; #ifndef NO_SHARED_EMPTY_STRINGS if (ptr == empty_string) return (mymalloc(len)); #endif /* * Note: for safety reasons the request length is a signed type. This * allows us to catch integer overflow problems that weren't already * caught up-stream. */ if (len < 1) msg_panic("myrealloc: requested length %ld", (long) len); #ifdef MYMALLOC_FUZZ len += MYMALLOC_FUZZ; #endif CHECK_IN_PTR(ptr, real_ptr, old_len, "myrealloc"); if ((real_ptr = (MBLOCK *) realloc((char *) real_ptr, SPACE_FOR(len))) == 0) msg_fatal("myrealloc: insufficient memory for %ld bytes: %m", (long) len); CHECK_OUT_PTR(ptr, real_ptr, len); if (len > old_len) memset(ptr + old_len, FILLER, len - old_len); return (ptr); }
void *acl_default_realloc(const char *filename, int line, void *ptr, size_t len) { const char *myname = "acl_default_realloc"; MBLOCK *real_ptr; size_t old_len, new_len; const char *pname = NULL; if (filename && *filename) SET_FILE(pname, filename); else pname = __FILENAME_UNKNOWN; #ifndef NO_SHARED_EMPTY_STRINGS if (ptr == empty_string) return acl_default_malloc(pname, line, len); #endif if (len < 1) { acl_msg_warn("%s(%d)->%s: realloc: requested length %ld", pname, line, myname, (long) len); len = 128; } if (ptr == NULL) return acl_default_malloc(pname, line, len); CHECK_IN_PTR(ptr, real_ptr, old_len, pname, line); new_len = SPACE_FOR(len); if (new_len <= 0) acl_msg_fatal("%s(%d): new_len(%d) <= 0", myname, __LINE__, (int) new_len); else if (new_len >= __malloc_limit) { acl_msg_warn("%s(%d): new_len(%d) too large", myname, __LINE__, (int) new_len); } #ifdef _USE_GLIB if ((real_ptr = (MBLOCK *) g_realloc((char *) real_ptr, new_len)) == 0) acl_msg_fatal("%s(%d)->%s: realloc: insufficient memory: %s", pname, line, myname, strerror(errno)); #else if ((real_ptr = (MBLOCK *) realloc((char *) real_ptr, new_len)) == 0) acl_msg_fatal("%s(%d)->%s: realloc: insufficient memory: %s", pname, line, myname, strerror(errno)); #endif CHECK_OUT_PTR(ptr, real_ptr, len); #if 0 if (len > old_len) memset((char *) ptr + old_len, FILLER, len - old_len); #endif return ptr; }
void *acl_default_malloc(const char *filename, int line, size_t len) { const char *myname = "acl_default_malloc"; size_t new_len; char *ptr; MBLOCK *real_ptr; const char *pname = NULL; #if 0 printf("%s:%d, len: %d\r\n", filename, line, (int) len); acl_trace_info(); #endif if (filename && *filename) SET_FILE(pname, filename); else pname = __FILENAME_UNKNOWN; if (len < 1) { acl_msg_warn("%s(%d), %s: malloc: length %ld invalid", pname, line, myname, (long) len); len = 128; } new_len = SPACE_FOR(len); if (new_len <= 0) acl_msg_fatal("%s(%d): new_len(%d) <= 0", myname, __LINE__, (int) new_len); else if (new_len >= __malloc_limit) { acl_msg_warn("%s(%d): new_len(%d) too large", myname, __LINE__, (int) new_len); } #ifdef _USE_GLIB if ((real_ptr = (MBLOCK *) g_malloc(new_len)) == 0) { acl_msg_error("%s(%d)->%s: new_len: %d, g_malloc error(%s)", pname, line, myname, (int) new_len, strerror(errno)); return 0; } #else if ((real_ptr = (MBLOCK *) malloc(new_len)) == 0) { acl_msg_error("%s(%d)->%s: malloc: insufficient memory: %s, " "new_len: %d", pname, line, myname, strerror(errno), (int) new_len); return 0; } #endif CHECK_OUT_PTR(ptr, real_ptr, len); #if 0 memset(ptr, FILLER, len); #endif return ptr; }
void *acl_default_malloc(const char *filename, int line, size_t len) { const char *myname = "acl_default_malloc"; size_t new_len; char *ptr; MBLOCK *real_ptr; const char *pname = NULL; if (filename && *filename) SET_FILE(pname, filename); else pname = __FILENAME_UNKNOWN; if (len < 1) acl_msg_fatal("%s(%d)->%s: malloc: requested length %ld invalid", pname, line, myname, (long) len); new_len = SPACE_FOR(len); if (new_len <= 0) acl_msg_fatal("%s(%d): new_len(%d) <= 0", myname, __LINE__, (int) new_len); else if (new_len >= 100000000) acl_msg_warn("%s(%d): new_len(%d) too large", myname, __LINE__, (int) new_len); #ifdef _USE_GLIB if ((real_ptr = (MBLOCK *) g_malloc(new_len)) == 0) { acl_msg_error("%s(%d)->%s: g_malloc error(%s)", pname, line, myname, strerror(errno)); return (0); } #else if ((real_ptr = (MBLOCK *) malloc(new_len)) == 0) { acl_msg_error("%s(%d)->%s: malloc: insufficient memory: %s", pname, line, myname, strerror(errno)); return (0); } #endif CHECK_OUT_PTR(ptr, real_ptr, len); #if 0 memset(ptr, FILLER, len); #endif return (ptr); }
char *mymalloc(ssize_t len) { char *ptr; MBLOCK *real_ptr; /* * Note: for safety reasons the request length is a signed type. This * allows us to catch integer overflow problems that weren't already * caught up-stream. */ if (len < 1) msg_panic("mymalloc: requested length %ld", (long) len); #ifdef MYMALLOC_FUZZ len += MYMALLOC_FUZZ; #endif if ((real_ptr = (MBLOCK *) malloc(SPACE_FOR(len))) == 0) msg_fatal("mymalloc: insufficient memory for %ld bytes: %m", (long) len); CHECK_OUT_PTR(ptr, real_ptr, len); memset(ptr, FILLER, len); return (ptr); }
static void tls_mem_free(const char *filename, int line, void *ptr) { MBLOCK *real_ptr; size_t len; CHECK_IN_PTR2(ptr, real_ptr, len, filename, line); #if 1 if (real_ptr->mem_slice->tid != (unsigned long) acl_pthread_self()) { #else if (real_ptr->mem_slice->tid != mem_slice->tid) { #endif MUTEX_LOCK(real_ptr->mem_slice); PRIVATE_ARRAY_PUSH(real_ptr->mem_slice->list, real_ptr); MUTEX_UNLOCK(real_ptr->mem_slice); } else acl_slice_pool_free(filename, line, real_ptr); } static void *tls_mem_alloc(const char *filename, int line, size_t len) { const char *myname = "tls_mem_alloc"; ACL_MEM_SLICE *mem_slice = acl_pthread_getspecific(__mem_slice_key); char *ptr; MBLOCK *real_ptr; if (mem_slice == NULL) { /* 每个子线程获得自己的线程局部存储内存池 */ mem_slice = mem_slice_create(); mem_slice->slice_list = __mem_slice_list; /* 将子线程的线程局部存储内存池置入全局内存池句柄集合中 */ if (__mem_slice_list_lock) thread_mutex_lock(__mem_slice_list_lock); private_array_push(__mem_slice_list, mem_slice); if (__mem_slice_list_lock) thread_mutex_unlock(__mem_slice_list_lock); } real_ptr = (MBLOCK *) acl_slice_pool_alloc(filename, line, mem_slice->slice_pool, SPACE_FOR(len)); if (real_ptr == 0) { acl_msg_error("%s(%d): malloc: insufficient memory", myname, __LINE__); return 0; } mem_slice->nalloc++; if (mem_slice->nalloc == mem_slice->nalloc_gc) { mem_slice->nalloc = 0; mem_slice_gc(mem_slice); } CHECK_OUT_PTR(ptr, real_ptr, mem_slice, len); return ptr; } static void *tls_mem_calloc(const char *filename, int line, size_t nmemb, size_t size) { void *ptr = tls_mem_alloc(filename, line, nmemb * size); memset(ptr, 0, nmemb * size); return ptr; }