diff options
author | Corey Farrell <git@cfware.com> | 2015-05-12 09:58:52 -0400 |
---|---|---|
committer | Corey Farrell <git@cfware.com> | 2015-05-13 21:55:07 -0400 |
commit | 478fb4a388afcb56e7e50184c996f0838d609a66 (patch) | |
tree | 7a09c1698a458a65e6703fcee59f64ec6afeed38 /include | |
parent | 3858e67dd549cf600fe1ed0c814affd9fb64c708 (diff) |
MALLOC_DEBUG: Replace WRAP_LIBC_MALLOC with ASTMM_LIBC.
There are 3 ways that calls directly to standard allocator functions can
be dealt with:
1. Block their use, cause them to generate an error. This is the default.
2. Replace them with the Asterisk equivalent function calls.
3. Leave them alone.
This change allows one of these 3 options to be selected by any source.
The source just needs to define ASTMM_LIBC to ASTMM_BLOCK, ASTMM_REDIRECT,
or ASTMM_IGNORE to use option 1, 2 or 3 respectively. Normally ASTMM_BLOCK
is the correct option, so it is default when ASTMM_LIBC is not defined.
In some cases when building 3rd party code it is desirable to have it use
Asterisk functions, without changing the whole source - ASTMM_REDIRECT
accomplishes this. When using 3rd party libraries sometimes a static
inline function will make use of malloc or free. In these cases it may
be unsafe to replace the allocator in the header, as it's possible the
memory could be freed by the library using standard allocators. For
those cases ASTMM_IGNORE is needed.
Change-Id: I8afef4bc7f3b93914263ae27d3a5858b69663fc7
Diffstat (limited to 'include')
-rw-r--r-- | include/asterisk/astmm.h | 87 |
1 files changed, 74 insertions, 13 deletions
diff --git a/include/asterisk/astmm.h b/include/asterisk/astmm.h index 1d778d4c5..6c9a8aeee 100644 --- a/include/asterisk/astmm.h +++ b/include/asterisk/astmm.h @@ -44,16 +44,6 @@ extern "C" { #include <stdio.h> #include <stdarg.h> -/* Undefine any macros */ -#undef malloc -#undef calloc -#undef realloc -#undef strdup -#undef strndup -#undef asprintf -#undef vasprintf -#undef free - void *ast_std_malloc(size_t size); void *ast_std_calloc(size_t nmemb, size_t size); void *ast_std_realloc(void *ptr, size_t size); @@ -74,9 +64,72 @@ int __ast_vasprintf(char **strp, const char *format, va_list ap, const char *fil void __ast_mm_init_phase_1(void); void __ast_mm_init_phase_2(void); -/* Redefine libc malloc to our own versions */ +/*! + * \brief ASTMM_LIBC can be defined to control the meaning of standard allocators. + * + * \note The standard allocators effected by this compiler define are: + * malloc, calloc, realloc, strdup, strndup, asprintf, vasprintf and free. + * + * @{ + */ + +/*! + * \brief Produce compiler errors if standard allocators are used. + * + * \note This is the default option, and in most cases the correct option. + * Any use of standard allocators will cause an error, even if those uses + * are in unused static inline header functions. + */ +#define ASTMM_BLOCK 0 + +/*! + * \brief Redirect standard allocators to use Asterisk functions. + * + * \note This option is used in some cases instead of changing the + * existing source to use Asterisk functions. New code should + * generally avoid this option, except where it's needed to work + * with situations where switching the code is unreasonable, such + * as output from code generators that are hard coded to use + * standard functions. + */ +#define ASTMM_REDIRECT 1 + +/*! + * \brief Standard allocators are used directly. + * + * \note This option is needed when including 3rd party headers with calls + * to standard allocators from inline functions. Using ASTMM_REDIRECT in + * this situation could result in an object being allocated by malloc and + * freed by ast_free, or the reverse. + */ +#define ASTMM_IGNORE 2 + +/*! + * }@ + */ + +#if !defined(ASTMM_LIBC) +/* BLOCK libc allocators by default. */ +#define ASTMM_LIBC ASTMM_BLOCK +#endif -#ifdef WRAP_LIBC_MALLOC +#if ASTMM_LIBC == ASTMM_IGNORE +/* Don't touch the libc functions. */ +#else + +/* Undefine any macros */ +#undef malloc +#undef calloc +#undef realloc +#undef strdup +#undef strndup +#undef asprintf +#undef vasprintf +#undef free + +#if ASTMM_LIBC == ASTMM_REDIRECT + +/* Redefine libc functions to our own versions */ #define calloc(a,b) \ __ast_calloc(a,b,__FILE__, __LINE__, __PRETTY_FUNCTION__) #define malloc(a) \ @@ -93,7 +146,10 @@ void __ast_mm_init_phase_2(void); __ast_asprintf(__FILE__, __LINE__, __PRETTY_FUNCTION__, a, b, c) #define vasprintf(a,b,c) \ __ast_vasprintf(a,b,c,__FILE__, __LINE__, __PRETTY_FUNCTION__) -#else + +#elif ASTMM_LIBC == ASTMM_BLOCK + +/* Redefine libc functions to cause compile errors */ #define calloc(a,b) \ Do_not_use_calloc__use_ast_calloc->fail(a,b) #define malloc(a) \ @@ -110,6 +166,11 @@ void __ast_mm_init_phase_2(void); Do_not_use_asprintf__use_ast_asprintf->fail(a,b,c) #define vasprintf(a,b,c) \ Do_not_use_vasprintf__use_ast_vasprintf->fail(a,b,c) + +#else +#error "Unacceptable value for the macro ASTMM_LIBC" +#endif + #endif /* Provide our own definitions */ |