drd/drd_malloc_wrappers.c

   1 /*
   2   This file is part of drd, a thread error detector.
   3
   4   Copyright (C) 2006-2020 Bart Van Assche <bvanassche@acm.org>.
   5
   6   This program is free software; you can redistribute it and/or
   7   modify it under the terms of the GNU General Public License as
   8   published by the Free Software Foundation; either version 2 of the
   9   License, or (at your option) any later version.
  10
  11   This program is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with this program; if not, see <http://www.gnu.org/licenses/>.
  18
  19   The GNU General Public License is contained in the file COPYING.
  20 */
  21
  22
  23 #include "drd_malloc_wrappers.h"
  24 #include "drd_thread.h"
  25 #include "pub_tool_basics.h"
  26 #include "pub_tool_execontext.h"
  27 #include "pub_tool_hashtable.h"
  28 #include "pub_tool_libcassert.h"
  29 #include "pub_tool_libcbase.h"
  30 #include "pub_tool_libcprint.h"
  31 #include "pub_tool_mallocfree.h"
  32 #include "pub_tool_options.h"
  33 #include "pub_tool_replacemalloc.h"
  34 #include "pub_tool_threadstate.h"
  35 #include "pub_tool_tooliface.h"
  36
  37
  38 /* Local type definitions. */
  39
  40 /**
  41  * Node with per-allocation information that will be stored in a hash map.
  42  * As specified in <pub_tool_hashtable.h>, the first member must be a pointer
  43  * and the second member must be an UWord.
  44  */
  45 typedef struct _DRD_Chunk {
  46    struct _DRD_Chunk* next;
  47    UWord              data;   // pointer to actual block
  48    SizeT              size;   // size requested
  49    ExeContext*        where;  // where it was allocated
  50 } DRD_Chunk;
  51
  52
  53 /* Local variables. */
  54
  55 static StartUsingMem s_start_using_mem_callback;
  56 static StopUsingMem  s_stop_using_mem_callback;
  57 /* Statistics. */
  58 static SizeT s_cmalloc_n_mallocs  = 0;
  59 static SizeT s_cmalloc_n_frees    = 0;
  60 static SizeT s_cmalloc_bs_mallocd = 0;
  61 /* Record malloc'd blocks. */
  62 static VgHashTable *s_malloc_list = NULL;
  63
  64
  65 /* Function definitions. */
  66
  67 /** Allocate client memory memory and update the hash map. */
  68 static void* new_block(ThreadId tid, SizeT size, SizeT align, Bool is_zeroed)
  69 {
  70    void* p;
  71
  72    p = VG_(cli_malloc)(align, size);
  73    if (!p)
  74       return NULL;
  75    if (is_zeroed)
  76       VG_(memset)(p, 0, size);
  77
  78    DRD_(malloclike_block)(tid, (Addr)p, size);
  79
  80    return p;
  81 }
  82
  83 /**
  84  * Store information about a memory block that has been allocated by
  85  * malloc() or a malloc() replacement in the hash map.
  86  */
  87 void DRD_(malloclike_block)(const ThreadId tid, const Addr p, const SizeT size)
  88 {
  89    DRD_Chunk* mc;
  90
  91    tl_assert(p);
  92
  93    if (size > 0)
  94       s_start_using_mem_callback(p, size, 0/*ec_uniq*/);
  95
  96    s_cmalloc_n_mallocs++;
  97    // Only update this stat if allocation succeeded.
  98    s_cmalloc_bs_mallocd += size;
  99
 100    mc = VG_(malloc)("drd.malloc_wrappers.cDC.1", sizeof(DRD_Chunk));
 101    mc->data  = p;
 102    mc->size  = size;
 103    mc->where = VG_(record_ExeContext)(tid, 0);
 104    VG_(HT_add_node)(s_malloc_list, mc);
 105 }
 106
 107 static void handle_free(ThreadId tid, void* p)
 108 {
 109    Bool success;
 110
 111    tl_assert(p);
 112    success = DRD_(freelike_block)(tid, (Addr)p, True);
 113    tl_assert(success);
 114 }
 115
 116 /**
 117  * Remove the information that was stored by DRD_(malloclike_block)() about
 118  * a memory block.
 119  */
 120 Bool DRD_(freelike_block)(const ThreadId tid, const Addr p, const Bool dealloc)
 121 {
 122    DRD_Chunk* mc;
 123
 124    tl_assert(p);
 125
 126    s_cmalloc_n_frees++;
 127
 128    mc = VG_(HT_lookup)(s_malloc_list, (UWord)p);
 129    if (mc)
 130    {
 131       tl_assert(p == mc->data);
 132       if (mc->size > 0)
 133          s_stop_using_mem_callback(mc->data, mc->size);
 134       if (dealloc)
 135          VG_(cli_free)((void*)p);
 136       VG_(HT_remove)(s_malloc_list, (UWord)p);
 137       VG_(free)(mc);
 138       return True;
 139    }
 140    return False;
 141 }
 142
 143 /** Wrapper for malloc(). */
 144 static void* drd_malloc(ThreadId tid, SizeT n)
 145 {
 146    return new_block(tid, n, VG_(clo_alignment), /*is_zeroed*/False);
 147 }
 148
 149 /** Wrapper for memalign(). */
 150 static void* drd_memalign(ThreadId tid, SizeT align, SizeT n)
 151 {
 152    return new_block(tid, n, align, /*is_zeroed*/False);
 153 }
 154
 155 /** Wrapper for calloc(). */
 156 static void* drd_calloc(ThreadId tid, SizeT nmemb, SizeT size1)
 157 {
 158    return new_block(tid, nmemb*size1, VG_(clo_alignment),
 159                           /*is_zeroed*/True);
 160 }
 161
 162 /** Wrapper for free(). */
 163 static void drd_free(ThreadId tid, void* p)
 164 {
 165    handle_free(tid, p);
 166 }
 167
 168 /**
 169  * Wrapper for realloc(). Returns a pointer to the new block of memory, or
 170  * NULL if no new block could not be allocated. Notes:
 171  * - realloc(NULL, size) has the same effect as malloc(size).
 172  * - realloc(p, 0) has the same effect as free(p).
 173  * - success is not guaranteed even if the requested size is smaller than the
 174  *   allocated size.
 175 */
 176 static void* drd_realloc(ThreadId tid, void* p_old, SizeT new_size)
 177 {
 178    DRD_Chunk* mc;
 179    void*      p_new;
 180    SizeT      old_size;
 181
 182    if (! p_old)
 183       return drd_malloc(tid, new_size);
 184
 185    if (new_size == 0)
 186    {
 187       drd_free(tid, p_old);
 188       return NULL;
 189    }
 190
 191    s_cmalloc_n_mallocs++;
 192    s_cmalloc_n_frees++;
 193    s_cmalloc_bs_mallocd += new_size;
 194
 195    mc = VG_(HT_lookup)(s_malloc_list, (UWord)p_old);
 196    if (mc == NULL)
 197    {
 198       tl_assert(0);
 199       return NULL;
 200    }
 201
 202    old_size = mc->size;
 203
 204    if (old_size == new_size)
 205    {
 206       /* size unchanged */
 207       mc->where = VG_(record_ExeContext)(tid, 0);
 208       p_new = p_old;
 209    }
 210    else if (new_size < old_size)
 211    {
 212       /* new size is smaller but nonzero */
 213       s_stop_using_mem_callback(mc->data + new_size, old_size - new_size);
 214       mc->size = new_size;
 215       mc->where = VG_(record_ExeContext)(tid, 0);
 216       p_new = p_old;
 217    }
 218    else
 219    {
 220       /* new size is bigger */
 221       p_new = VG_(cli_malloc)(VG_(clo_alignment), new_size);
 222
 223       if (p_new)
 224       {
 225          /* Copy from old to new. */
 226          VG_(memcpy)(p_new, p_old, mc->size);
 227
 228          /* Free old memory. */
 229          if (mc->size > 0)
 230             s_stop_using_mem_callback(mc->data, mc->size);
 231          VG_(cli_free)(p_old);
 232          VG_(HT_remove)(s_malloc_list, (UWord)p_old);
 233
 234          /* Update state information. */
 235          mc->data  = (Addr)p_new;
 236          mc->size  = new_size;
 237          mc->where = VG_(record_ExeContext)(tid, 0);
 238          VG_(HT_add_node)(s_malloc_list, mc);
 239          s_start_using_mem_callback((Addr)p_new, new_size, 0/*ec_uniq*/);
 240       }
 241       else
 242       {
 243          /* Allocation failed -- leave original block untouched. */
 244       }
 245    }
 246
 247    return p_new;
 248 }
 249
 250 /** Wrapper for __builtin_new(). */
 251 static void* drd___builtin_new(ThreadId tid, SizeT n)
 252 {
 253    return new_block(tid, n, VG_(clo_alignment), /*is_zeroed*/False);
 254 }
 255
 256 /** Wrapper for __builtin_delete(). */
 257 static void drd___builtin_delete(ThreadId tid, void* p)
 258 {
 259    handle_free(tid, p);
 260 }
 261
 262 /** Wrapper for __builtin_vec_new(). */
 263 static void* drd___builtin_vec_new(ThreadId tid, SizeT n)
 264 {
 265    return new_block(tid, n, VG_(clo_alignment), /*is_zeroed*/False);
 266 }
 267
 268 /** Wrapper for __builtin_vec_delete(). */
 269 static void drd___builtin_vec_delete(ThreadId tid, void* p)
 270 {
 271    handle_free(tid, p);
 272 }
 273
 274 /**
 275  * Wrapper for malloc_usable_size() / malloc_size(). This function takes
 276  * a pointer to a block allocated by `malloc' and returns the amount of space
 277  * that is available in the block. This may or may not be more than the size
 278  * requested from `malloc', due to alignment or minimum size constraints.
 279  */
 280 static SizeT drd_malloc_usable_size(ThreadId tid, void* p)
 281 {
 282    DRD_Chunk* mc;
 283
 284    mc = VG_(HT_lookup)(s_malloc_list, (UWord)p);
 285
 286    return mc ? mc->size : 0;
 287 }
 288
 289 void DRD_(register_malloc_wrappers)(const StartUsingMem start_callback,
 290                                     const StopUsingMem stop_callback)
 291 {
 292    tl_assert(s_malloc_list == 0);
 293    s_malloc_list = VG_(HT_construct)("drd_malloc_list");
 294    tl_assert(start_callback);
 295    tl_assert(stop_callback);
 296
 297    s_start_using_mem_callback = start_callback;
 298    s_stop_using_mem_callback  = stop_callback;
 299
 300    VG_(needs_malloc_replacement)(drd_malloc,
 301                                  drd___builtin_new,
 302                                  drd___builtin_vec_new,
 303                                  drd_memalign,
 304                                  drd_calloc,
 305                                  drd_free,
 306                                  drd___builtin_delete,
 307                                  drd___builtin_vec_delete,
 308                                  drd_realloc,
 309                                  drd_malloc_usable_size,
 310                                  0);
 311 }
 312
 313 Bool DRD_(heap_addrinfo)(Addr const a,
 314                          Addr* const data,
 315                          SizeT* const size,
 316                          ExeContext** const where)
 317 {
 318    DRD_Chunk* mc;
 319
 320    tl_assert(data);
 321    tl_assert(size);
 322    tl_assert(where);
 323
 324    VG_(HT_ResetIter)(s_malloc_list);
 325    while ((mc = VG_(HT_Next)(s_malloc_list)))
 326    {
 327       if (mc->data <= a && a < mc->data + mc->size)
 328       {
 329          *data  = mc->data;
 330          *size  = mc->size;
 331          *where = mc->where;
 332          return True;
 333       }
 334    }
 335    return False;
 336 }
 337
 338 /*------------------------------------------------------------*/
 339 /*--- Statistics printing                                  ---*/
 340 /*------------------------------------------------------------*/
 341
 342 void DRD_(print_malloc_stats)(void)
 343 {
 344    DRD_Chunk* mc;
 345    SizeT     nblocks = 0;
 346    SizeT     nbytes  = 0;
 347
 348    if (VG_(clo_verbosity) == 0)
 349       return;
 350    if (VG_(clo_xml))
 351       return;
 352
 353    /* Count memory still in use. */
 354    VG_(HT_ResetIter)(s_malloc_list);
 355    while ((mc = VG_(HT_Next)(s_malloc_list)))
 356    {
 357       nblocks++;
 358       nbytes += mc->size;
 359    }
 360
 361    VG_(message)(Vg_DebugMsg,
 362                 "malloc/free: in use at exit: %lu bytes in %lu blocks.\n",
 363                 nbytes, nblocks);
 364    VG_(message)(Vg_DebugMsg,
 365                 "malloc/free: %lu allocs, %lu frees, %lu bytes allocated.\n",
 366                 s_cmalloc_n_mallocs,
 367                 s_cmalloc_n_frees, s_cmalloc_bs_mallocd);
 368    if (VG_(clo_verbosity) > 1)
 369       VG_(message)(Vg_DebugMsg, " \n");
 370 }
 371
 372 /*--------------------------------------------------------------------*/
 373 /*--- end                                                          ---*/
 374 /*--------------------------------------------------------------------*/