diff options
| -rw-r--r-- | source3/include/includes.h | 4 | ||||
| -rw-r--r-- | source3/lib/util.c | 7 | ||||
| -rw-r--r-- | source3/mem_man/mem_man.c | 742 | ||||
| -rw-r--r-- | source3/mem_man/mem_man.h | 92 | ||||
| -rw-r--r-- | source3/nmbd/nmbd.c | 2 | ||||
| -rw-r--r-- | source3/rpcclient/rpcclient.c | 8 | ||||
| -rw-r--r-- | source3/smbd/server.c | 2 |
7 files changed, 0 insertions, 857 deletions
diff --git a/source3/include/includes.h b/source3/include/includes.h index 3fcec98f32..3e9010bf54 100644 --- a/source3/include/includes.h +++ b/source3/include/includes.h @@ -128,13 +128,9 @@ #include <memory.h> #endif -#ifdef MEM_MAN -#include "../mem_man/mem_man.h" -#else #ifdef HAVE_MALLOC_H #include <malloc.h> #endif -#endif #ifdef HAVE_FCNTL_H #include <fcntl.h> diff --git a/source3/lib/util.c b/source3/lib/util.c index d3a63691df..0ad14ad3ae 100644 --- a/source3/lib/util.c +++ b/source3/lib/util.c @@ -1716,13 +1716,6 @@ void *Realloc(void *p,size_t size) else ret = (void *)realloc(p,size); -#ifdef MEM_MAN - { - extern FILE *dbf; - smb_mem_write_info(ret, dbf); - } -#endif - if (!ret) DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size)); diff --git a/source3/mem_man/mem_man.c b/source3/mem_man/mem_man.c deleted file mode 100644 index 758fac4386..0000000000 --- a/source3/mem_man/mem_man.c +++ /dev/null @@ -1,742 +0,0 @@ -#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 diff --git a/source3/mem_man/mem_man.h b/source3/mem_man/mem_man.h deleted file mode 100644 index 60e31e6d44..0000000000 --- a/source3/mem_man/mem_man.h +++ /dev/null @@ -1,92 +0,0 @@ -#if (defined(NOMEMMAN) && !defined(MEM_MAN_MAIN)) -#include <malloc.h> -#else - -/* user settable parameters */ - -#define MEM_MANAGER - -/* -this is the maximum number of blocks that can be allocated at one -time. Set this to more than the max number of mallocs you want possible -*/ -#define MEM_MAX_MEM_OBJECTS 20000 - -/* -maximum length of a file name. This is for the source files only. This -would normally be around 30 - increase it only if necessary -*/ -#define MEM_FILE_STR_LENGTH 30 - -/* -default mem multiplier. All memory requests will be multiplied by -this number, thus allowing fast resizing. High values chew lots of -memory but allow for easy resizing -*/ -#define MEM_DEFAULT_MEM_MULTIPLIER 1 - -/* -the length of the corruption buffers before and after each memory block. -Using these can reduce memory overrun errors and catch bad code. The -amount actually allocated is this times 2 times sizeof(char) -*/ -#define MEM_CORRUPT_BUFFER 16 - -/* -the 'seed' to use for the corruption buffer. zero is a very bad choice -*/ -#define MEM_CORRUPT_SEED 0x10 - - -/* -seed increment. This is another precaution. This will be added to the -'seed' for each adjacent element of the corruption buffer -*/ -#define MEM_SEED_INCREMENT 0x1 - - -/* -memory fill. This will be copied over all allocated memory - to aid in -debugging memory dumps. It is one byte long -*/ -#define MEM_FILL_BYTE 42 - - -/* -this determines whether free() on your system returns an integer or -nothing. If unsure then leave this un defined. -*/ -/* #define MEM_FREE_RETURNS_INT */ - - -/* - This determines whether a signal handler will be instelled to do - a mem_write_verbose on request -*/ -#define MEM_SIGNAL_HANDLER - - -/* -This sets which vector to use if MEM_SIGNAL_HANDLER is defined -*/ -#define MEM_SIGNAL_VECTOR SIGUSR1 - -#ifndef MEM_MAN_MAIN -#ifdef malloc -# undef malloc -#endif -#define malloc(x) smb_mem_malloc(x,__FILE__,__LINE__) -#define free(x) smb_mem_free(x,__FILE__,__LINE__) -#define realloc(ptr,newsize) smb_mem_resize(ptr,newsize) -#ifdef calloc -# undef calloc -#endif -#define calloc(nitems,size) malloc(((_mem_size)nitems)*((_mem_size)size)) - -#ifdef strdup -# undef strdup -#endif -#define strdup(s) smb_mem_strdup(s, __FILE__, __LINE__) -#endif - -#endif diff --git a/source3/nmbd/nmbd.c b/source3/nmbd/nmbd.c index 3ba8acc5e0..751aede394 100644 --- a/source3/nmbd/nmbd.c +++ b/source3/nmbd/nmbd.c @@ -674,7 +674,6 @@ static void usage(char *pname) /* If we are using the malloc debug code we can't use SIGUSR1 and SIGUSR2 to do debug level changes. */ -#ifndef MEM_MAN #if defined(SIGUSR1) CatchSignal( SIGUSR1, SIGNAL_CAST sig_usr1 ); #endif /* SIGUSR1 */ @@ -682,7 +681,6 @@ static void usage(char *pname) #if defined(SIGUSR2) CatchSignal( SIGUSR2, SIGNAL_CAST sig_usr2 ); #endif /* SIGUSR2 */ -#endif /* MEM_MAN */ while( EOF != (opt = getopt( argc, argv, "Vaos:T:I:C:bAi:B:N:Rn:l:d:Dp:hSH:G:f:" )) ) diff --git a/source3/rpcclient/rpcclient.c b/source3/rpcclient/rpcclient.c index 0750d8dbb8..2931356334 100644 --- a/source3/rpcclient/rpcclient.c +++ b/source3/rpcclient/rpcclient.c @@ -148,14 +148,6 @@ do a (presumably graceful) quit... static void cmd_quit(struct client_info *info) { rpcclient_stop(); -#ifdef MEM_MAN - { - extern FILE* dbf; - smb_mem_write_status(dbf); - smb_mem_write_errors(dbf); - smb_mem_write_verbose(dbf); - } -#endif exit(0); } diff --git a/source3/smbd/server.c b/source3/smbd/server.c index 1c6d6536ad..0d45f11693 100644 --- a/source3/smbd/server.c +++ b/source3/smbd/server.c @@ -693,7 +693,6 @@ static void usage(char *pname) /* If we are using the malloc debug code we can't use SIGUSR1 and SIGUSR2 to do debug level changes. */ -#ifndef MEM_MAN #if defined(SIGUSR1) CatchSignal( SIGUSR1, SIGNAL_CAST sig_usr1 ); #endif /* SIGUSR1 */ @@ -701,7 +700,6 @@ static void usage(char *pname) #if defined(SIGUSR2) CatchSignal( SIGUSR2, SIGNAL_CAST sig_usr2 ); #endif /* SIGUSR2 */ -#endif /* MEM_MAN */ DEBUG(3,( "loaded services\n")); |