/* * WARNING: this file was produced from settings.dist * by the configure program. The configure script, when * run again, will overwrite changed made here. */ /* * Manual configuration flags * * Copyright 2000 by Gray Watson * * This file is part of the dmalloc package. * * Permission to use, copy, modify, and distribute this software for * any purpose and without fee is hereby granted, provided that the * above copyright notice and this permission notice appear in all * copies, and that the name of Gray Watson not be used in advertising * or publicity pertaining to distribution of the document or software * without specific, written prior permission. * * Gray Watson makes no representations about the suitability of the * software described herein for any purpose. It is provided "as is" * without express or implied warranty. * * The author may be contacted via http://dmalloc.com/ * * $Id: settings.dist,v 1.71 2007/03/13 01:11:25 gray Exp $ */ /* * PROGRAMMING NOTE: this file cannot be included before conf.h, so * you might as well only include conf.h and never this file. */ #ifndef __SETTINGS_H__ #define __SETTINGS_H__ /* * Should we allow zero length allocations? This will generate the * smallest possible allocation. * * FYI: if fence post checking is requested, the top and bottom of the * fence post information will be touching. */ #define ALLOW_ALLOC_ZERO_SIZE 1 /* * Should we allow realloc of a NULL pointer? If set to one, this * will call malloc when 0L is realloc-ed. This is useful when you * are extending an array in a loop and do not want to allocate it * specially the first time. */ #define ALLOW_REALLOC_NULL 1 /* * Should we allow realloc to a 0 size to cause the pointer to be * freed? If set to one, this will call free when a pointer is * realloc-ed to a size of 0. Thanks to Stefan Froehlich * for patiently pointing that the realloc in just about every Unix * has this functionality. */ #define ALLOW_REALLOC_SIZE_ZERO 1 /* * I have swayed to public pressure and allowing free(0L) is now the * default. Sigh. :-) * * Should we allow the free of a NULL pointer and if it happens, * should a message be generated to that effect. Most (if not all) * POSIX C libraries allow you to free() or delete() a NULL pointer * and a number of programming reference manuals mention that freeing * of NULL is "allowed". However, I believe that it is bad form, * promotes lazy pointer handling, and can often hide program bugs. I * encourage you to do something like the following in your programs: * if (pnt != NULL) { free(pnt); } * * Setting ALLOW_FREE_NULL to 0 will cause an exception whenever a * free of NULL is encountered allowing the user to determine where * s/he is freeing a possibly random pointer. I recommend at least * logging a message with the ALLOW_FREE_NULL_MESSAGE set to 1. * * Even with ALLOW_FREE_NULL set to 1, you can enable the * 'error-free-null' token at runtime for a specific program to * generate an exception when it sees a free(0L). */ #define ALLOW_FREE_NULL 1 #define ALLOW_FREE_NULL_MESSAGE 1 /* * Should we use the ra-address macros in return.h. These are system * specific macros designed to return the return-address for logging * callers (i.e. possible offenders) of malloc routines. * * Please mail me if you have any questions with this functionality. */ #define USE_RETURN_MACROS 1 /* * Write this character into memory when it is allocated and not * calloc-ed if the alloc-blank token is enabled. It will also write * this into realloc'd memory which you extend or reduce. You can * verify that these sections have not been overwritten with the * check-blank token. * * \332 == 0xda, 0332, decimal 218 (i.e. dmalloc-alloc) */ #define ALLOC_BLANK_CHAR '\332' /* * Write this character into memory when it is freed if the free-blank * token is enabled. You can verify that these sections have not been * overwritten with the check-blank token. * * \337 == 0xdf, 0337, decimal 223 (i.e. dmalloc-free) */ #define FREE_BLANK_CHAR '\337' /* * The following information sets limits on the size of the source * file name and line numbers returned by the __FILE__ and __LINE__ * compiler macros. You may need to tune then to fit your environment * although I would argue that if you have filenames longer than 40 * characters or files longer than 10,000 lines, you are doing * something wrong. * * MIN_FILE_LENGTH 3 => file "[a-zA-Z].c" * * Set MAX_FILE_LENGTH or MAX_LINE_NUMBER to be 0 to disable checks. * * NOTE: if the max is changed then the dmalloc.texi file reference to * it will need to be changed too. */ #define MIN_FILE_LENGTH 3 #define MAX_FILE_LENGTH 100 #define MAX_LINE_NUMBER 30000 /* * The largest allowable allocation size. This is only for * verification purposes to control allocations of bizarre sizes. Any * allocation larger than this will generate a ERROR_TOO_BIG error. * * Set to 0 to disable the test altogether. */ #define LARGEST_ALLOCATION 268435456UL /* 256 mb */ /* * Automatically call dmalloc_shutdown if on_exit or atexit is * available. See conf.h for whether configure found on_exit or * atexit calls. If neither is available, your program will have to * call dmalloc_shutdown yourself before it exits. You can also take * a look at atexit.c in the contrib directory which may provide this * useful functionality for your system. * * NOTE: If you are having problems with the library going recursive * (see LOCK_THREADS below if you are using pthreads), you might want * to try setting this to 0. Because the library makes a call to * on_exit or atexit to register itself, it may cause memory * transactions by the system causing the dreaded recursive message. * You may then be forced to register dmalloc_shutdown yourself via * on_exit or atexit in main() or call dmalloc_shutdown directly * before you exit(). */ #define AUTO_SHUTDOWN 1 /* * The ABORT_OKAY is auto-configured but may have to be adjusted by * forcing the USE_ABORT to be 1 or 0. On some OS's, abort calls * fclose() which may want to free memory making the library go * recursive when it is aborting. See ABORT_OKAY in the conf.h file * for more information. * * If you need to override it or if ABORT_OKAY is 0, set KILL_PROCESS * to the proper way to stop the program. Killing the current process * (id 0) with SIGABRT works on a number of Unix systems. You may * have to define some include file to get the value for the signal * that is used. * * Alternatives might be: * * #define KILL_PROCESS { int *_int_p = 0L; *_int_p = 1; } */ #if ABORT_OKAY #define USE_ABORT 1 #else #define USE_ABORT 0 #endif #if SIGNAL_OKAY #define KILL_INCLUDE #define KILL_PROCESS (void)kill(0, SIGABRT) #endif /* * Define the signals that are to be caught by the catch-signals * token. When caught, these signals will cause an automatic shutdown * of the library so that the not-freed memory and other statistics will * be displayed. Thanks Marty. */ #if SIGNAL_OKAY #define SIGNAL1 SIGHUP #define SIGNAL2 SIGINT #define SIGNAL3 SIGTERM #undef SIGNAL4 #undef SIGNAL5 #undef SIGNAL6 #endif /* * Number of bytes to write at the top of allocations (if fence-post * checking is enabled). A larger number means more memory space used * up but better protection against fence overruns. See the manual * for more information. */ #define FENCE_TOP_SIZE 4 /* * Number of bytes to write at the bottom of allocations. See the * FENCE_TOP_SIZE setting above or the manual for more information. * * WARNING: this should changed with caution and probably should only be * increased. If you need to change it, use (ALLOCATION_ALIGNMENT * * X) or some such. For more information see ALLOCATION_ALIGNMENT in * conf.h. */ #define FENCE_BOTTOM_SIZE ALLOCATION_ALIGNMENT /* * Amount of space that we are to display whenever we need to dump a * pointer's contents to a log file or stream. This should be more * than FENCE_BOTTOM_SIZE and FENCE_TOP_SIZE. */ #define DUMP_SPACE 20 /* * At the front of each log message, print the output from the time() * call as a number. This requires that the time function be defined. */ #define LOG_TIME_NUMBER 1 #define TIME_INCLUDE /* * Write the iteration count at the start of every log entry. This is * handy when you are using the DMALLOC_START variable and want to * begin the tough debugging at a certain point. This is also returned * by the dmalloc_mark() function. */ #define LOG_ITERATION 1 /* * Write the pid number at the start of every log entry if the * getpid() function is available. This is handy when you are using * dmalloc with a program which forks. See LOG_REOPEN below. */ #define LOG_PID 0 /* * If the getpid() function is available, notice when the pid of the * process changes and reopen the logfile. This is handy when you are * using dmalloc with a program which forks and you want the separate * forked programs to have separate logs. * * NOTE: This only works if the %p string is in the logfile name * otherwise the log might reopen and clobber the existing log. */ #define LOG_REOPEN 1 /* * Store the number of times a pointer is "seen" being allocated or * freed -- it shows up as a s# (for seen) in the logfile. This is * useful for tracking of not-freed memory. See the documents for more * information. * * NOTE: This creates a certain amount of memory overhead. */ #define LOG_PNT_SEEN_COUNT 1 /* * Store the iteration count when a pointer is allocated -- it * shows up as a i# (for iteration) in the logfile. This is to give * you some idea when during program execution, a pointer was * allocated but not freed. * * NOTE: This creates a certain amount of memory overhead. */ #define LOG_PNT_ITERATION 0 /* * At the front of each log message, print the output from the ctime() * function (not including the \n). The TIME_NUMBER_TYPE is the type * that will store the output of time() and whose address we will pass * into ctime. This requires that the ctime and time functions both * be defined. */ #if LOG_TIME_NUMBER == 0 #define LOG_CTIME_STRING 1 #define TIME_TYPE unsigned int #endif /* * Store the time (in seconds) or timeval (in seconds and * microseconds) when a pointer is allocated -- it shows up as a w# * (for when) in the logfile. This is to give you some idea when a * pointer was allocated but not freed. The library will log the * starting and the ending time if either of these flags is set. * TIMEVAL_INCLUDE is the include file to define struct timeval and * GET_TIMEVAL does the actual reading of the current time of day. * * WARNING: only TIME _or_ TIMEVAL can be defined at one time. * * NOTE: This creates a certain amount of memory overhead. */ #define LOG_PNT_TIME 0 #ifndef TIME_INCLUDE #define TIME_INCLUDE #endif #ifndef TIME_TYPE #define TIME_TYPE unsigned int #endif #define LOG_PNT_TIMEVAL 0 #define TIMEVAL_INCLUDE #define TIMEVAL_TYPE struct timeval #define GET_TIMEVAL(timeval) (void)gettimeofday(&(timeval), NULL) /* * In OSF (anyone else?) you can setup __fini_* functions in each * module which will be called automagically at shutdown of the * program. If you enable this variable, dmalloc will shut itself * down and log statistics when the program closes on its own. Pretty * cool OS feature. */ #define FINI_DMALLOC 0 /* If you enable this, you probably want the AUTO_SHUTDOWN flag turned off */ #if FINI_DMALLOC #undef AUTO_SHUTDOWN #define AUTO_SHUTDOWN 0 #endif /* * Keep addresses that are freed from recycling back into the used * queue for a certain number of memory transactions. For instance, * if this is set to 10 then after you free a pointer, it cannot be * reused until after 10 additional calls to malloc, free, realloc, * etc.. Define to 0 to disable. NOTE: setting to 1 does nothing. * * For more drastic debugging, you can enable the never-reuse flag * which will cause the library to never reuse previously allocated * memory. This may significantly expand the memory requirements of * your system however. */ #define FREED_POINTER_DELAY 20 /* * Size of the table of file and line number memory entries. This * memory table records the top locations by file/line or * return-address of all pointers allocated. It also tabulates the * freed memory pointers so you can easily locate the large memory * leaks. See the MEMORY_TABLE_TOP_LOG value below to 0 to disable * the table. * * NOTE: The table will only hold the _first_ pointers into the table. * If you configure a size of 10 then the 11th pointer allocated will * not be accounted for. * * NOTE: the library will actually allocated 2 times this many entries * for speed reasons. */ #define MEMORY_TABLE_SIZE 4096 /* * This indicates how many of the top entries from the memory table * you want to log by default to the log file. * * NOTE: to display the top entries correctly, your OS must support * the quicksort function. */ #define MEMORY_TABLE_TOP_LOG 10 /* * Define this to 1 to only display the memory table summary of the * dumped table pointers. The default is to display the summary as * well as the individual pointers so the individual leaks can be * tracked down. */ #define DUMP_UNFREED_SUMMARY_ONLY 0 /* * If (and _only_ if) your system does not have sbrk(), you can have * dmalloc pre-allocate its only heap space. The default heap size is * 1mb but you can set the space to be any size. For super-small * memory applications please understand that dmalloc is in no way * optimized for space and so you can easily run out of memory with * it. * * WARNING: this probably should only be used if HAVE_SBRK and * HAVE_MMAP are 0. Please send me email with any problems or * comments on this feature. */ #if HAVE_SBRK == 0 && HAVE_MMAP == 0 #define INTERNAL_MEMORY_SPACE (1024 * 1024) #endif /* * The default smallest allowable allocations in bytes. Any blocks * asked for that are smaller will be rounded up to this size. */ #define DEFAULT_SMALLEST_ALLOCATION 8 /****************************** thread settings ******************************/ /* * The following definition allows use of the library in threaded * programs. The most common package is MIT's pthreads so this is the * default. Please send me mail if these definitions are configurable * enough to work with your thread package. */ #ifndef LOCK_THREADS #define LOCK_THREADS 0 #endif #if LOCK_THREADS /* * Which threads library header to include when needed. It is assumed * that the types and functions in the THREAD_TYPE and THREAD_GET_ID * macros below are defined in this include file. In addition, the * thread mutex init, lock, and unlock functions in malloc.c should * also be prototyped here. */ #define THREAD_INCLUDE /* * As we approach the time when we start mutex locking the library, we * need to init the mutex variable. This sets how many times before * we start locking should we init the variable taking in account that * the init itself might generate a call into the library. Ugh. */ #define THREAD_INIT_LOCK 2 /* * For those threaded programs, the following settings allow the * library to log the identity of the thread that allocated a specific * pointer. The thread-id will show up as a ``t'' followed by a * string identifying the thread. The LOG_THREAD_ID macro says * whether the thread-id is logged at the front of all log messages. * The THREAD_TYPE macro defines the variable type of the id. The * THREAD_GET_ID macro is what function to call to get the currently * running thread. The THREAD_ID_TO_STRING defines how the thread-id * value is translated to the string necessary to be included with the * ``t'' in the logfile. */ #define LOG_PNT_THREAD_ID 0 #define THREAD_TYPE pthread_t #define THREAD_GET_ID() pthread_self() #if HAVE_SNPRINTF #define THREAD_ID_TO_STRING(buf, buf_size, thread_id) \ (void)snprintf((buf), (buf_size), "%#lx", \ (long)(thread_id)) #else #define THREAD_ID_TO_STRING(buf, buf_size, thread_id) \ (void)sprintf((buf), "%#lx", (long)(thread_id)) #endif #endif /* LOCK_THREADS */ #endif /* ! __SETTINGS_H__ */