/* * A basic header of information wrapper allocator. Simply stores * information as a header, returns the memory + 1 past it, can be * retrieved again with - 1. Where type is stat_mem_block_t*. */ void *stat_mem_allocate(size_t size, size_t line, const char *file) { stat_mem_block_t *info = (stat_mem_block_t*)malloc(sizeof(stat_mem_block_t) + size); void *data = (void*)(info + 1); if(GMQCC_UNLIKELY(!info)) return NULL; info->line = line; info->size = size; info->file = file; info->prev = NULL; info->next = stat_mem_block_root; /* likely since it only happens once */ if (GMQCC_LIKELY(stat_mem_block_root != NULL)) { VALGRIND_MAKE_MEM_DEFINED(stat_mem_block_root, sizeof(stat_mem_block_t)); stat_mem_block_root->prev = info; VALGRIND_MAKE_MEM_NOACCESS(stat_mem_block_root, sizeof(stat_mem_block_t)); } stat_mem_block_root = info; stat_mem_allocated += size; stat_mem_high += size; stat_mem_allocated_total ++; if (stat_mem_high > stat_mem_peak) stat_mem_peak = stat_mem_high; VALGRIND_MALLOCLIKE_BLOCK(data, size, sizeof(stat_mem_block_t), 0); return data; }
/* * A basic header of information wrapper allocator. Simply stores * information as a header, returns the memory + 1 past it, can be * retrieved again with - 1. Where type is stat_mem_block_t*. */ void *stat_mem_allocate(size_t size, size_t line, const char *file, const char *expr) { stat_mem_block_t *info = (stat_mem_block_t*)malloc(size + IDENT_MEM_TOP); void *data = (void *)((char*)info + IDENT_MEM_TOP); if(GMQCC_UNLIKELY(!info)) return NULL; info->line = line; info->size = size; info->file = file; info->expr = expr; info->prev = NULL; info->next = stat_mem_block_root; /* Write identifier */ memcpy(info + 1, IDENT_MEM, IDENT_SIZE); /* likely since it only happens once */ if (GMQCC_LIKELY(stat_mem_block_root != NULL)) { VALGRIND_MAKE_MEM_DEFINED(stat_mem_block_root, IDENT_MEM_TOP); stat_mem_block_root->prev = info; VALGRIND_MAKE_MEM_NOACCESS(stat_mem_block_root, IDENT_MEM_TOP); } stat_mem_block_root = info; stat_mem_allocated += size; stat_mem_high += size; stat_mem_allocated_total ++; if (stat_mem_high > stat_mem_peak) stat_mem_peak = stat_mem_high; VALGRIND_MALLOCLIKE_BLOCK(data, size, IDENT_MEM_TOP, 0); return data; }
void stat_mem_deallocate(void *ptr) { stat_mem_block_t *info = NULL; if (GMQCC_UNLIKELY(!ptr)) return; info = ((stat_mem_block_t*)ptr - 1); /* * we need access to the redzone that represents the info block * so lets do that. */ VALGRIND_MAKE_MEM_DEFINED(info, sizeof(stat_mem_block_t)); stat_mem_deallocated += info->size; stat_mem_high -= info->size; stat_mem_deallocated_total ++; if (info->prev) { /* just need access for a short period */ VALGRIND_MAKE_MEM_DEFINED(info->prev, sizeof(stat_mem_block_t)); info->prev->next = info->next; /* don't need access anymore */ VALGRIND_MAKE_MEM_NOACCESS(info->prev, sizeof(stat_mem_block_t)); } if (info->next) { /* just need access for a short period */ VALGRIND_MAKE_MEM_DEFINED(info->next, sizeof(stat_mem_block_t)); info->next->prev = info->prev; /* don't need access anymore */ VALGRIND_MAKE_MEM_NOACCESS(info->next, sizeof(stat_mem_block_t)); } /* move ahead */ if (info == stat_mem_block_root) stat_mem_block_root = info->next; free(info); VALGRIND_MAKE_MEM_NOACCESS(info, sizeof(stat_mem_block_t)); VALGRIND_FREELIKE_BLOCK(ptr, sizeof(stat_mem_block_t)); }
void *stat_mem_reallocate(void *ptr, size_t size, size_t line, const char *file) { stat_mem_block_t *oldinfo = NULL; stat_mem_block_t *newinfo; if (GMQCC_UNLIKELY(!ptr)) return stat_mem_allocate(size, line, file); /* stay consistent with glibc */ if (GMQCC_UNLIKELY(!size)) { stat_mem_deallocate(ptr); return NULL; } oldinfo = ((stat_mem_block_t*)ptr - 1); newinfo = ((stat_mem_block_t*)malloc(sizeof(stat_mem_block_t) + size)); if (GMQCC_UNLIKELY(!newinfo)) { stat_mem_deallocate(ptr); return NULL; } VALGRIND_MALLOCLIKE_BLOCK(newinfo + 1, size, sizeof(stat_mem_block_t), 0); /* we need access to the old info redzone */ VALGRIND_MAKE_MEM_DEFINED(oldinfo, sizeof(stat_mem_block_t)); memcpy(newinfo+1, oldinfo+1, oldinfo->size); if (oldinfo->prev) { /* just need access for a short period */ VALGRIND_MAKE_MEM_DEFINED(oldinfo->prev, sizeof(stat_mem_block_t)); oldinfo->prev->next = oldinfo->next; /* don't need access anymore */ VALGRIND_MAKE_MEM_NOACCESS(oldinfo->prev, sizeof(stat_mem_block_t)); } if (oldinfo->next) { /* just need access for a short period */ VALGRIND_MAKE_MEM_DEFINED(oldinfo->next, sizeof(stat_mem_block_t)); oldinfo->next->prev = oldinfo->prev; /* don't need access anymore */ VALGRIND_MAKE_MEM_NOACCESS(oldinfo->next, sizeof(stat_mem_block_t)); } /* move ahead */ if (oldinfo == stat_mem_block_root) stat_mem_block_root = oldinfo->next; /* we need access to the redzone for the newinfo block */ VALGRIND_MAKE_MEM_DEFINED(newinfo, sizeof(stat_mem_block_t)); newinfo->line = line; newinfo->size = size; newinfo->file = file; newinfo->prev = NULL; newinfo->next = stat_mem_block_root; /* * likely since the only time there is no root is when it's * being initialized first. */ if (GMQCC_LIKELY(stat_mem_block_root != NULL)) { /* we need access to the root */ VALGRIND_MAKE_MEM_DEFINED(stat_mem_block_root, sizeof(stat_mem_block_t)); stat_mem_block_root->prev = newinfo; /* kill access */ VALGRIND_MAKE_MEM_NOACCESS(stat_mem_block_root, sizeof(stat_mem_block_t)); } stat_mem_block_root = newinfo; stat_mem_allocated -= oldinfo->size; stat_mem_high -= oldinfo->size; stat_mem_allocated += newinfo->size; stat_mem_high += newinfo->size; /* * we're finished with the redzones, lets kill the access * to them. */ VALGRIND_MAKE_MEM_NOACCESS(newinfo, sizeof(stat_mem_block_t)); VALGRIND_MAKE_MEM_NOACCESS(oldinfo, sizeof(stat_mem_block_t)); if (stat_mem_high > stat_mem_peak) stat_mem_peak = stat_mem_high; free(oldinfo); VALGRIND_FREELIKE_BLOCK(ptr, sizeof(stat_mem_block_t)); return newinfo + 1; }
void stat_mem_deallocate(void *ptr, size_t line, const char *file) { stat_mem_block_t *info = NULL; char *ident = (char *)ptr - IDENT_SIZE; if (GMQCC_UNLIKELY(!ptr)) return; /* Validate usage */ VALGRIND_MAKE_MEM_DEFINED(ident, IDENT_SIZE); if (!strcmp(ident, IDENT_VEC)) { vector_t *vec = (vector_t*)((char *)ptr - IDENT_VEC_TOP); stat_mem_block_t *block = (stat_mem_block_t*)((char *)vec - IDENT_MEM_TOP); VALGRIND_MAKE_MEM_DEFINED(block, sizeof(stat_mem_block_t)); con_err("internal warning: invalid use of mem_d:\n"); con_err("internal warning: vector (used elements: %u, allocated elements: %u)\n", (unsigned)vec->used, (unsigned)vec->allocated ); con_err("internal warning: vector was last (re)allocated with (size: %u (bytes), at location: %s:%u)\n", (unsigned)block->size, block->file, (unsigned)block->line ); con_err("internal warning: released with wrong routine at %s:%u\n", file, (unsigned)line); con_err("internal warning: forwarding to vec_free, please fix it\n"); VALGRIND_MAKE_MEM_NOACCESS(block, sizeof(stat_mem_block_t)); VALGRIND_MAKE_MEM_NOACCESS(ident, IDENT_SIZE); vec_free(ptr); return; } VALGRIND_MAKE_MEM_NOACCESS(ident, IDENT_SIZE); info = (stat_mem_block_t*)((char *)ptr - IDENT_MEM_TOP); /* * we need access to the redzone that represents the info block * so lets do that. */ VALGRIND_MAKE_MEM_DEFINED(info, IDENT_MEM_TOP); stat_mem_deallocated += info->size; stat_mem_high -= info->size; stat_mem_deallocated_total ++; if (info->prev) { /* just need access for a short period */ VALGRIND_MAKE_MEM_DEFINED(info->prev, IDENT_MEM_TOP); info->prev->next = info->next; /* don't need access anymore */ VALGRIND_MAKE_MEM_NOACCESS(info->prev, IDENT_MEM_TOP); } if (info->next) { /* just need access for a short period */ VALGRIND_MAKE_MEM_DEFINED(info->next, IDENT_MEM_TOP); info->next->prev = info->prev; /* don't need access anymore */ VALGRIND_MAKE_MEM_NOACCESS(info->next, IDENT_MEM_TOP); } /* move ahead */ if (info == stat_mem_block_root) stat_mem_block_root = info->next; free(info); VALGRIND_MAKE_MEM_NOACCESS(info, IDENT_MEM_TOP); VALGRIND_FREELIKE_BLOCK(ptr, IDENT_MEM_TOP); }