This is mem_man.c in view mode; [Download] [Up]
#if MEM_MAN
/* a simple memory manager. All allocates and frees should go through here */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#define MEM_MAN_MAIN
#include "mem_man.h"
#ifdef MEM_SIGNAL_HANDLER
#include <signal.h>
#endif
/*
this module is stand alone. typically a define will occur in a C file
like this
#define malloc(x) smb_mem_malloc(x,__FILE__,__LINE__)
#define free(x) smb_mem_free(x,__FILE__,__LINE__)
which redirects all calls to malloc and free through this module
Various configuration options can be set in mem_man.h. This file also
includes the defines above - so the complete system can be implemented
with just one include call.
*/
extern FILE *dbf;
/*
ACCESSING the memory manager :
mem_init_memory_manager() :
initialises internal data structures of memory manager
void *malloc(size_t size) :
allocates memory as per usual. also records lots of info
int free(void *ptr) :
frees some memory as per usual. writes errors if necessary.
void *smb_mem_resize(void *ptr,size_t newsize) :
changes the memory assignment size of a pointer. note it may return a
different pointer than the one given. memory can be sized up or down.
int smb_mem_query_size(void *ptr) :
returns the size of the allocated memory.
int smb_mem_query_real_size(void *ptr) :
returns the actual amount of memory allocated to a pointer.
char *smb_mem_query_file(void *ptr) :
returns the name of the file where the pointer was allocated.
int smb_mem_query_line(void *ptr) :
returns the line of the file where the memory was allocated.
void smb_mem_write_status(FILE *outfile) :
writes short summary of memory stats on the stream.
void smb_mem_write_verbose(FILE *outfile) :
writes lots of info on current allocations to stream.
void smb_mem_write_errors(FILE *outfile) :
writes info on error blocks
void smb_mem_write_info(void *ptr,FILE *outfile)
writes info on one pointer to outfile
int smb_mem_test(void *ptr) :
returns true if the pointer is OK - false if it is not.
void smb_mem_set_multiplier(int multiplier) :
sets defaults amount of memory allocated to multiplier times
amount requested.
int smb_mem_total_errors(void) :
returns the total number of error blocks
void smb_mem_check_buffers(void) :
checks all buffers for corruption. It marks them as corrupt if they are.
kill -USR1 <pid> :
this will send a signal to the memory manager to do a mem_write_verbose
it also checks them for corruption. Note that the signal number can be
set in the header file mem_man.h. This can also be turned off.
*/
void smb_mem_write_errors(FILE *outfile);
void smb_mem_write_verbose(FILE *outfile);
void smb_mem_write_status(FILE *outfile);
static void mem_check_buffers(void);
#define FREE_FAILURE 0
#define FREE_SUCCESS 1
#define FN
#define True (0==0)
#define False (!True)
#define BUF_SIZE (MEM_CORRUPT_BUFFER * sizeof(char) * 2)
#define BUF_OFFSET (BUF_SIZE/2)
typedef struct
{
void *pointer;
size_t present_size;
size_t allocated_size;
unsigned char status;
short error_number;
char file[MEM_FILE_STR_LENGTH];
unsigned short line;
} memory_struct;
/* the order of this enum is important. everything greater than
S_ALLOCATED is considered an error */
enum status_types {S_UNALLOCATED,S_ALLOCATED,
S_ERROR_UNALLOCATED,S_ERROR_FREEING,
S_CORRUPT_FRONT,S_CORRUPT_BACK,S_CORRUPT_FRONT_BACK};
/* here is the data memory */
static memory_struct *memory_blocks=NULL; /* these hold the allocation data */
static int mem_blocks_allocated=0; /* how many mem blocks are allocated */
static int mem_multiplier; /* this is the current multiplier mor over allocation */
static int mem_manager_initialised=False; /* has it been initialised ? */
static int last_block_allocated=0; /* a speed up method - this will contain the
index of the last block allocated or freed
to cut down searching time for a new block */
typedef struct
{
int status;
char *label;
} stat_str_type;
static stat_str_type stat_str_struct[] =
{
{S_UNALLOCATED,"S_UNALLOCATED"},
{S_ALLOCATED,"S_ALLOCATED"},
{S_ERROR_UNALLOCATED,"S_ERROR_UNALLOCATED"},
{S_ERROR_FREEING,"S_ERROR_FREEING"},
{S_CORRUPT_FRONT,"S_CORRUPT_FRONT"},
{S_CORRUPT_BACK,"S_CORRUPT_BACK"},
{S_CORRUPT_FRONT_BACK,"S_CORRUPT_FRONT_BACK"},
{-1,NULL}
};
#define INIT_MANAGER() if (!mem_manager_initialised) mem_init_memory_manager()
/*******************************************************************
returns a pointer to a static string for each status
********************************************************************/
static char *status_to_str(int status)
{
int i=0;
while (stat_str_struct[i].label != NULL)
{
if (stat_str_struct[i].status == status)
return(stat_str_struct[i].label);
i++;
}
return(NULL);
}
#ifdef MEM_SIGNAL_HANDLER
/*******************************************************************
this handles signals - causes a mem_write_verbose on stderr
********************************************************************/
static void mem_signal_handler()
{
mem_check_buffers();
smb_mem_write_verbose(dbf);
signal(MEM_SIGNAL_VECTOR,mem_signal_handler);
}
#endif
#ifdef MEM_SIGNAL_HANDLER
/*******************************************************************
this handles error signals - causes a mem_write_verbose on stderr
********************************************************************/
static void error_signal_handler()
{
fprintf(dbf,"Received error signal!\n");
mem_check_buffers();
smb_mem_write_status(dbf);
smb_mem_write_errors(dbf);
abort();
}
#endif
/*******************************************************************
initialise memory manager data structures
********************************************************************/
static void mem_init_memory_manager(void)
{
int i;
/* allocate the memory_blocks array */
mem_blocks_allocated = MEM_MAX_MEM_OBJECTS;
while (mem_blocks_allocated > 0)
{
memory_blocks = (memory_struct *)
calloc(mem_blocks_allocated,sizeof(memory_struct));
if (memory_blocks != NULL) break;
mem_blocks_allocated /= 2;
}
if (memory_blocks == NULL)
{
fprintf(dbf,"Panic ! can't allocate mem manager blocks!\n");
abort();
}
/* just loop setting status flag to unallocated */
for (i=0;i<mem_blocks_allocated;i++)
memory_blocks[i].status = S_UNALLOCATED;
/* also set default mem multiplier */
mem_multiplier = MEM_DEFAULT_MEM_MULTIPLIER;
mem_manager_initialised=True;
#ifdef MEM_SIGNAL_HANDLER
signal(MEM_SIGNAL_VECTOR,mem_signal_handler);
signal(SIGSEGV,error_signal_handler);
signal(SIGBUS,error_signal_handler);
#endif
}
/*******************************************************************
finds first available slot in memory blocks
********************************************************************/
static int mem_first_avail_slot(void)
{
int i;
for (i=last_block_allocated;i<mem_blocks_allocated;i++)
if (memory_blocks[i].status == S_UNALLOCATED)
return(last_block_allocated=i);
for (i=0;i<last_block_allocated;i++)
if (memory_blocks[i].status == S_UNALLOCATED)
return(last_block_allocated=i);
return(-1);
}
/*******************************************************************
find which Index a pointer refers to
********************************************************************/
static int mem_find_Index(void *ptr)
{
int i;
int start = last_block_allocated+mem_blocks_allocated/50;
if (start > mem_blocks_allocated-1) start = mem_blocks_allocated-1;
for (i=start;i>=0;i--)
if ((memory_blocks[i].status == S_ALLOCATED) &&
(memory_blocks[i].pointer == ptr))
return(i);
for (i=(start+1);i<mem_blocks_allocated;i++)
if ((memory_blocks[i].status == S_ALLOCATED) &&
(memory_blocks[i].pointer == ptr))
return(i);
/* it's not there! */
return(-1);
}
/*******************************************************************
fill the buffer areas of a mem block
********************************************************************/
static void mem_fill_bytes(void *p,int size,int Index)
{
memset(p,Index%256,size);
}
/*******************************************************************
fill the buffer areas of a mem block
********************************************************************/
static void mem_fill_buffer(int Index)
{
char *iptr,*tailptr;
int i;
int seed;
/* fill the front and back ends */
seed = MEM_CORRUPT_SEED;
iptr = (char *)((char *)memory_blocks[Index].pointer - BUF_OFFSET);
tailptr = (char *)((char *)memory_blocks[Index].pointer +
memory_blocks[Index].present_size);
for (i=0;i<MEM_CORRUPT_BUFFER;i++)
{
iptr[i] = seed;
tailptr[i] = seed;
seed += MEM_SEED_INCREMENT;
}
}
/*******************************************************************
check if a mem block is corrupt
********************************************************************/
static int mem_buffer_ok(int Index)
{
char *iptr;
int i;
int corrupt_front = False;
int corrupt_back = False;
/* check the front end */
iptr = (char *)((char *)memory_blocks[Index].pointer - BUF_OFFSET);
for (i=0;i<MEM_CORRUPT_BUFFER;i++)
if (iptr[i] != (char)(MEM_CORRUPT_SEED + i*MEM_SEED_INCREMENT))
corrupt_front = True;
/* now check the tail end */
iptr = (char *)((char *)memory_blocks[Index].pointer +
memory_blocks[Index].present_size);
for (i=0;i<MEM_CORRUPT_BUFFER;i++)
if (iptr[i] != (char)(MEM_CORRUPT_SEED + i*MEM_SEED_INCREMENT))
corrupt_back = True;
if (corrupt_front && !corrupt_back)
memory_blocks[Index].status = S_CORRUPT_FRONT;
if (corrupt_back && !corrupt_front)
memory_blocks[Index].status = S_CORRUPT_BACK;
if (corrupt_front && corrupt_back)
memory_blocks[Index].status = S_CORRUPT_FRONT_BACK;
if (!corrupt_front && !corrupt_back)
return(True);
return(False);
}
/*******************************************************************
check all buffers for corruption
********************************************************************/
static void mem_check_buffers(void)
{
int i;
for (i=0;i<mem_blocks_allocated;i++)
if (memory_blocks[i].status == S_ALLOCATED)
mem_buffer_ok(i);
}
/*******************************************************************
record stats and alloc memory
********************************************************************/
void *smb_mem_malloc(size_t size,char *file,int line)
{
int Index;
INIT_MANAGER();
/* find an open spot */
Index = mem_first_avail_slot();
if (Index<0) return(NULL);
/* record some info */
memory_blocks[Index].present_size = size;
memory_blocks[Index].allocated_size = size*mem_multiplier;
memory_blocks[Index].line = line;
strncpy(memory_blocks[Index].file,file,MEM_FILE_STR_LENGTH);
memory_blocks[Index].file[MEM_FILE_STR_LENGTH-1] = 0;
memory_blocks[Index].error_number = 0;
/* now try and actually get the memory */
memory_blocks[Index].pointer = malloc(size*mem_multiplier + BUF_SIZE);
/* if that failed then try and get exactly what was actually requested */
if (memory_blocks[Index].pointer == NULL)
{
memory_blocks[Index].allocated_size = size;
memory_blocks[Index].pointer = malloc(size + BUF_SIZE);
}
/* if it failed then return NULL */
if (memory_blocks[Index].pointer == NULL) return(NULL);
/* it succeeded - set status flag and return */
memory_blocks[Index].status = S_ALLOCATED;
/* add an offset */
memory_blocks[Index].pointer =
(void *)((char *)memory_blocks[Index].pointer + BUF_OFFSET);
/* fill the buffer appropriately */
mem_fill_buffer(Index);
/* and set the fill byte */
mem_fill_bytes(memory_blocks[Index].pointer,memory_blocks[Index].present_size,Index);
/* return the allocated memory */
return(memory_blocks[Index].pointer);
}
/*******************************************************************
dup a string
********************************************************************/
char *smb_mem_strdup(char *s, char *file, int line)
{
char *ret = (char *)smb_mem_malloc(strlen(s)+1, file, line);
strcpy(ret, s);
return ret;
}
/*******************************************************************
free some memory
********************************************************************/
int smb_mem_free(void *ptr,char *file,int line)
{
int Index;
int free_ret;
static int count;
INIT_MANAGER();
if (count % 100 == 0) {
smb_mem_write_errors(dbf);
}
count++;
Index = mem_find_Index(ptr);
if (Index<0) /* we are freeing a pointer that hasn't been allocated ! */
{
/* set up an error block */
Index = mem_first_avail_slot();
if (Index < 0) /* I can't even allocate an Error! */
{
fprintf(dbf,"Panic in memory manager - can't allocate error block!\n");
fprintf(dbf,"freeing un allocated pointer at %s(%d)\n",file,line);
abort();
}
/* fill in error block */
memory_blocks[Index].present_size = 0;
memory_blocks[Index].allocated_size = 0;
memory_blocks[Index].line = line;
strncpy(memory_blocks[Index].file,file,MEM_FILE_STR_LENGTH);
memory_blocks[Index].file[MEM_FILE_STR_LENGTH-1] = 0;
memory_blocks[Index].status = S_ERROR_UNALLOCATED;
memory_blocks[Index].pointer = ptr;
return(FREE_FAILURE);
}
/* it is a valid pointer - check for corruption */
if (!mem_buffer_ok(Index))
/* it's bad ! return an error */
return(FREE_FAILURE);
/* the pointer is OK - try to free it */
#ifdef MEM_FREE_RETURNS_INT
free_ret = free((char *)ptr - BUF_OFFSET);
#else
free((char *)ptr - BUF_OFFSET);
free_ret = FREE_SUCCESS;
#endif
/* if this failed then make an error block again */
if (free_ret == FREE_FAILURE)
{
memory_blocks[Index].present_size = 0;
memory_blocks[Index].allocated_size = 0;
memory_blocks[Index].line = line;
strncpy(memory_blocks[Index].file,file,MEM_FILE_STR_LENGTH);
memory_blocks[Index].file[MEM_FILE_STR_LENGTH-1] = 0;
memory_blocks[Index].status = S_ERROR_FREEING;
memory_blocks[Index].pointer = ptr;
memory_blocks[Index].error_number = errno;
return(FREE_FAILURE);
}
/* all is OK - set status and return */
memory_blocks[Index].status = S_UNALLOCATED;
/* this is a speedup - if it is freed then it can be allocated again ! */
last_block_allocated = Index;
return(FREE_SUCCESS);
}
/*******************************************************************
writes info on just one Index
it must not be un allocated to do this
********************************************************************/
static void mem_write_Index_info(int Index,FILE *outfile)
{
if (memory_blocks[Index].status != S_UNALLOCATED)
fprintf(outfile,"block %d file %s(%d) : size %d, alloc size %d, status %s\n",
Index,memory_blocks[Index].file,memory_blocks[Index].line,
memory_blocks[Index].present_size,
memory_blocks[Index].allocated_size,
status_to_str(memory_blocks[Index].status));
}
/*******************************************************************
writes info on one pointer
********************************************************************/
void smb_mem_write_info(void *ptr,FILE *outfile)
{
int Index;
INIT_MANAGER();
Index = mem_find_Index(ptr);
if (Index<0) return;
mem_write_Index_info(Index,outfile);
}
/*******************************************************************
return the size of the mem block
********************************************************************/
size_t smb_mem_query_size(void *ptr)
{
int Index;
INIT_MANAGER();
Index = mem_find_Index(ptr);
if (Index<0) return(0);
return(memory_blocks[Index].present_size);
}
/*******************************************************************
return the allocated size of the mem block
********************************************************************/
size_t smb_mem_query_real_size(void *ptr)
{
int Index;
INIT_MANAGER();
Index = mem_find_Index(ptr);
if (Index<0) return(0);
return(memory_blocks[Index].allocated_size);
}
/*******************************************************************
return the file of caller of the mem block
********************************************************************/
char *smb_mem_query_file(void *ptr)
{
int Index;
INIT_MANAGER();
Index = mem_find_Index(ptr);
if (Index<0) return(NULL);
return(memory_blocks[Index].file);
}
/*******************************************************************
return the line in the file of caller of the mem block
********************************************************************/
int smb_mem_query_line(void *ptr)
{
int Index;
INIT_MANAGER();
Index = mem_find_Index(ptr);
if (Index<0) return(0);
return(memory_blocks[Index].line);
}
/*******************************************************************
return True if the pointer is OK
********************************************************************/
int smb_mem_test(void *ptr)
{
int Index;
INIT_MANAGER();
Index = mem_find_Index(ptr);
if (Index<0) return(False);
return(mem_buffer_ok(Index));
}
/*******************************************************************
write brief info on mem status
********************************************************************/
void smb_mem_write_status(FILE *outfile)
{
int num_allocated=0;
int total_size=0;
int total_alloc_size=0;
int num_errors=0;
int i;
INIT_MANAGER();
mem_check_buffers();
for (i=0;i<mem_blocks_allocated;i++)
switch (memory_blocks[i].status)
{
case S_UNALLOCATED :
break;
case S_ALLOCATED :
num_allocated++;
total_size += memory_blocks[i].present_size;
total_alloc_size += memory_blocks[i].allocated_size;
break;
case S_ERROR_UNALLOCATED :
case S_ERROR_FREEING :
case S_CORRUPT_BACK :
case S_CORRUPT_FRONT :
num_errors++;
break;
}
fprintf(outfile,
"Mem Manager : %d blocks, allocation %dK, real allocation %dK, %d errors\n",
num_allocated,(int)(total_size/1024),(int)(total_alloc_size/1024),
num_errors);
fflush(outfile);
}
/*******************************************************************
write verbose info on allocated blocks
********************************************************************/
void smb_mem_write_verbose(FILE *outfile)
{
int Index;
/* first write a summary */
INIT_MANAGER();
smb_mem_write_status(outfile);
/* just loop writing info on relevant indices */
for (Index=0;Index<mem_blocks_allocated;Index++)
if (memory_blocks[Index].status != S_UNALLOCATED)
mem_write_Index_info(Index,outfile);
}
/*******************************************************************
write verbose info on error blocks
********************************************************************/
void smb_mem_write_errors(FILE *outfile)
{
int Index;
INIT_MANAGER();
mem_check_buffers();
/* just loop writing info on relevant indices */
for (Index=0;Index<mem_blocks_allocated;Index++)
if (((int)memory_blocks[Index].status) > ((int)S_ALLOCATED))
mem_write_Index_info(Index,outfile);
}
/*******************************************************************
sets the memory multiplier
********************************************************************/
void smb_mem_set_multiplier(int multiplier)
{
/* check it is valid */
if (multiplier < 1) return;
mem_multiplier = multiplier;
}
/*******************************************************************
increases or decreases the memory assigned to a pointer
********************************************************************/
void *smb_mem_resize(void *ptr,size_t newsize)
{
int Index;
size_t allocsize;
void *temp_ptr;
INIT_MANAGER();
Index = mem_find_Index(ptr);
/* if invalid return NULL */
if (Index<0)
{
#ifdef BUG
int Error();
Error("Invalid mem_resize to size %d\n",newsize);
#endif
return(NULL);
}
/* now - will it fit in the current allocation ? */
if (newsize <= memory_blocks[Index].allocated_size)
{
memory_blocks[Index].present_size = newsize;
mem_fill_buffer(Index);
return(ptr);
}
/* can it be allocated ? */
allocsize = newsize*mem_multiplier;
temp_ptr = malloc(newsize*mem_multiplier + BUF_SIZE);
/* no? try with just the size asked for */
if (temp_ptr == NULL)
{
allocsize=newsize;
temp_ptr = malloc(newsize + BUF_SIZE);
}
/* if it's still NULL give up */
if (temp_ptr == NULL)
return(NULL);
/* copy the old data to the new memory area */
memcpy(temp_ptr,(char *)memory_blocks[Index].pointer - BUF_OFFSET,
memory_blocks[Index].allocated_size + BUF_SIZE);
/* fill the extra space */
mem_fill_bytes((char *)temp_ptr + BUF_OFFSET + memory_blocks[Index].present_size,newsize - memory_blocks[Index].present_size,Index);
/* free the old mem and set vars */
free((char *)ptr - BUF_OFFSET);
memory_blocks[Index].pointer = (void *)((char *)temp_ptr + BUF_OFFSET);
memory_blocks[Index].present_size = newsize;
memory_blocks[Index].allocated_size = allocsize;
/* fill the buffer appropriately */
mem_fill_buffer(Index);
/* now return the new pointer */
return((char *)temp_ptr + BUF_OFFSET);
}
#else
void dummy_mem_man(void) {}
#endif
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.