1// Copyright (c) 2005, Google Inc. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above 11// copyright notice, this list of conditions and the following disclaimer 12// in the documentation and/or other materials provided with the 13// distribution. 14// * Neither the name of Google Inc. nor the names of its 15// contributors may be used to endorse or promote products derived from 16// this software without specific prior written permission. 17// 18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30// --- 31// Author: Sanjay Ghemawat 32// 33// Some of our malloc implementations can invoke the following hooks whenever 34// memory is allocated or deallocated. MallocHook is thread-safe, and things 35// you do before calling AddFooHook(MyHook) are visible to any resulting calls 36// to MyHook. Hooks must be thread-safe. If you write: 37// 38// CHECK(MallocHook::AddNewHook(&MyNewHook)); 39// 40// MyNewHook will be invoked in subsequent calls in the current thread, but 41// there are no guarantees on when it might be invoked in other threads. 42// 43// There are a limited number of slots available for each hook type. Add*Hook 44// will return false if there are no slots available. Remove*Hook will return 45// false if the given hook was not already installed. 46// 47// The order in which individual hooks are called in Invoke*Hook is undefined. 48// 49// It is safe for a hook to remove itself within Invoke*Hook and add other 50// hooks. Any hooks added inside a hook invocation (for the same hook type) 51// will not be invoked for the current invocation. 52// 53// One important user of these hooks is the heap profiler. 54// 55// CAVEAT: If you add new MallocHook::Invoke* calls then those calls must be 56// directly in the code of the (de)allocation function that is provided to the 57// user and that function must have an ATTRIBUTE_SECTION(malloc_hook) attribute. 58// 59// Note: the Invoke*Hook() functions are defined in malloc_hook-inl.h. If you 60// need to invoke a hook (which you shouldn't unless you're part of tcmalloc), 61// be sure to #include malloc_hook-inl.h in addition to malloc_hook.h. 62// 63// NOTE FOR C USERS: If you want to use malloc_hook functionality from 64// a C program, #include malloc_hook_c.h instead of this file. 65 66#ifndef _MALLOC_HOOK_H_ 67#define _MALLOC_HOOK_H_ 68 69#include <stddef.h> 70#include <sys/types.h> 71extern "C" { 72#include <gperftools/malloc_hook_c.h> // a C version of the malloc_hook interface 73} 74 75// Annoying stuff for windows -- makes sure clients can import these functions 76#ifndef PERFTOOLS_DLL_DECL 77# ifdef _WIN32 78# define PERFTOOLS_DLL_DECL __declspec(dllimport) 79# else 80# define PERFTOOLS_DLL_DECL 81# endif 82#endif 83 84// The C++ methods below call the C version (MallocHook_*), and thus 85// convert between an int and a bool. Windows complains about this 86// (a "performance warning") which we don't care about, so we suppress. 87#ifdef _MSC_VER 88#pragma warning(push) 89#pragma warning(disable:4800) 90#endif 91 92// Note: malloc_hook_c.h defines MallocHook_*Hook and 93// MallocHook_{Add,Remove}*Hook. The version of these inside the MallocHook 94// class are defined in terms of the malloc_hook_c version. See malloc_hook_c.h 95// for details of these types/functions. 96 97class PERFTOOLS_DLL_DECL MallocHook { 98 public: 99 // The NewHook is invoked whenever an object is allocated. 100 // It may be passed NULL if the allocator returned NULL. 101 typedef MallocHook_NewHook NewHook; 102 inline static bool AddNewHook(NewHook hook) { 103 return MallocHook_AddNewHook(hook); 104 } 105 inline static bool RemoveNewHook(NewHook hook) { 106 return MallocHook_RemoveNewHook(hook); 107 } 108 inline static void InvokeNewHook(const void* p, size_t s); 109 110 // The DeleteHook is invoked whenever an object is deallocated. 111 // It may be passed NULL if the caller is trying to delete NULL. 112 typedef MallocHook_DeleteHook DeleteHook; 113 inline static bool AddDeleteHook(DeleteHook hook) { 114 return MallocHook_AddDeleteHook(hook); 115 } 116 inline static bool RemoveDeleteHook(DeleteHook hook) { 117 return MallocHook_RemoveDeleteHook(hook); 118 } 119 inline static void InvokeDeleteHook(const void* p); 120 121 // The PreMmapHook is invoked with mmap or mmap64 arguments just 122 // before the call is actually made. Such a hook may be useful 123 // in memory limited contexts, to catch allocations that will exceed 124 // a memory limit, and take outside actions to increase that limit. 125 typedef MallocHook_PreMmapHook PreMmapHook; 126 inline static bool AddPreMmapHook(PreMmapHook hook) { 127 return MallocHook_AddPreMmapHook(hook); 128 } 129 inline static bool RemovePreMmapHook(PreMmapHook hook) { 130 return MallocHook_RemovePreMmapHook(hook); 131 } 132 inline static void InvokePreMmapHook(const void* start, 133 size_t size, 134 int protection, 135 int flags, 136 int fd, 137 off_t offset); 138 139 // The MmapReplacement is invoked after the PreMmapHook but before 140 // the call is actually made. The MmapReplacement should return true 141 // if it handled the call, or false if it is still necessary to 142 // call mmap/mmap64. 143 // This should be used only by experts, and users must be be 144 // extremely careful to avoid recursive calls to mmap. The replacement 145 // should be async signal safe. 146 // Only one MmapReplacement is supported. After setting an MmapReplacement 147 // you must call RemoveMmapReplacement before calling SetMmapReplacement 148 // again. 149 typedef MallocHook_MmapReplacement MmapReplacement; 150 inline static bool SetMmapReplacement(MmapReplacement hook) { 151 return MallocHook_SetMmapReplacement(hook); 152 } 153 inline static bool RemoveMmapReplacement(MmapReplacement hook) { 154 return MallocHook_RemoveMmapReplacement(hook); 155 } 156 inline static bool InvokeMmapReplacement(const void* start, 157 size_t size, 158 int protection, 159 int flags, 160 int fd, 161 off_t offset, 162 void** result); 163 164 165 // The MmapHook is invoked whenever a region of memory is mapped. 166 // It may be passed MAP_FAILED if the mmap failed. 167 typedef MallocHook_MmapHook MmapHook; 168 inline static bool AddMmapHook(MmapHook hook) { 169 return MallocHook_AddMmapHook(hook); 170 } 171 inline static bool RemoveMmapHook(MmapHook hook) { 172 return MallocHook_RemoveMmapHook(hook); 173 } 174 inline static void InvokeMmapHook(const void* result, 175 const void* start, 176 size_t size, 177 int protection, 178 int flags, 179 int fd, 180 off_t offset); 181 182 // The MunmapReplacement is invoked with munmap arguments just before 183 // the call is actually made. The MunmapReplacement should return true 184 // if it handled the call, or false if it is still necessary to 185 // call munmap. 186 // This should be used only by experts. The replacement should be 187 // async signal safe. 188 // Only one MunmapReplacement is supported. After setting an 189 // MunmapReplacement you must call RemoveMunmapReplacement before 190 // calling SetMunmapReplacement again. 191 typedef MallocHook_MunmapReplacement MunmapReplacement; 192 inline static bool SetMunmapReplacement(MunmapReplacement hook) { 193 return MallocHook_SetMunmapReplacement(hook); 194 } 195 inline static bool RemoveMunmapReplacement(MunmapReplacement hook) { 196 return MallocHook_RemoveMunmapReplacement(hook); 197 } 198 inline static bool InvokeMunmapReplacement(const void* p, 199 size_t size, 200 int* result); 201 202 // The MunmapHook is invoked whenever a region of memory is unmapped. 203 typedef MallocHook_MunmapHook MunmapHook; 204 inline static bool AddMunmapHook(MunmapHook hook) { 205 return MallocHook_AddMunmapHook(hook); 206 } 207 inline static bool RemoveMunmapHook(MunmapHook hook) { 208 return MallocHook_RemoveMunmapHook(hook); 209 } 210 inline static void InvokeMunmapHook(const void* p, size_t size); 211 212 // The MremapHook is invoked whenever a region of memory is remapped. 213 typedef MallocHook_MremapHook MremapHook; 214 inline static bool AddMremapHook(MremapHook hook) { 215 return MallocHook_AddMremapHook(hook); 216 } 217 inline static bool RemoveMremapHook(MremapHook hook) { 218 return MallocHook_RemoveMremapHook(hook); 219 } 220 inline static void InvokeMremapHook(const void* result, 221 const void* old_addr, 222 size_t old_size, 223 size_t new_size, 224 int flags, 225 const void* new_addr); 226 227 // The PreSbrkHook is invoked just before sbrk is called -- except when 228 // the increment is 0. This is because sbrk(0) is often called 229 // to get the top of the memory stack, and is not actually a 230 // memory-allocation call. It may be useful in memory-limited contexts, 231 // to catch allocations that will exceed the limit and take outside 232 // actions to increase such a limit. 233 typedef MallocHook_PreSbrkHook PreSbrkHook; 234 inline static bool AddPreSbrkHook(PreSbrkHook hook) { 235 return MallocHook_AddPreSbrkHook(hook); 236 } 237 inline static bool RemovePreSbrkHook(PreSbrkHook hook) { 238 return MallocHook_RemovePreSbrkHook(hook); 239 } 240 inline static void InvokePreSbrkHook(ptrdiff_t increment); 241 242 // The SbrkHook is invoked whenever sbrk is called -- except when 243 // the increment is 0. This is because sbrk(0) is often called 244 // to get the top of the memory stack, and is not actually a 245 // memory-allocation call. 246 typedef MallocHook_SbrkHook SbrkHook; 247 inline static bool AddSbrkHook(SbrkHook hook) { 248 return MallocHook_AddSbrkHook(hook); 249 } 250 inline static bool RemoveSbrkHook(SbrkHook hook) { 251 return MallocHook_RemoveSbrkHook(hook); 252 } 253 inline static void InvokeSbrkHook(const void* result, ptrdiff_t increment); 254 255 // Get the current stack trace. Try to skip all routines up to and 256 // and including the caller of MallocHook::Invoke*. 257 // Use "skip_count" (similarly to GetStackTrace from stacktrace.h) 258 // as a hint about how many routines to skip if better information 259 // is not available. 260 inline static int GetCallerStackTrace(void** result, int max_depth, 261 int skip_count) { 262 return MallocHook_GetCallerStackTrace(result, max_depth, skip_count); 263 } 264 265 // Unhooked versions of mmap() and munmap(). These should be used 266 // only by experts, since they bypass heapchecking, etc. 267 // Note: These do not run hooks, but they still use the MmapReplacement 268 // and MunmapReplacement. 269 static void* UnhookedMMap(void *start, size_t length, int prot, int flags, 270 int fd, off_t offset); 271 static int UnhookedMUnmap(void *start, size_t length); 272 273 // The following are DEPRECATED. 274 inline static NewHook GetNewHook(); 275 inline static NewHook SetNewHook(NewHook hook) { 276 return MallocHook_SetNewHook(hook); 277 } 278 279 inline static DeleteHook GetDeleteHook(); 280 inline static DeleteHook SetDeleteHook(DeleteHook hook) { 281 return MallocHook_SetDeleteHook(hook); 282 } 283 284 inline static PreMmapHook GetPreMmapHook(); 285 inline static PreMmapHook SetPreMmapHook(PreMmapHook hook) { 286 return MallocHook_SetPreMmapHook(hook); 287 } 288 289 inline static MmapHook GetMmapHook(); 290 inline static MmapHook SetMmapHook(MmapHook hook) { 291 return MallocHook_SetMmapHook(hook); 292 } 293 294 inline static MunmapHook GetMunmapHook(); 295 inline static MunmapHook SetMunmapHook(MunmapHook hook) { 296 return MallocHook_SetMunmapHook(hook); 297 } 298 299 inline static MremapHook GetMremapHook(); 300 inline static MremapHook SetMremapHook(MremapHook hook) { 301 return MallocHook_SetMremapHook(hook); 302 } 303 304 inline static PreSbrkHook GetPreSbrkHook(); 305 inline static PreSbrkHook SetPreSbrkHook(PreSbrkHook hook) { 306 return MallocHook_SetPreSbrkHook(hook); 307 } 308 309 inline static SbrkHook GetSbrkHook(); 310 inline static SbrkHook SetSbrkHook(SbrkHook hook) { 311 return MallocHook_SetSbrkHook(hook); 312 } 313 // End of DEPRECATED methods. 314 315 private: 316 // Slow path versions of Invoke*Hook. 317 static void InvokeNewHookSlow(const void* p, size_t s); 318 static void InvokeDeleteHookSlow(const void* p); 319 static void InvokePreMmapHookSlow(const void* start, 320 size_t size, 321 int protection, 322 int flags, 323 int fd, 324 off_t offset); 325 static void InvokeMmapHookSlow(const void* result, 326 const void* start, 327 size_t size, 328 int protection, 329 int flags, 330 int fd, 331 off_t offset); 332 static bool InvokeMmapReplacementSlow(const void* start, 333 size_t size, 334 int protection, 335 int flags, 336 int fd, 337 off_t offset, 338 void** result); 339 static void InvokeMunmapHookSlow(const void* p, size_t size); 340 static bool InvokeMunmapReplacementSlow(const void* p, 341 size_t size, 342 int* result); 343 static void InvokeMremapHookSlow(const void* result, 344 const void* old_addr, 345 size_t old_size, 346 size_t new_size, 347 int flags, 348 const void* new_addr); 349 static void InvokePreSbrkHookSlow(ptrdiff_t increment); 350 static void InvokeSbrkHookSlow(const void* result, ptrdiff_t increment); 351}; 352 353#ifdef _MSC_VER 354#pragma warning(pop) 355#endif 356 357 358#endif /* _MALLOC_HOOK_H_ */ 359