1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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(malloc_table_t*, ReplaceMallocBridge**)
//
// The malloc_table_t pointer given to that function is a table containing
// pointers to the original allocator implementation, so that replacement
// functions can call them back if they need to. The initialization function
// needs to alter that table to replace the function it wants to replace.
// If it needs the original implementation, it thus needs a copy of the
// original table.
//
// The ReplaceMallocBridge* pointer is an outparam that allows the
// replace_init function to return a pointer to its ReplaceMallocBridge
// (see replace_malloc_bridge.h).
//
// 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 a pointer to a copy of the table replace_init got.
//
// 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/MacroArgs.h"
#include "mozilla/Types.h"
MOZ_BEGIN_EXTERN_C
// MOZ_REPLACE_WEAK is only defined in mozjemalloc.cpp. Normally including
// this header will add function definitions.
#ifndef MOZ_REPLACE_WEAK
# define MOZ_REPLACE_WEAK
#endif
// When building a replace-malloc library for static linking, we want
// each to have a different name for their "public" functions.
// The build system defines MOZ_REPLACE_MALLOC_PREFIX in that case.
#ifdef MOZ_REPLACE_MALLOC_PREFIX
# define replace_init MOZ_CONCAT(MOZ_REPLACE_MALLOC_PREFIX, _init)
# define MOZ_REPLACE_PUBLIC
#else
# define MOZ_REPLACE_PUBLIC MOZ_EXPORT
#endif
struct ReplaceMallocBridge;
typedef void (*jemalloc_init_func)(malloc_table_t*,
struct ReplaceMallocBridge**);
// Replace-malloc library initialization function. See top of this file
MOZ_REPLACE_PUBLIC void replace_init(
malloc_table_t*, struct ReplaceMallocBridge**) MOZ_REPLACE_WEAK;
// ensure this is visible and libxul/etc reference it with a weak ref
MFBT_API void jemalloc_replace_dynamic(jemalloc_init_func);
MOZ_END_EXTERN_C
#endif // replace_malloc_h
|
