1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 #ifndef replace_malloc_bridge_h
8 #define replace_malloc_bridge_h
10 // The replace-malloc bridge allows bidirectional method calls between
11 // a program and the replace-malloc library that has been loaded for it.
12 // In Firefox, this is used to allow method calls between code in libxul
13 // and code in the replace-malloc library, without libxul needing to link
14 // against that library or vice-versa.
16 // Subsystems can add methods for their own need. Replace-malloc libraries
17 // can decide to implement those methods or not.
19 // Replace-malloc libraries can provide such a bridge by implementing
20 // a ReplaceMallocBridge-derived class, and a get_bridge function
21 // returning an instance of that class. The default methods in
22 // ReplaceMallocBridge are expected to return values that callers would
23 // understand as "the bridge doesn't implement this method", so that a
24 // replace-malloc library doesn't have to implement all methods.
26 // The ReplaceMallocBridge class contains definitions for methods for
27 // all replace-malloc libraries. Each library picks the methods it wants
28 // to reply to in its ReplaceMallocBridge-derived class instance.
29 // All methods of ReplaceMallocBridge must be virtual. Similarly,
30 // anything passed as an argument to those methods must be plain data, or
31 // an instance of a class with only virtual methods.
33 // Binary compatibility is expected to be maintained, such that a newer
34 // Firefox can be used with an old replace-malloc library, or an old
35 // Firefox can be used with a newer replace-malloc library. As such, only
36 // new virtual methods should be added to ReplaceMallocBridge, and
37 // each change should have a corresponding bump of the mVersion value.
38 // At the same time, each virtual method should have a corresponding
39 // wrapper calling the virtual method on the instance from
40 // ReplaceMallocBridge::Get(), giving it the version the virtual method
43 // Parts that are not relevant to the replace-malloc library end of the
44 // bridge are hidden when REPLACE_MALLOC_IMPL is not defined, which is
45 // the case when including replace_malloc.h.
47 struct ReplaceMallocBridge
;
49 #include "mozilla/Types.h"
53 #ifndef REPLACE_MALLOC_IMPL
54 // Returns the replace-malloc bridge if there is one to be returned.
55 MFBT_API ReplaceMallocBridge
* get_bridge();
58 // Table of malloc functions.
59 // e.g. void* (*malloc)(size_t), etc.
61 #define MALLOC_DECL(name, return_type, ...) \
62 typedef return_type(name##_impl_t)(__VA_ARGS__);
64 #include "malloc_decls.h"
66 #define MALLOC_DECL(name, return_type, ...) name##_impl_t* name;
69 #include "malloc_decls.h"
76 // Table of malloc hook functions.
77 // Those functions are called with the arguments and results of malloc
78 // functions after they are called.
79 // e.g. void* (*malloc_hook)(void*, size_t), etc.
80 // They can either return the result they're given, or alter it before
82 // The hooks corresponding to functions, like free(void*), that return no
83 // value, don't take an extra argument.
84 // The table must at least contain a pointer for malloc_hook and free_hook
85 // functions. They will be used as fallback if no pointer is given for
86 // other allocation functions, like calloc_hook.
89 template <typename R
, typename
... Args
>
90 struct AllocHookType
{
91 using Type
= R (*)(R
, Args
...);
94 template <typename
... Args
>
95 struct AllocHookType
<void, Args
...> {
96 using Type
= void (*)(Args
...);
100 } // namespace mozilla
102 # define MALLOC_DECL(name, return_type, ...) \
103 typename mozilla::detail::AllocHookType<return_type, ##__VA_ARGS__>::Type \
107 # include "malloc_decls.h"
108 // Like free_hook, but called before realloc_hook. free_hook is called
109 // instead of not given.
110 void (*realloc_hook_before
)(void* aPtr
);
111 } malloc_hook_table_t
;
124 // Callbacks to register debug file handles for Poison IO interpose.
125 // See Mozilla(|Un)RegisterDebugHandle in xpcom/build/PoisonIOInterposer.h
126 struct DebugFdRegistry
{
127 virtual void RegisterHandle(intptr_t aFd
);
129 virtual void UnRegisterHandle(intptr_t aFd
);
131 } // namespace mozilla
133 struct ReplaceMallocBridge
{
134 ReplaceMallocBridge() : mVersion(6) {}
136 // This method was added in version 1 of the bridge.
137 virtual mozilla::dmd::DMDFuncs
* GetDMDFuncs() { return nullptr; }
139 // Send a DebugFdRegistry instance to the replace-malloc library so that
140 // it can register/unregister file descriptors whenever needed. The
141 // instance is valid until the process dies.
142 // This method was added in version 2 of the bridge.
143 virtual void InitDebugFd(mozilla::DebugFdRegistry
&) {}
145 // Register a list of malloc functions and hook functions to the
146 // replace-malloc library so that it can choose to dispatch to them
147 // when needed. The details of what is dispatched when is left to the
148 // replace-malloc library.
149 // Passing a nullptr for either table will unregister a previously
150 // registered table under the same name.
151 // Returns nullptr if registration failed.
152 // If registration succeeded, a table of "pure" malloc functions is
153 // returned. Those "pure" malloc functions won't call hooks.
154 // /!\ Do not rely on registration/unregistration to be instantaneous.
155 // Functions from a previously registered table may still be called for
156 // a brief time after RegisterHook returns.
157 // This method was added in version 3 of the bridge.
158 virtual const malloc_table_t
* RegisterHook(
159 const char* aName
, const malloc_table_t
* aTable
,
160 const malloc_hook_table_t
* aHookTable
) {
164 # ifndef REPLACE_MALLOC_IMPL
165 // Returns the replace-malloc bridge if its version is at least the
167 static ReplaceMallocBridge
* Get(int aMinimumVersion
) {
168 static ReplaceMallocBridge
* sSingleton
= get_bridge();
169 return (sSingleton
&& sSingleton
->mVersion
>= aMinimumVersion
) ? sSingleton
178 # ifndef REPLACE_MALLOC_IMPL
179 // Class containing wrappers for calls to ReplaceMallocBridge methods.
180 // Those wrappers need to be static methods in a class because compilers
181 // complain about unused static global functions, and linkers complain
182 // about multiple definitions of non-static global functions.
183 // Using a separate class from ReplaceMallocBridge allows the function
184 // names to be identical.
185 struct ReplaceMalloc
{
186 // Don't call this method from performance critical code. Use
187 // mozilla::dmd::DMDFuncs::Get() instead, it has less overhead.
188 static mozilla::dmd::DMDFuncs
* GetDMDFuncs() {
189 auto singleton
= ReplaceMallocBridge::Get(/* minimumVersion */ 1);
190 return singleton
? singleton
->GetDMDFuncs() : nullptr;
193 static void InitDebugFd(mozilla::DebugFdRegistry
& aRegistry
) {
194 auto singleton
= ReplaceMallocBridge::Get(/* minimumVersion */ 2);
196 singleton
->InitDebugFd(aRegistry
);
200 static const malloc_table_t
* RegisterHook(
201 const char* aName
, const malloc_table_t
* aTable
,
202 const malloc_hook_table_t
* aHookTable
) {
203 auto singleton
= ReplaceMallocBridge::Get(/* minimumVersion */ 3);
204 return singleton
? singleton
->RegisterHook(aName
, aTable
, aHookTable
)
210 #endif // __cplusplus
212 #endif // replace_malloc_bridge_h