| /* This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this file, |
| * You can obtain one at http://mozilla.org/MPL/2.0/. */ |
| |
| #ifndef replace_malloc_h |
| #define replace_malloc_h |
| |
| /* |
| * The replace_malloc facility allows an external library to replace or |
| * supplement the jemalloc implementation. |
| * |
| * The external library may be hooked by setting one of the following |
| * environment variables to the library path: |
| * - LD_PRELOAD on Linux, |
| * - DYLD_INSERT_LIBRARIES on OSX, |
| * - MOZ_REPLACE_MALLOC_LIB on Windows and Android. |
| * |
| * An initialization function is called before any malloc replacement |
| * function, and has the following declaration: |
| * |
| * void replace_init(const malloc_table_t *) |
| * |
| * The const malloc_table_t pointer given to that function is a table |
| * containing pointers to the original jemalloc implementation, so that |
| * replacement functions can call them back if they need to. The pointer |
| * itself can safely be kept around (no need to copy the table itself). |
| * |
| * The functions to be implemented in the external library are of the form: |
| * |
| * void *replace_malloc(size_t size) |
| * { |
| * // Fiddle with the size if necessary. |
| * // orig->malloc doesn't have to be called if the external library |
| * // provides its own allocator, but in this case it will have to |
| * // implement all functions. |
| * void *ptr = orig->malloc(size); |
| * // Do whatever you want with the ptr. |
| * return ptr; |
| * } |
| * |
| * where "orig" is the pointer obtained from replace_init. |
| * |
| * See malloc_decls.h for a list of functions that can be replaced this |
| * way. The implementations are all in the form: |
| * return_type replace_name(arguments [,...]) |
| * |
| * They don't all need to be provided. |
| * |
| * Building a replace-malloc library is like rocket science. It can end up |
| * with things blowing up, especially when trying to use complex types, and |
| * even more especially when these types come from XPCOM or other parts of the |
| * Mozilla codebase. |
| * It is recommended to add the following to a replace-malloc implementation's |
| * moz.build: |
| * DISABLE_STL_WRAPPING = True # Avoid STL wrapping |
| * |
| * If your replace-malloc implementation lives under memory/replace, these |
| * are taken care of by memory/replace/defs.mk. |
| */ |
| |
| #ifdef replace_malloc_bridge_h |
| #error Do not include replace_malloc_bridge.h before replace_malloc.h. \ |
| In fact, you only need the latter. |
| #endif |
| |
| #define REPLACE_MALLOC_IMPL |
| |
| #include "replace_malloc_bridge.h" |
| |
| /* Implementing a replace-malloc library is incompatible with using mozalloc. */ |
| #define MOZ_NO_MOZALLOC 1 |
| |
| #include "mozilla/Types.h" |
| |
| MOZ_BEGIN_EXTERN_C |
| |
| /* MOZ_NO_REPLACE_FUNC_DECL and MOZ_REPLACE_WEAK are only defined in |
| * replace_malloc.c. Normally including this header will add function |
| * definitions. */ |
| #ifndef MOZ_NO_REPLACE_FUNC_DECL |
| |
| # ifndef MOZ_REPLACE_WEAK |
| # define MOZ_REPLACE_WEAK |
| # endif |
| |
| # define MALLOC_DECL(name, return_type, ...) \ |
| MOZ_EXPORT return_type replace_ ## name(__VA_ARGS__) MOZ_REPLACE_WEAK; |
| |
| # define MALLOC_FUNCS MALLOC_FUNCS_ALL |
| # include "malloc_decls.h" |
| |
| #endif /* MOZ_NO_REPLACE_FUNC_DECL */ |
| |
| /* |
| * posix_memalign, aligned_alloc, memalign and valloc all implement some |
| * kind of aligned memory allocation. For convenience, replace_posix_memalign, |
| * replace_aligned_alloc and replace_valloc can be automatically derived from |
| * memalign when MOZ_REPLACE_ONLY_MEMALIGN is defined before including this |
| * header. PAGE_SIZE also needs to be defined to the appropriate expression. |
| */ |
| #ifdef MOZ_REPLACE_ONLY_MEMALIGN |
| #include <errno.h> |
| |
| int replace_posix_memalign(void **ptr, size_t alignment, size_t size) |
| { |
| if (size == 0) { |
| *ptr = NULL; |
| return 0; |
| } |
| /* alignment must be a power of two and a multiple of sizeof(void *) */ |
| if (((alignment - 1) & alignment) != 0 || (alignment % sizeof(void *))) |
| return EINVAL; |
| *ptr = replace_memalign(alignment, size); |
| return *ptr ? 0 : ENOMEM; |
| } |
| |
| void *replace_aligned_alloc(size_t alignment, size_t size) |
| { |
| /* size should be a multiple of alignment */ |
| if (size % alignment) |
| return NULL; |
| return replace_memalign(alignment, size); |
| } |
| |
| void *replace_valloc(size_t size) |
| { |
| return replace_memalign(PAGE_SIZE, size); |
| } |
| #endif |
| |
| MOZ_END_EXTERN_C |
| |
| #endif /* replace_malloc_h */ |