third_party/tcmalloc/chromium/src/gperftools/malloc_hook.h

   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>
  71 extern "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
  97 class 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_ */