void hp_status(struct hp_block *qm)
{
struct hp_frag* f;
unsigned int i,j;
unsigned int h;
int unused;
unsigned long size;
LM_GEN1(memdump, "hp_status (%p):\n", qm);
if (!qm) return;
LM_GEN1(memdump, " heap size= %ld\n", qm->size);
#ifdef STATISTICS
LM_GEN1(memdump, " used= %lu, used+overhead=%lu, free=%lu\n",
qm->used, qm->real_used, qm->size-qm->used);
LM_GEN1(memdump, " max used (+overhead)= %lu\n", qm->max_real_used);
#endif
LM_GEN1(memdump, "dumping free list:\n");
for(h=0,i=0,size=0; h<HP_HASH_SIZE; h++) {
unused=0;
for (f=qm->free_hash[h].first,j=0; f;
size+=f->size,f=f->u.nxt_free,i++,j++) { }
if (j) LM_GEN1(memdump,"hash = %3d fragments no.: %5d, unused: %5d\n\t\t"
" bucket size: %9lu - %9lu (first %9lu)\n",
h, j, unused, UN_HASH(h),
((h<=HP_MALLOC_OPTIMIZE/ROUNDTO)?1:2)* UN_HASH(h),
qm->free_hash[h].first->size
);
if (j!=qm->free_hash[h].no) {
LM_CRIT("different free frag. count: %d!=%ld"
" for hash %3d\n", j, qm->free_hash[h].no, h);
}
}
LM_GEN1(memdump, "TOTAL: %6d free fragments = %6lu free bytes\n", i, size);
LM_GEN1(memdump, "TOTAL: %ld large bytes\n", qm->large_space );
LM_GEN1(memdump, "TOTAL: %u overhead\n", (unsigned int)FRAG_OVERHEAD );
LM_GEN1(memdump, "-----------------------------\n");
}
void update_shm_stats(struct hp_block *hpb)
{
struct hp_frag_lnk *bucket, *it;
int i, j, used_mem;
unsigned long in_use_frags;
long size = 0;
lock_get(hp_stats_lock);
hpb->used = hpb->real_used = hpb->total_fragments = 0;
for (i = 0, bucket = hpb->free_hash;
bucket < &hpb->free_hash[HP_HASH_SIZE];
i++, bucket++) {
size = UN_HASH(i);
if (!bucket->is_optimized) {
in_use_frags = bucket->total_no - bucket->no;
used_mem = in_use_frags * size;
hpb->used += used_mem;
hpb->real_used += used_mem + bucket->total_no * FRAG_OVERHEAD;
hpb->total_fragments += bucket->total_no;
} else {
for (j = 0, it = &hpb->free_hash[HP_HASH_SIZE + i * shm_secondary_hash_size];
j < shm_secondary_hash_size;
j++, it++) {
in_use_frags = it->total_no - it->no;
used_mem = in_use_frags * size;
hpb->used += used_mem;
hpb->real_used += used_mem + it->total_no * FRAG_OVERHEAD;
hpb->total_fragments += it->total_no;
}
}
}
if (hpb->real_used > hpb->max_real_used)
hpb->max_real_used = hpb->real_used;
LM_DBG("updated shm statistics: [ us: %ld | rus: %ld | frags: %ld ]\n",
hpb->used, hpb->real_used, hpb->total_fragments);
gettimeofday(&hpb->last_updated, NULL);
lock_release(hp_stats_lock);
}
/* fills a malloc info structure with info about the block
* if a parameter is not supported, it will be filled with 0 */
void fm_info(struct fm_block* qm, struct mem_info* info)
{
unsigned int r;
long total_frags;
#if !defined(DBG_F_MALLOC) && !defined(STATISTICS)
struct fm_frag* f;
#endif
memset(info,0, sizeof(*info));
total_frags=0;
info->total_size=qm->size;
info->min_frag=MIN_FRAG_SIZE;
#if defined(DBG_F_MALLOC) || defined(STATISTICS)
info->free=qm->size-qm->real_used;
info->used=qm->used;
info->real_used=qm->real_used;
info->max_used=qm->max_real_used;
for(r=0;r<F_HASH_SIZE; r++){
total_frags+=qm->free_hash[r].no;
}
#else
/* we'll have to compute it all */
for (r=0; r<=F_MALLOC_OPTIMIZE/ROUNDTO; r++){
info->free+=qm->free_hash[r].no*UN_HASH(r);
total_frags+=qm->free_hash[r].no;
}
for(;r<F_HASH_SIZE; r++){
total_frags+=qm->free_hash[r].no;
for(f=qm->free_hash[r].first;f;f=f->u.nxt_free){
info->free+=f->size;
}
}
info->real_used=info->total_size-info->free;
info->used=0; /* we don't really now */
info->max_used=0; /* we don't really now */
#endif
info->total_frags=total_frags;
}
int split_frag(struct qm_block* qm, struct qm_frag* f, unsigned long new_size)
#endif
{
unsigned long rest;
struct qm_frag* n;
struct qm_frag_end* end;
rest=f->size-new_size;
#ifdef MEM_FRAG_AVOIDANCE
if ((rest> (FRAG_OVERHEAD+QM_MALLOC_OPTIMIZE))||
(rest>=(FRAG_OVERHEAD+new_size))){/* the residue fragm. is big enough*/
#else
if (rest>(FRAG_OVERHEAD+MIN_FRAG_SIZE)){
#endif
f->size=new_size;
/*split the fragment*/
end=FRAG_END(f);
end->size=new_size;
n=(struct qm_frag*)((char*)end+sizeof(struct qm_frag_end));
n->size=rest-FRAG_OVERHEAD;
FRAG_END(n)->size=n->size;
FRAG_CLEAR_USED(n); /* never used */
qm->real_used+=FRAG_OVERHEAD;
#ifdef DBG_QM_MALLOC
end->check1=END_CHECK_PATTERN1;
end->check2=END_CHECK_PATTERN2;
/* frag created by malloc, mark it*/
n->file=file;
n->func=func;
n->line=line;
n->check=ST_CHECK_PATTERN;
#endif
/* reinsert n in free list*/
qm_insert_free(qm, n);
return 0;
}else{
/* we cannot split this fragment any more */
return -1;
}
}
#ifdef DBG_QM_MALLOC
void* qm_malloc(struct qm_block* qm, unsigned long size,
const char* file, const char* func, unsigned int line)
#else
void* qm_malloc(struct qm_block* qm, unsigned long size)
#endif
{
struct qm_frag* f;
int hash;
#ifdef DBG_QM_MALLOC
unsigned int list_cntr;
list_cntr = 0;
LM_GEN1( memlog, "params (%p, %lu), called from %s: %s(%d)\n",
qm, size, file, func, line);
#endif
/*size must be a multiple of 8*/
size=ROUNDUP(size);
if (size>(qm->size-qm->real_used)) return 0;
/*search for a suitable free frag*/
#ifdef DBG_QM_MALLOC
if ((f=qm_find_free(qm, size, &hash, &list_cntr))!=0){
#else
if ((f=qm_find_free(qm, size, &hash))!=0){
#endif
/* we found it!*/
/*detach it from the free list*/
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, f);
#endif
qm_detach_free(qm, f);
/*mark it as "busy"*/
f->u.is_free=0;
qm->free_hash[hash].no--;
/* we ignore split return */
#ifdef DBG_QM_MALLOC
split_frag(qm, f, size, file, "fragm. from qm_malloc", line);
#else
split_frag(qm, f, size);
#endif
qm->real_used+=f->size;
qm->used+=f->size;
if (qm->max_real_used<qm->real_used)
qm->max_real_used=qm->real_used;
#ifdef DBG_QM_MALLOC
f->file=file;
f->func=func;
f->line=line;
f->check=ST_CHECK_PATTERN;
/* FRAG_END(f)->check1=END_CHECK_PATTERN1;
FRAG_END(f)->check2=END_CHECK_PATTERN2;*/
LM_GEN1( memlog, "params (%p, %lu), returns address %p frag. %p "
"(size=%lu) on %d -th hit\n",
qm, size, (char*)f+sizeof(struct qm_frag), f, f->size, list_cntr );
#endif
return (char*)f+sizeof(struct qm_frag);
}
return 0;
}
#ifdef DBG_QM_MALLOC
void qm_free(struct qm_block* qm, void* p, const char* file, const char* func,
unsigned int line)
#else
void qm_free(struct qm_block* qm, void* p)
#endif
{
struct qm_frag* f;
unsigned long size;
#ifdef QM_JOIN_FREE
struct qm_frag* next;
struct qm_frag* prev;
#endif
#ifdef DBG_QM_MALLOC
LM_GEN1( memlog, "params(%p, %p), called from %s: %s(%d)\n",
qm, p, file, func, line);
if (p>(void*)qm->last_frag_end || p<(void*)qm->first_frag){
LM_CRIT("bad pointer %p (out of memory block!) - aborting\n", p);
abort();
}
#endif
if (p==0) {
LM_WARN("free(0) called\n");
return;
}
#ifdef QM_JOIN_FREE
prev=next=0;
#endif
f=(struct qm_frag*) ((char*)p-sizeof(struct qm_frag));
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, f);
if (f->u.is_free){
LM_CRIT("freeing already freed pointer,"
" first free: %s: %s(%ld) - aborting\n",
f->file, f->func, f->line);
abort();
}
LM_GEN1( memlog, "freeing frag. %p alloc'ed from %s: %s(%ld)\n",
f, f->file, f->func, f->line);
#endif
size=f->size;
qm->used-=size;
qm->real_used-=size;
#ifdef QM_JOIN_FREE
/* join packets if possible*/
next=FRAG_NEXT(f);
if (((char*)next < (char*)qm->last_frag_end) &&( next->u.is_free)){
/* join */
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, next);
#endif
qm_detach_free(qm, next);
size+=next->size+FRAG_OVERHEAD;
qm->real_used-=FRAG_OVERHEAD;
qm->free_hash[GET_HASH(next->size)].no--; /* FIXME slow */
}
if (f > qm->first_frag){
prev=FRAG_PREV(f);
/* (struct qm_frag*)((char*)f - (struct qm_frag_end*)((char*)f-
sizeof(struct qm_frag_end))->size);*/
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, prev);
#endif
if (prev->u.is_free){
/*join*/
qm_detach_free(qm, prev);
size+=prev->size+FRAG_OVERHEAD;
qm->real_used-=FRAG_OVERHEAD;
qm->free_hash[GET_HASH(prev->size)].no--; /* FIXME slow */
f=prev;
}
}
f->size=size;
FRAG_END(f)->size=f->size;
#endif /* QM_JOIN_FREE*/
#ifdef DBG_QM_MALLOC
f->file=file;
f->func=func;
f->line=line;
#endif
qm_insert_free(qm, f);
}
#ifdef DBG_QM_MALLOC
void* qm_realloc(struct qm_block* qm, void* p, unsigned long size,
const char* file, const char* func, unsigned int line)
#else
void* qm_realloc(struct qm_block* qm, void* p, unsigned long size)
#endif
{
struct qm_frag* f;
unsigned long diff;
unsigned long orig_size;
struct qm_frag* n;
void* ptr;
#ifdef DBG_QM_MALLOC
LM_GEN1( memlog, "params (%p, %p, %lu), called from %s: %s(%d)\n",
qm, p, size, file, func, line);
if ((p)&&(p>(void*)qm->last_frag_end || p<(void*)qm->first_frag)){
LM_CRIT("bad pointer %p (out of memory block!) - aborting\n", p);
abort();
}
#endif
if (size==0) {
if (p)
#ifdef DBG_QM_MALLOC
qm_free(qm, p, file, func, line);
#else
qm_free(qm, p);
#endif
return 0;
}
if (p==0)
#ifdef DBG_QM_MALLOC
return qm_malloc(qm, size, file, func, line);
#else
return qm_malloc(qm, size);
#endif
f=(struct qm_frag*) ((char*)p-sizeof(struct qm_frag));
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, f);
LM_GEN1( memlog, "realloc'ing frag %p alloc'ed from %s: %s(%ld)\n",
f, f->file, f->func, f->line);
if (f->u.is_free){
LM_CRIT("trying to realloc an already freed "
"pointer %p , fragment %p -- aborting\n", p, f);
abort();
}
#endif
/* find first acceptable size */
size=ROUNDUP(size);
if (f->size > size){
orig_size=f->size;
/* shrink */
#ifdef DBG_QM_MALLOC
LM_GEN1(memlog,"shrinking from %lu to %lu\n", f->size, size);
if(split_frag(qm, f, size, file, "fragm. from qm_realloc", line)!=0){
LM_GEN1(memlog,"shrinked successful\n");
#else
if(split_frag(qm, f, size)!=0){
#endif
/* update used sizes: freed the spitted frag */
qm->real_used-=(orig_size-f->size-FRAG_OVERHEAD);
qm->used-=(orig_size-f->size);
}
}else if (f->size < size){
/* grow */
#ifdef DBG_QM_MALLOC
LM_GEN1( memlog, "growing from %lu to %lu\n", f->size, size);
#endif
orig_size=f->size;
diff=size-f->size;
n=FRAG_NEXT(f);
if (((char*)n < (char*)qm->last_frag_end) &&
(n->u.is_free)&&((n->size+FRAG_OVERHEAD)>=diff)){
/* join */
qm_detach_free(qm, n);
qm->free_hash[GET_HASH(n->size)].no--; /*FIXME: slow*/
f->size+=n->size+FRAG_OVERHEAD;
qm->real_used-=FRAG_OVERHEAD;
FRAG_END(f)->size=f->size;
/* end checks should be ok */
/* split it if necessary */
if (f->size > size ){
#ifdef DBG_QM_MALLOC
split_frag(qm, f, size, file, "fragm. from qm_realloc",
line);
#else
split_frag(qm, f, size);
#endif
}
qm->real_used+=(f->size-orig_size);
qm->used+=(f->size-orig_size);
}else{
/* could not join => realloc */
#ifdef DBG_QM_MALLOC
ptr=qm_malloc(qm, size, file, func, line);
#else
ptr=qm_malloc(qm, size);
#endif
if (ptr) {
/* copy, need by libssl */
memcpy(ptr, p, orig_size);
#ifdef DBG_QM_MALLOC
qm_free(qm, p, file, func, line);
#else
qm_free(qm, p);
#endif
}
p=ptr;
}
}else{
/* do nothing */
#ifdef DBG_QM_MALLOC
LM_GEN1(memlog,"doing nothing, same size: %lu - %lu\n", f->size, size);
#endif
}
#ifdef DBG_QM_MALLOC
LM_GEN1(memlog,"returning %p\n", p);
#endif
return p;
}
void qm_status(struct qm_block* qm)
{
struct qm_frag* f;
int i,j;
int h;
int unused;
LM_GEN1(memdump, "qm_status (%p):\n", qm);
if (!qm) return;
LM_GEN1(memdump, " heap size= %lu\n", qm->size);
LM_GEN1(memdump, " used= %lu, used+overhead=%lu, free=%lu\n",
qm->used, qm->real_used, qm->size-qm->real_used);
LM_GEN1(memdump, " max used (+overhead)= %lu\n", qm->max_real_used);
LM_GEN1(memdump, "dumping all alloc'ed. fragments:\n");
for (f=qm->first_frag, i=0;(char*)f<(char*)qm->last_frag_end;f=FRAG_NEXT(f)
,i++){
if (! f->u.is_free){
LM_GEN1(memdump," %3d. %c address=%p frag=%p size=%lu used=%d\n",
i,
(f->u.is_free)?'a':'N',
(char*)f+sizeof(struct qm_frag), f, f->size, FRAG_WAS_USED(f));
#ifdef DBG_QM_MALLOC
LM_GEN1(memdump, " %s from %s: %s(%ld)\n",
(f->u.is_free)?"freed":"alloc'd", f->file, f->func, f->line);
LM_GEN1(memdump, " start check=%lx, end check= %lx, %lx\n",
f->check, FRAG_END(f)->check1, FRAG_END(f)->check2);
#endif
}
}
LM_GEN1(memdump, "dumping free list stats :\n");
for(h=0,i=0;h<QM_HASH_SIZE;h++){
unused=0;
for (f=qm->free_hash[h].head.u.nxt_free,j=0;
f!=&(qm->free_hash[h].head); f=f->u.nxt_free, i++, j++){
if (!FRAG_WAS_USED(f)){
unused++;
#ifdef DBG_QM_MALLOC
LM_GEN1(memdump, "unused fragm.: hash = %3d, fragment %p,"
" address %p size %lu, created from %s: %s(%lu)\n",
h, f, (char*)f+sizeof(struct qm_frag), f->size,
f->file, f->func, f->line);
#endif
}
}
if (j) LM_GEN1(memdump, "hash= %3d. fragments no.: %5d, unused: %5d\n"
"\t\t bucket size: %9lu - %9ld (first %9lu)\n",
h, j, unused, UN_HASH(h),
((h<=QM_MALLOC_OPTIMIZE/ROUNDTO)?1:2)*UN_HASH(h),
qm->free_hash[h].head.u.nxt_free->size
);
if (j!=qm->free_hash[h].no){
LM_CRIT("different free frag. count: %d!=%lu"
" for hash %3d\n", j, qm->free_hash[h].no, h);
}
}
LM_GEN1(memdump, "-----------------------------\n");
}
/* fills a malloc info structure with info about the block
* if a parameter is not supported, it will be filled with 0 */
void qm_info(struct qm_block* qm, struct mem_info* info)
{
int r;
long total_frags;
total_frags=0;
memset(info,0, sizeof(*info));
info->total_size=qm->size;
info->min_frag=MIN_FRAG_SIZE;
info->free=qm->size-qm->real_used;
info->used=qm->used;
info->real_used=qm->real_used;
info->max_used=qm->max_real_used;
for(r=0;r<QM_HASH_SIZE; r++){
total_frags+=qm->free_hash[r].no;
}
info->total_frags=total_frags;
}
void hp_status(struct hp_block *hpb)
{
struct hp_frag *f;
int i, j, si, t = 0;
int h;
LM_GEN1(memdump, "hp_status (%p, ROUNDTO=%ld):\n", hpb, ROUNDTO);
if (!hpb)
return;
LM_GEN1(memdump, "%20s : %ld\n", "HP_HASH_SIZE", HP_HASH_SIZE);
LM_GEN1(memdump, "%20s : %ld\n", "HP_EXTRA_HASH_SIZE", HP_HASH_SIZE);
LM_GEN1(memdump, "%20s : %ld\n", "HP_TOTAL_SIZE", HP_HASH_SIZE);
LM_GEN1(memdump, "%20s : %ld\n", "total_size", hpb->size);
#ifdef STATISTICS
LM_GEN1(memdump, "%20s : %lu\n%20s : %lu\n%20s : %lu\n",
"used", hpb->used,
"used+overhead", hpb->real_used,
"free", hpb->size - hpb->used);
LM_GEN1(memdump, "%20s : %lu\n\n", "max_used (+overhead)", hpb->max_real_used);
#endif
LM_GEN1(memdump, "Dumping free fragments:\n");
for (h = 0; h < HP_HASH_SIZE; h++) {
if (hpb->free_hash[h].is_optimized) {
LM_GEN1(memdump, "[ %4d ][ %5d B ][ frags: ", h, h * (int)ROUNDTO);
for (si = HP_HASH_SIZE + h * shm_secondary_hash_size, j = 0;
j < shm_secondary_hash_size; j++, si++, t++) {
SHM_LOCK(si);
for (i=0, f=hpb->free_hash[si].first; f; f=f->u.nxt_free, i++, t++)
;
SHM_UNLOCK(si);
LM_GEN1(memdump, "%s%5d ", j == 0 ? "" : "| ", i);
}
LM_GEN1(memdump, "]\n");
} else {
SHM_LOCK(h);
for (i=0, f=hpb->free_hash[h].first; f; f=f->u.nxt_free, i++, t++)
;
SHM_UNLOCK(h);
if (i == 0)
continue;
if (h > HP_LINEAR_HASH_SIZE) {
LM_GEN1(memdump, "[ %4d ][ %8d B -> %7d B ][ frags: %5d ]\n",
h, (int)UN_HASH(h), (int)UN_HASH(h+1) - (int)ROUNDTO, i);
} else
LM_GEN1(memdump, "[ %4d ][ %5d B ][ frags: %5d ]\n",
h, h * (int)ROUNDTO, i);
}
}
LM_GEN1(memdump, "TOTAL: %6d free fragments\n", t);
LM_GEN1(memdump, "TOTAL: %ld large bytes\n", hpb->large_space );
LM_GEN1(memdump, "TOTAL: %u overhead\n", (unsigned int)FRAG_OVERHEAD );
LM_GEN1(memdump, "-----------------------------\n");
}
void fm_status(struct fm_block* qm)
{
struct fm_frag* f;
unsigned int i,j;
unsigned int h;
int unused;
unsigned long size;
#ifdef DBG_MALLOC
mem_dbg_htable_t allocd;
struct mem_dbg_entry *it;
#endif
LM_GEN1(memdump, "fm_status (%p):\n", qm);
if (!qm) return;
LM_GEN1(memdump, " heap size= %ld\n", qm->size);
#if defined(DBG_MALLOC) || defined(STATISTICS)
LM_GEN1(memdump, " used= %lu, used+overhead=%lu, free=%lu\n",
qm->used, qm->real_used, qm->size-qm->used);
LM_GEN1(memdump, " max used (+overhead)= %lu\n", qm->max_real_used);
#endif
#if defined(DBG_MALLOC)
dbg_ht_init(allocd);
for (f=qm->first_frag; (char*)f<(char*)qm->last_frag; f=FRAG_NEXT(f))
if (!f->is_free)
if (dbg_ht_update(allocd, f->file, f->func, f->line, f->size) < 0) {
LM_ERR("Unable to update alloc'ed. memory summary\n");
dbg_ht_free(allocd);
return;
}
LM_GEN1(memdump, " dumping summary of all alloc'ed. fragments:\n");
for(i=0; i < DBG_HASH_SIZE; i++) {
it = allocd[i];
while (it) {
LM_GEN1(memdump, " %10lu : %lu x [%s: %s, line %lu]\n",
it->size, it->no_fragments, it->file, it->func, it->line);
it = it->next;
}
}
dbg_ht_free(allocd);
#endif
LM_GEN1(memdump, "dumping free list:\n");
for(h=0,i=0,size=0; h<F_HASH_SIZE; h++) {
unused=0;
for (f=qm->free_hash[h].first,j=0; f;
size+=f->size,f=f->u.nxt_free,i++,j++) { }
if (j) LM_GEN1(memdump,"hash = %3d fragments no.: %5d, unused: %5d\n\t\t"
" bucket size: %9lu - %9lu (first %9lu)\n",
h, j, unused, UN_HASH(h),
((h<=F_MALLOC_OPTIMIZE/ROUNDTO)?1:2)* UN_HASH(h),
qm->free_hash[h].first->size
);
if (j!=qm->free_hash[h].no) {
LM_CRIT("different free frag. count: %d!=%ld"
" for hash %3d\n", j, qm->free_hash[h].no, h);
}
}
LM_GEN1(memdump, "TOTAL: %6d free fragments = %6lu free bytes\n", i, size);
LM_GEN1(memdump, "TOTAL: %ld large bytes\n", qm->large_space );
LM_GEN1(memdump, "TOTAL: %u overhead\n", (unsigned int)FRAG_OVERHEAD );
LM_GEN1(memdump, "-----------------------------\n");
}
int split_frag(struct qm_block* qm, struct qm_frag* f, unsigned long new_size)
#endif
{
unsigned long rest;
struct qm_frag* n;
struct qm_frag_end* end;
rest=f->size-new_size;
#ifdef MEM_FRAG_AVOIDANCE
if ((rest> (FRAG_OVERHEAD+QM_MALLOC_OPTIMIZE))||
(rest>=(FRAG_OVERHEAD+new_size))){/* the residue fragm. is big enough*/
#else
if (rest>(FRAG_OVERHEAD+MIN_FRAG_SIZE)){
#endif
f->size=new_size;
/*split the fragment*/
end=FRAG_END(f);
end->size=new_size;
n=(struct qm_frag*)((char*)end+sizeof(struct qm_frag_end));
n->size=rest-FRAG_OVERHEAD;
FRAG_END(n)->size=n->size;
FRAG_CLEAR_USED(n); /* never used */
qm->real_used+=FRAG_OVERHEAD;
#ifdef DBG_QM_MALLOC
end->check1=END_CHECK_PATTERN1;
end->check2=END_CHECK_PATTERN2;
/* frag created by malloc, mark it*/
n->file=file;
n->func=func;
n->line=line;
n->check=ST_CHECK_PATTERN;
#endif
/* reinsert n in free list*/
qm_insert_free(qm, n);
return 0;
}else{
/* we cannot split this fragment any more */
return -1;
}
}
#ifdef DBG_QM_MALLOC
void* qm_malloc(void* qmp, unsigned long size,
const char* file, const char* func, unsigned int line)
#else
void* qm_malloc(void* qmp, unsigned long size)
#endif
{
struct qm_block* qm;
struct qm_frag* f;
int hash;
#ifdef DBG_QM_MALLOC
unsigned int list_cntr;
#endif
qm = (struct qm_block*)qmp;
#ifdef DBG_QM_MALLOC
list_cntr = 0;
MDBG("qm_malloc(%p, %lu) called from %s: %s(%d)\n", qm, size, file, func,
line);
#endif
/*malloc(0) should return a valid pointer according to specs*/
if(unlikely(size==0)) size=4;
/*size must be a multiple of 8*/
size=ROUNDUP(size);
if (size>(qm->size-qm->real_used)) return 0;
/*search for a suitable free frag*/
#ifdef DBG_QM_MALLOC
if ((f=qm_find_free(qm, size, &hash, &list_cntr))!=0){
#else
if ((f=qm_find_free(qm, size, &hash))!=0){
#endif
/* we found it!*/
/*detach it from the free list*/
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, f);
#endif
qm_detach_free(qm, f);
/*mark it as "busy"*/
f->u.is_free=0;
qm->free_hash[hash].no--;
qm->ffrags--;
/* we ignore split return */
#ifdef DBG_QM_MALLOC
split_frag(qm, f, size, file, "fragm. from qm_malloc", line);
#else
split_frag(qm, f, size);
#endif
qm->real_used+=f->size;
qm->used+=f->size;
if (qm->max_real_used<qm->real_used)
qm->max_real_used=qm->real_used;
#ifdef DBG_QM_MALLOC
f->file=file;
f->func=func;
f->line=line;
f->check=ST_CHECK_PATTERN;
/* FRAG_END(f)->check1=END_CHECK_PATTERN1;
FRAG_END(f)->check2=END_CHECK_PATTERN2;*/
MDBG("qm_malloc(%p, %lu) returns address %p frag. %p (size=%lu) on %d"
" -th hit\n",
qm, size, (char*)f+sizeof(struct qm_frag), f, f->size, list_cntr );
#endif
#ifdef MALLOC_STATS
if(qm->type==MEM_TYPE_PKG) {
sr_event_exec(SREV_PKG_UPDATE_STATS, 0);
}
#endif
return (char*)f+sizeof(struct qm_frag);
}
return 0;
}
#ifdef DBG_QM_MALLOC
void qm_free(void* qmp, void* p, const char* file, const char* func,
unsigned int line)
#else
void qm_free(void* qmp, void* p)
#endif
{
struct qm_block* qm;
struct qm_frag* f;
unsigned long size;
#ifdef MEM_JOIN_FREE
struct qm_frag* next;
struct qm_frag* prev;
#endif /* MEM_JOIN_FREE*/
qm = (struct qm_block*)qmp;
#ifdef DBG_QM_MALLOC
MDBG("qm_free(%p, %p), called from %s: %s(%d)\n", qm, p, file, func, line);
#endif
if (p==0) {
#ifdef DBG_QM_MALLOC
LOG(L_WARN, "WARNING:qm_free: free(0) called from %s: %s(%d)\n", file, func, line);
#else
LOG(L_WARN, "WARNING:qm_free: free(0) called\n");
#endif
return;
}
#ifdef DBG_QM_MALLOC
if (p>(void*)qm->last_frag_end || p<(void*)qm->first_frag){
LOG(L_CRIT, "BUG: qm_free: bad pointer %p (out of memory block!)"
" called from %s: %s(%d) - aborting\n", p, file, func, line);
if(likely(cfg_get(core, core_cfg, mem_safety)==0))
abort();
else return;
}
#endif
f=(struct qm_frag*) ((char*)p-sizeof(struct qm_frag));
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, f);
if (f->u.is_free){
LOG(L_CRIT, "BUG: qm_free: freeing already freed pointer (%p),"
" called from %s: %s(%d), first free %s: %s(%ld) - aborting\n",
p, file, func, line, f->file, f->func, f->line);
if(likely(cfg_get(core, core_cfg, mem_safety)==0))
abort();
else return;
}
MDBG("qm_free: freeing frag. %p alloc'ed from %s: %s(%ld)\n",
f, f->file, f->func, f->line);
#endif
if (unlikely(f->u.is_free)){
LM_INFO("freeing a free fragment (%p/%p) - ignore\n",
f, p);
return;
}
size=f->size;
qm->used-=size;
qm->real_used-=size;
#ifdef MEM_JOIN_FREE
if(unlikely(cfg_get(core, core_cfg, mem_join)!=0)) {
next=prev=0;
/* mark this fragment as used (might fall into the middle of joined frags)
to give us an extra chance of detecting a double free call (if the joined
fragment has not yet been reused) */
f->u.nxt_free=(void*)0x1L; /* bogus value, just to mark it as free */
/* join packets if possible*/
next=FRAG_NEXT(f);
if (((char*)next < (char*)qm->last_frag_end) && (next->u.is_free)){
/* join next packet */
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, next);
#endif
qm_detach_free(qm, next);
size+=next->size+FRAG_OVERHEAD;
qm->real_used-=FRAG_OVERHEAD;
qm->free_hash[GET_HASH(next->size)].no--; /* FIXME slow */
qm->ffrags--;
}
if (f > qm->first_frag){
prev=FRAG_PREV(f);
/* (struct qm_frag*)((char*)f - (struct qm_frag_end*)((char*)f-
sizeof(struct qm_frag_end))->size);*/
if (prev->u.is_free){
/* join prev packet */
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, prev);
#endif
qm_detach_free(qm, prev);
size+=prev->size+FRAG_OVERHEAD;
qm->real_used-=FRAG_OVERHEAD;
qm->free_hash[GET_HASH(prev->size)].no--; /* FIXME slow */
qm->ffrags--;
f=prev;
}
}
f->size=size;
FRAG_END(f)->size=f->size;
} /* if cfg_core->mem_join */
#endif /* MEM_JOIN_FREE*/
#ifdef DBG_QM_MALLOC
f->file=file;
f->func=func;
f->line=line;
#endif
qm_insert_free(qm, f);
#ifdef MALLOC_STATS
if(qm->type==MEM_TYPE_PKG) {
sr_event_exec(SREV_PKG_UPDATE_STATS, 0);
}
#endif
}
#ifdef DBG_QM_MALLOC
void* qm_realloc(void* qmp, void* p, unsigned long size,
const char* file, const char* func, unsigned int line)
#else
void* qm_realloc(void* qmp, void* p, unsigned long size)
#endif
{
struct qm_block* qm;
struct qm_frag* f;
unsigned long diff;
unsigned long orig_size;
struct qm_frag* n;
void* ptr;
qm = (struct qm_block*)qmp;
#ifdef DBG_QM_MALLOC
MDBG("qm_realloc(%p, %p, %lu) called from %s: %s(%d)\n", qm, p, size,
file, func, line);
if ((p)&&(p>(void*)qm->last_frag_end || p<(void*)qm->first_frag)){
LOG(L_CRIT, "BUG: qm_free: bad pointer %p (out of memory block!) - "
"aborting\n", p);
abort();
}
#endif
if (size==0) {
if (p)
#ifdef DBG_QM_MALLOC
qm_free(qm, p, file, func, line);
#else
qm_free(qm, p);
#endif
return 0;
}
if (p==0)
#ifdef DBG_QM_MALLOC
return qm_malloc(qm, size, file, func, line);
#else
return qm_malloc(qm, size);
#endif
f=(struct qm_frag*) ((char*)p-sizeof(struct qm_frag));
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, f);
MDBG("qm_realloc: realloc'ing frag %p alloc'ed from %s: %s(%ld)\n",
f, f->file, f->func, f->line);
if (f->u.is_free){
LOG(L_CRIT, "BUG:qm_realloc: trying to realloc an already freed "
"pointer %p , fragment %p -- aborting\n", p, f);
abort();
}
#endif
/* find first acceptable size */
size=ROUNDUP(size);
if (f->size > size){
orig_size=f->size;
/* shrink */
#ifdef DBG_QM_MALLOC
MDBG("qm_realloc: shrinking from %lu to %lu\n", f->size, size);
if(split_frag(qm, f, size, file, "fragm. from qm_realloc", line)!=0){
MDBG("qm_realloc : shrinked successful\n");
#else
if(split_frag(qm, f, size)!=0){
#endif
/* update used sizes: freed the splited frag */
/* split frag already adds FRAG_OVERHEAD for the newly created
free frag, so here we only need orig_size-f->size for real used
*/
qm->real_used-=(orig_size-f->size);
qm->used-=(orig_size-f->size);
}
}else if (f->size < size){
/* grow */
#ifdef DBG_QM_MALLOC
MDBG("qm_realloc: growing from %lu to %lu\n", f->size, size);
#endif
orig_size=f->size;
diff=size-f->size;
n=FRAG_NEXT(f);
if (((char*)n < (char*)qm->last_frag_end) &&
(n->u.is_free)&&((n->size+FRAG_OVERHEAD)>=diff)){
/* join */
qm_detach_free(qm, n);
qm->free_hash[GET_HASH(n->size)].no--; /*FIXME: slow*/
qm->ffrags--;
f->size+=n->size+FRAG_OVERHEAD;
qm->real_used-=FRAG_OVERHEAD;
FRAG_END(f)->size=f->size;
/* end checks should be ok */
/* split it if necessary */
if (f->size > size ){
#ifdef DBG_QM_MALLOC
split_frag(qm, f, size, file, "fragm. from qm_realloc",
line);
#else
split_frag(qm, f, size);
#endif
}
qm->real_used+=(f->size-orig_size);
qm->used+=(f->size-orig_size);
}else{
/* could not join => realloc */
#ifdef DBG_QM_MALLOC
ptr=qm_malloc(qm, size, file, func, line);
#else
ptr=qm_malloc(qm, size);
#endif
if (ptr){
/* copy, need by libssl */
memcpy(ptr, p, orig_size);
}
#ifdef DBG_QM_MALLOC
qm_free(qm, p, file, func, line);
#else
qm_free(qm, p);
#endif
p=ptr;
}
}else{
/* do nothing */
#ifdef DBG_QM_MALLOC
MDBG("qm_realloc: doing nothing, same size: %lu - %lu\n",
f->size, size);
#endif
}
#ifdef DBG_QM_MALLOC
MDBG("qm_realloc: returning %p\n", p);
#endif
#ifdef MALLOC_STATS
if(qm->type==MEM_TYPE_PKG) {
sr_event_exec(SREV_PKG_UPDATE_STATS, 0);
}
#endif
return p;
}
void qm_check(struct qm_block* qm)
{
struct qm_frag* f;
long fcount = 0;
int memlog;
memlog=cfg_get(core, core_cfg, memlog);
LOG(memlog, "DEBUG: qm_check()\n");
f = qm->first_frag;
while ((char*)f < (char*)qm->last_frag_end) {
fcount++;
/* check struct qm_frag */
#ifdef DBG_QM_MALLOC
if (f->check!=ST_CHECK_PATTERN){
LOG(L_CRIT, "BUG: qm_*: fragm. %p (address %p) "
"beginning overwritten(%lx)!\n",
f, (char*)f + sizeof(struct qm_frag),
f->check);
qm_status(qm);
abort();
};
#endif
if (f + sizeof(struct qm_frag) + f->size + sizeof(struct qm_frag_end) > qm->first_frag + qm->size) {
LOG(L_CRIT, "BUG: qm_*: fragm. %p (address %p) "
"bad size: %lu (frag end: %p > end of block: %p)\n",
f, (char*)f + sizeof(struct qm_frag) + sizeof(struct qm_frag_end), f->size,
f + sizeof(struct qm_frag) + f->size, qm->first_frag + qm->size);
qm_status(qm);
abort();
}
/* check struct qm_frag_end */
if (FRAG_END(f)->size != f->size) {
LOG(L_CRIT, "BUG: qm_*: fragm. %p (address %p) "
"size in qm_frag and qm_frag_end does not match: frag->size=%lu, frag_end->size=%lu)\n",
f, (char*)f + sizeof(struct qm_frag),
f->size, FRAG_END(f)->size);
qm_status(qm);
abort();
}
#ifdef DBG_QM_MALLOC
if ((FRAG_END(f)->check1 != END_CHECK_PATTERN1) ||
(FRAG_END(f)->check2 != END_CHECK_PATTERN2)) {
LOG(L_CRIT, "BUG: qm_*: fragm. %p (address %p)"
" end overwritten(%lx, %lx)!\n",
f, (char*)f + sizeof(struct qm_frag),
FRAG_END(f)->check1, FRAG_END(f)->check2);
qm_status(qm);
abort();
}
#endif
f = FRAG_NEXT(f);
}
LOG(memlog, "DEBUG: qm_check: %lu fragments OK\n", fcount);
}
void qm_status(void* qmp)
{
struct qm_block* qm;
struct qm_frag* f;
int i,j;
int h;
int unused;
int memlog;
int mem_summary;
qm = (struct qm_block*)qmp;
memlog=cfg_get(core, core_cfg, memlog);
mem_summary=cfg_get(core, core_cfg, mem_summary);
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ", "(%p):\n", qm);
if (!qm) return;
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ", "heap size= %lu\n",
qm->size);
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ",
"used= %lu, used+overhead=%lu, free=%lu\n",
qm->used, qm->real_used, qm->size-qm->real_used);
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ",
"max used (+overhead)= %lu\n", qm->max_real_used);
if (mem_summary & 16) return;
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ",
"dumping all alloc'ed. fragments:\n");
for (f=qm->first_frag, i=0;(char*)f<(char*)qm->last_frag_end;f=FRAG_NEXT(f)
,i++){
if (! f->u.is_free){
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ",
" %3d. %c address=%p frag=%p size=%lu used=%d\n",
i,
(f->u.is_free)?'a':'N',
(char*)f+sizeof(struct qm_frag), f, f->size, FRAG_WAS_USED(f));
#ifdef DBG_QM_MALLOC
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ",
" %s from %s: %s(%ld)\n",
(f->u.is_free)?"freed":"alloc'd", f->file, f->func, f->line);
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ",
" start check=%lx, end check= %lx, %lx\n",
f->check, FRAG_END(f)->check1, FRAG_END(f)->check2);
#endif
}
}
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ",
"dumping free list stats :\n");
for(h=0,i=0;h<QM_HASH_SIZE;h++){
unused=0;
for (f=qm->free_hash[h].head.u.nxt_free,j=0;
f!=&(qm->free_hash[h].head); f=f->u.nxt_free, i++, j++){
if (!FRAG_WAS_USED(f)){
unused++;
#ifdef DBG_QM_MALLOC
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ",
"unused fragm.: hash = %3d, fragment %p,"
" address %p size %lu, created from %s: %s(%lu)\n",
h, f, (char*)f+sizeof(struct qm_frag), f->size,
f->file, f->func, f->line);
#endif
}
}
if (j) LOG_(DEFAULT_FACILITY, memlog, "qm_status: ",
"hash= %3d. fragments no.: %5d, unused: %5d\n"
"\t\t bucket size: %9lu - %9ld (first %9lu)\n",
h, j, unused, UN_HASH(h),
((h<=QM_MALLOC_OPTIMIZE/ROUNDTO)?1:2)*UN_HASH(h),
qm->free_hash[h].head.u.nxt_free->size
);
if (j!=qm->free_hash[h].no){
LOG(L_CRIT, "BUG: qm_status: different free frag. count: %d!=%lu"
" for hash %3d\n", j, qm->free_hash[h].no, h);
}
}
LOG_(DEFAULT_FACILITY, memlog, "qm_status: ",
"-----------------------------\n");
}
/* fills a malloc info structure with info about the block
* if a parameter is not supported, it will be filled with 0 */
void qm_info(void* qmp, struct mem_info* info)
{
struct qm_block* qm;
qm = (struct qm_block*)qmp;
memset(info,0, sizeof(*info));
info->total_size=qm->size;
info->min_frag=MIN_FRAG_SIZE;
info->free=qm->size-qm->real_used;
info->used=qm->used;
info->real_used=qm->real_used;
info->max_used=qm->max_real_used;
info->total_frags=qm->ffrags;
}
/* returns how much free memory is available
* it never returns an error (unlike fm_available) */
unsigned long qm_available(void* qmp)
{
struct qm_block* qm;
qm = (struct qm_block*)qmp;
return qm->size-qm->real_used;
}
#ifdef DBG_QM_MALLOC
typedef struct _mem_counter{
const char *file;
const char *func;
unsigned long line;
unsigned long size;
int count;
struct _mem_counter *next;
} mem_counter;
static mem_counter* get_mem_counter(mem_counter **root, struct qm_frag* f)
{
mem_counter *x;
if (!*root) goto make_new;
for(x=*root;x;x=x->next)
if (x->file == f->file && x->func == f->func && x->line == f->line)
return x;
make_new:
x = malloc(sizeof(mem_counter));
x->file = f->file;
x->func = f->func;
x->line = f->line;
x->count = 0;
x->size = 0;
x->next = *root;
*root = x;
return x;
}
void qm_sums(void* qmp)
{
struct qm_block* qm;
struct qm_frag* f;
int i;
mem_counter *root, *x;
int memlog;
qm = (struct qm_block*)qmp;
root=0;
if (!qm) return;
memlog=cfg_get(core, core_cfg, memlog);
LOG_(DEFAULT_FACILITY, memlog, "qm_sums: ",
"summarizing all alloc'ed. fragments:\n");
for (f=qm->first_frag, i=0;(char*)f<(char*)qm->last_frag_end;
f=FRAG_NEXT(f),i++){
if (! f->u.is_free){
x = get_mem_counter(&root,f);
x->count++;
x->size+=f->size;
}
}
x = root;
while(x){
LOG_(DEFAULT_FACILITY, memlog, "qm_sums: ",
" count=%6d size=%10lu bytes from %s: %s(%ld)\n",
x->count,x->size,
x->file, x->func, x->line
);
root = x->next;
free(x);
x = root;
}
LOG_(DEFAULT_FACILITY, memlog, "qm_sums: ",
"-----------------------------\n");
}
#else
void qm_sums(void* qm)
{
return;
}
#endif /* DBG_QM_MALLOC */
/*memory manager core api*/
static char *_qm_mem_name = "q_malloc";
/* PKG - private memory API*/
static char *_qm_pkg_pool = 0;
static struct qm_block *_qm_pkg_block = 0;
/**
* \brief Destroy memory pool
*/
void qm_malloc_destroy_pkg_manager(void)
{
if (_qm_pkg_pool) {
free(_qm_pkg_pool);
_qm_pkg_pool = 0;
}
_qm_pkg_block = 0;
}
/**
* \brief Init memory pool
*/
int qm_malloc_init_pkg_manager(void)
{
sr_pkg_api_t ma;
_qm_pkg_pool = malloc(pkg_mem_size);
if (_qm_pkg_pool)
_qm_pkg_block=qm_malloc_init(_qm_pkg_pool, pkg_mem_size, MEM_TYPE_PKG);
if (_qm_pkg_block==0){
LOG(L_CRIT, "could not initialize qm memory pool\n");
fprintf(stderr, "Too much qm pkg memory demanded: %ld bytes\n",
pkg_mem_size);
return -1;
}
memset(&ma, 0, sizeof(sr_pkg_api_t));
ma.mname = _qm_mem_name;
ma.mem_pool = _qm_pkg_pool;
ma.mem_block = _qm_pkg_block;
ma.xmalloc = qm_malloc;
ma.xfree = qm_free;
ma.xrealloc = qm_realloc;
ma.xstatus = qm_status;
ma.xinfo = qm_info;
ma.xavailable = qm_available;
ma.xsums = qm_sums;
ma.xdestroy = qm_malloc_destroy_pkg_manager;
return pkg_init_api(&ma);
}
/* SHM - shared memory API*/
static void *_qm_shm_pool = 0;
static struct qm_block *_qm_shm_block = 0;
/*SHM wrappers to sync the access to memory block*/
#ifdef DBG_QM_MALLOC
void* qm_shm_malloc(void* qmp, unsigned long size,
const char* file, const char* func, unsigned int line)
{
void *r;
shm_lock();
r = qm_malloc(qmp, size, file, func, line);
shm_unlock();
return r;
}
int split_frag(struct qm_block* qm, struct qm_frag* f, unsigned long new_size)
#endif
{
unsigned long rest;
struct qm_frag* n;
struct qm_frag_end* end;
rest=f->size-new_size;
#ifdef MEM_FRAG_AVOIDANCE
if ((rest> (FRAG_OVERHEAD+QM_MALLOC_OPTIMIZE))||
(rest>=(FRAG_OVERHEAD+new_size))){/* the residue fragm. is big enough*/
#else
if (rest>(FRAG_OVERHEAD+MIN_FRAG_SIZE)){
#endif
f->size=new_size;
/*split the fragment*/
end=FRAG_END(f);
end->size=new_size;
n=(struct qm_frag*)((char*)end+sizeof(struct qm_frag_end));
n->size=rest-FRAG_OVERHEAD;
FRAG_END(n)->size=n->size;
FRAG_CLEAR_USED(n); /* never used */
qm->real_used+=FRAG_OVERHEAD;
#ifdef DBG_QM_MALLOC
end->check1=END_CHECK_PATTERN1;
end->check2=END_CHECK_PATTERN2;
/* frag created by malloc, mark it*/
n->file=file;
n->func=func;
n->line=line;
n->check=ST_CHECK_PATTERN;
#endif
/* reinsert n in free list*/
qm_insert_free(qm, n);
return 0;
}else{
/* we cannot split this fragment any more */
return -1;
}
}
#ifdef DBG_QM_MALLOC
void* qm_malloc(struct qm_block* qm, unsigned long size,
const char* file, const char* func, unsigned int line)
#else
void* qm_malloc(struct qm_block* qm, unsigned long size)
#endif
{
struct qm_frag* f;
int hash;
#ifdef DBG_QM_MALLOC
unsigned int list_cntr;
list_cntr = 0;
MDBG("qm_malloc(%p, %lu) called from %s: %s(%d)\n", qm, size, file, func,
line);
#endif
/*size must be a multiple of 8*/
size=ROUNDUP(size);
if (size>(qm->size-qm->real_used)) return 0;
/*search for a suitable free frag*/
#ifdef DBG_QM_MALLOC
if ((f=qm_find_free(qm, size, &hash, &list_cntr))!=0){
#else
if ((f=qm_find_free(qm, size, &hash))!=0){
#endif
/* we found it!*/
/*detach it from the free list*/
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, f);
#endif
qm_detach_free(qm, f);
/*mark it as "busy"*/
f->u.is_free=0;
qm->free_hash[hash].no--;
/* we ignore split return */
#ifdef DBG_QM_MALLOC
split_frag(qm, f, size, file, "fragm. from qm_malloc", line);
#else
split_frag(qm, f, size);
#endif
qm->real_used+=f->size;
qm->used+=f->size;
if (qm->max_real_used<qm->real_used)
qm->max_real_used=qm->real_used;
#ifdef DBG_QM_MALLOC
f->file=file;
f->func=func;
f->line=line;
f->check=ST_CHECK_PATTERN;
/* FRAG_END(f)->check1=END_CHECK_PATTERN1;
FRAG_END(f)->check2=END_CHECK_PATTERN2;*/
MDBG("qm_malloc(%p, %lu) returns address %p frag. %p (size=%lu) on %d"
" -th hit\n",
qm, size, (char*)f+sizeof(struct qm_frag), f, f->size, list_cntr );
#endif
return (char*)f+sizeof(struct qm_frag);
}
return 0;
}
#ifdef DBG_QM_MALLOC
void qm_free(struct qm_block* qm, void* p, const char* file, const char* func,
unsigned int line)
#else
void qm_free(struct qm_block* qm, void* p)
#endif
{
struct qm_frag* f;
struct qm_frag* prev;
struct qm_frag* next;
unsigned long size;
#ifdef DBG_QM_MALLOC
MDBG("qm_free(%p, %p), called from %s: %s(%d)\n", qm, p, file, func, line);
if (p>(void*)qm->last_frag_end || p<(void*)qm->first_frag){
LOG(L_CRIT, "BUG: qm_free: bad pointer %p (out of memory block!) - "
"aborting\n", p);
abort();
}
#endif
if (p==0) {
LOG(L_WARN, "WARNING:qm_free: free(0) called\n");
return;
}
prev=next=0;
f=(struct qm_frag*) ((char*)p-sizeof(struct qm_frag));
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, f);
if (f->u.is_free){
LOG(L_CRIT, "BUG: qm_free: freeing already freed pointer,"
" first free: %s: %s(%ld) - aborting\n",
f->file, f->func, f->line);
abort();
}
MDBG("qm_free: freeing frag. %p alloc'ed from %s: %s(%ld)\n",
f, f->file, f->func, f->line);
#endif
size=f->size;
qm->used-=size;
qm->real_used-=size;
#ifdef QM_JOIN_FREE
/* join packets if possible*/
next=FRAG_NEXT(f);
if (((char*)next < (char*)qm->last_frag_end) &&( next->u.is_free)){
/* join */
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, next);
#endif
qm_detach_free(qm, next);
size+=next->size+FRAG_OVERHEAD;
qm->real_used-=FRAG_OVERHEAD;
qm->free_hash[GET_HASH(next->size)].no--; /* FIXME slow */
}
if (f > qm->first_frag){
prev=FRAG_PREV(f);
/* (struct qm_frag*)((char*)f - (struct qm_frag_end*)((char*)f-
sizeof(struct qm_frag_end))->size);*/
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, prev);
#endif
if (prev->u.is_free){
/*join*/
qm_detach_free(qm, prev);
size+=prev->size+FRAG_OVERHEAD;
qm->real_used-=FRAG_OVERHEAD;
qm->free_hash[GET_HASH(prev->size)].no--; /* FIXME slow */
f=prev;
}
}
f->size=size;
FRAG_END(f)->size=f->size;
#endif /* QM_JOIN_FREE*/
#ifdef DBG_QM_MALLOC
f->file=file;
f->func=func;
f->line=line;
#endif
qm_insert_free(qm, f);
}
#ifdef DBG_QM_MALLOC
void* qm_realloc(struct qm_block* qm, void* p, unsigned long size,
const char* file, const char* func, unsigned int line)
#else
void* qm_realloc(struct qm_block* qm, void* p, unsigned long size)
#endif
{
struct qm_frag* f;
unsigned long diff;
unsigned long orig_size;
struct qm_frag* n;
void* ptr;
#ifdef DBG_QM_MALLOC
MDBG("qm_realloc(%p, %p, %lu) called from %s: %s(%d)\n", qm, p, size,
file, func, line);
if ((p)&&(p>(void*)qm->last_frag_end || p<(void*)qm->first_frag)){
LOG(L_CRIT, "BUG: qm_free: bad pointer %p (out of memory block!) - "
"aborting\n", p);
abort();
}
#endif
if (size==0) {
if (p)
#ifdef DBG_QM_MALLOC
qm_free(qm, p, file, func, line);
#else
qm_free(qm, p);
#endif
return 0;
}
if (p==0)
#ifdef DBG_QM_MALLOC
return qm_malloc(qm, size, file, func, line);
#else
return qm_malloc(qm, size);
#endif
f=(struct qm_frag*) ((char*)p-sizeof(struct qm_frag));
#ifdef DBG_QM_MALLOC
qm_debug_frag(qm, f);
MDBG("qm_realloc: realloc'ing frag %p alloc'ed from %s: %s(%ld)\n",
f, f->file, f->func, f->line);
if (f->u.is_free){
LOG(L_CRIT, "BUG:qm_realloc: trying to realloc an already freed "
"pointer %p , fragment %p -- aborting\n", p, f);
abort();
}
#endif
/* find first acceptable size */
size=ROUNDUP(size);
if (f->size > size){
orig_size=f->size;
/* shrink */
#ifdef DBG_QM_MALLOC
MDBG("qm_realloc: shrinking from %lu to %lu\n", f->size, size);
if(split_frag(qm, f, size, file, "fragm. from qm_realloc", line)!=0){
MDBG("qm_realloc : shrinked successful\n");
#else
if(split_frag(qm, f, size)!=0){
#endif
/* update used sizes: freed the spitted frag */
qm->real_used-=(orig_size-f->size-FRAG_OVERHEAD);
qm->used-=(orig_size-f->size);
}
}else if (f->size < size){
/* grow */
#ifdef DBG_QM_MALLOC
MDBG("qm_realloc: growing from %lu to %lu\n", f->size, size);
#endif
orig_size=f->size;
diff=size-f->size;
n=FRAG_NEXT(f);
if (((char*)n < (char*)qm->last_frag_end) &&
(n->u.is_free)&&((n->size+FRAG_OVERHEAD)>=diff)){
/* join */
qm_detach_free(qm, n);
qm->free_hash[GET_HASH(n->size)].no--; /*FIXME: slow*/
f->size+=n->size+FRAG_OVERHEAD;
qm->real_used-=FRAG_OVERHEAD;
FRAG_END(f)->size=f->size;
/* end checks should be ok */
/* split it if necessary */
if (f->size > size ){
#ifdef DBG_QM_MALLOC
split_frag(qm, f, size, file, "fragm. from qm_realloc",
line);
#else
split_frag(qm, f, size);
#endif
}
qm->real_used+=(f->size-orig_size);
qm->used+=(f->size-orig_size);
}else{
/* could not join => realloc */
#ifdef DBG_QM_MALLOC
ptr=qm_malloc(qm, size, file, func, line);
#else
ptr=qm_malloc(qm, size);
#endif
if (ptr){
/* copy, need by libssl */
memcpy(ptr, p, orig_size);
#ifdef DBG_QM_MALLOC
qm_free(qm, p, file, func, line);
#else
qm_free(qm, p);
#endif
}
p=ptr;
}
}else{
/* do nothing */
#ifdef DBG_QM_MALLOC
MDBG("qm_realloc: doing nothing, same size: %lu - %lu\n",
f->size, size);
#endif
}
#ifdef DBG_QM_MALLOC
MDBG("qm_realloc: returning %p\n", p);
#endif
return p;
}
void qm_status(struct qm_block* qm)
{
struct qm_frag* f;
int i,j;
int h;
int unused;
LOG(memlog, "qm_status (%p):\n", qm);
if (!qm) return;
LOG(memlog, " heap size= %lu\n", qm->size);
LOG(memlog, " used= %lu, used+overhead=%lu, free=%lu\n",
qm->used, qm->real_used, qm->size-qm->real_used);
LOG(memlog, " max used (+overhead)= %lu\n", qm->max_real_used);
LOG(memlog, "dumping all alloc'ed. fragments:\n");
for (f=qm->first_frag, i=0;(char*)f<(char*)qm->last_frag_end;f=FRAG_NEXT(f)
,i++){
if (! f->u.is_free){
LOG(memlog, " %3d. %c address=%p frag=%p size=%lu used=%d\n",
i,
(f->u.is_free)?'a':'N',
(char*)f+sizeof(struct qm_frag), f, f->size, FRAG_WAS_USED(f));
#ifdef DBG_QM_MALLOC
LOG(memlog, " %s from %s: %s(%ld)\n",
(f->u.is_free)?"freed":"alloc'd", f->file, f->func, f->line);
LOG(memlog, " start check=%lx, end check= %lx, %lx\n",
f->check, FRAG_END(f)->check1, FRAG_END(f)->check2);
#endif
}
}
LOG(memlog, "dumping free list stats :\n");
for(h=0,i=0;h<QM_HASH_SIZE;h++){
unused=0;
for (f=qm->free_hash[h].head.u.nxt_free,j=0;
f!=&(qm->free_hash[h].head); f=f->u.nxt_free, i++, j++){
if (!FRAG_WAS_USED(f)){
unused++;
#ifdef DBG_QM_MALLOC
LOG(memlog, "unused fragm.: hash = %3d, fragment %p,"
" address %p size %lu, created from %s: %s(%lu)\n",
h, f, (char*)f+sizeof(struct qm_frag), f->size,
f->file, f->func, f->line);
#endif
}
}
if (j) LOG(memlog, "hash= %3d. fragments no.: %5d, unused: %5d\n"
"\t\t bucket size: %9lu - %9ld (first %9lu)\n",
h, j, unused, UN_HASH(h),
((h<=QM_MALLOC_OPTIMIZE/ROUNDTO)?1:2)*UN_HASH(h),
qm->free_hash[h].head.u.nxt_free->size
);
if (j!=qm->free_hash[h].no){
LOG(L_CRIT, "BUG: qm_status: different free frag. count: %d!=%lu"
" for hash %3d\n", j, qm->free_hash[h].no, h);
}
}
LOG(memlog, "-----------------------------\n");
}
/* fills a malloc info structure with info about the block
* if a parameter is not supported, it will be filled with 0 */
void qm_info(struct qm_block* qm, struct mem_info* info)
{
int r;
long total_frags;
total_frags=0;
memset(info,0, sizeof(*info));
info->total_size=qm->size;
info->min_frag=MIN_FRAG_SIZE;
info->free=qm->size-qm->real_used;
info->used=qm->used;
info->real_used=qm->real_used;
info->max_used=qm->max_real_used;
for(r=0;r<QM_HASH_SIZE; r++){
total_frags+=qm->free_hash[r].no;
}
info->total_frags=total_frags;
}
/* returns how much free memory is available
* it never returns an error (unlike fm_available) */
unsigned long qm_available(struct qm_block* qm)
{
return qm->size-qm->real_used;
}
#ifdef DBG_QM_MALLOC
typedef struct _mem_counter{
const char *file;
const char *func;
unsigned long line;
unsigned long size;
int count;
struct _mem_counter *next;
} mem_counter;
mem_counter* get_mem_counter(mem_counter **root,struct qm_frag* f)
{
mem_counter *x;
if (!*root) goto make_new;
for(x=*root;x;x=x->next)
if (x->file == f->file && x->func == f->func && x->line == f->line)
return x;
make_new:
x = malloc(sizeof(mem_counter));
x->file = f->file;
x->func = f->func;
x->line = f->line;
x->count = 0;
x->size = 0;
x->next = *root;
*root = x;
return x;
}
#include "../locking.h"
#include "../pt.h"
extern gen_lock_t* process_lock;
extern struct process_table *pt;
extern int process_no;
void qm_sums(struct qm_block* qm)
{
struct qm_frag* f;
int i;
int total_count=0;
long unsigned int total_size=0;
int memlog=L_ERR;
mem_counter *root=0,*x;
//lock_get(process_lock);
if (process_no!=0)
LOG(memlog, "qm_sums (%p): PKG[%s]\n", qm,pt[process_no].desc);
else
LOG(memlog, "qm_sums (%p): PKG[0]/SHM \n",qm);
if (!qm) {
//lock_release(process_lock);
return;
}
LOG(memlog, "summarizing all alloc'ed. fragments:\n");
for (f=qm->first_frag, i=0;(char*)f<(char*)qm->last_frag_end;f=FRAG_NEXT(f),i++){
if (! f->u.is_free){
x = get_mem_counter(&root,f);
x->count++;
x->size+=f->size;
}
}
x = root;
while(x){
LOG(memlog, " count=%6d size=%10lu bytes from %s: %s(%ld)\n",
x->count,x->size,
x->file, x->func, x->line
);
total_count+=x->count;total_size+=x->size;
root = x->next;
free(x);
x = root;
}
LOG(memlog, " count=%6d size=%10lu bytes in total\n",total_count,total_size);
LOG(memlog, "-----------------------------\n");
//lock_release(process_lock);
}