vpx_mem/vpx_mem_tracker.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11
  12 /*
  13   vpx_mem_tracker.c
  14
  15   jwz 2003-09-30:
  16    Stores a list of addreses, their size, and file and line they came from.
  17    All exposed lib functions are prefaced by vpx_ and allow the global list
  18    to be thread safe.
  19    Current supported platforms are:
  20     Linux, Win32, win_ce and vx_works
  21    Further support can be added by defining the platform specific mutex
  22    in the memory_tracker struct as well as calls to create/destroy/lock/unlock
  23    the mutex in vpx_memory_tracker_init/Destroy and memory_tracker_lock_mutex/unlock_mutex
  24 */
  25 #include "vpx_config.h"
  26
  27 #if defined(__uClinux__)
  28 # include <lddk.h>
  29 #endif
  30
  31 #if HAVE_PTHREAD_H
  32 # include <pthread.h>
  33 #elif defined(WIN32) || defined(_WIN32_WCE)
  34 # define WIN32_LEAN_AND_MEAN
  35 # include <windows.h>
  36 # include <winbase.h>
  37 #elif defined(VXWORKS)
  38 # include <sem_lib.h>
  39 #endif
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h> //VXWORKS doesn't have a malloc/memory.h file,
  44 //this should pull in malloc,free,etc.
  45 #include <stdarg.h>
  46
  47 #include "include/vpx_mem_tracker.h"
  48
  49 #undef vpx_malloc   //undefine any vpx_mem macros that may affect calls to
  50 #undef vpx_free     //memory functions in this file
  51 #undef vpx_memcpy
  52 #undef vpx_memset
  53
  54
  55 #ifndef USE_GLOBAL_FUNCTION_POINTERS
  56 # define USE_GLOBAL_FUNCTION_POINTERS   0  //use function pointers instead of compiled functions.
  57 #endif
  58
  59 #if USE_GLOBAL_FUNCTION_POINTERS
  60 static mem_track_malloc_func g_malloc   = malloc;
  61 static mem_track_calloc_func g_calloc   = calloc;
  62 static mem_track_realloc_func g_realloc = realloc;
  63 static mem_track_free_func g_free       = free;
  64 static mem_track_memcpy_func g_memcpy   = memcpy;
  65 static mem_track_memset_func g_memset   = memset;
  66 static mem_track_memmove_func g_memmove = memmove;
  67 # define MEM_TRACK_MALLOC g_malloc
  68 # define MEM_TRACK_FREE   g_free
  69 # define MEM_TRACK_MEMCPY g_memcpy
  70 # define MEM_TRACK_MEMSET g_memset
  71 #else
  72 # define MEM_TRACK_MALLOC vpx_malloc
  73 # define MEM_TRACK_FREE   vpx_free
  74 # define MEM_TRACK_MEMCPY vpx_memcpy
  75 # define MEM_TRACK_MEMSET vpx_memset
  76 #endif // USE_GLOBAL_FUNCTION_POINTERS
  77
  78 /* prototypes for internal library functions */
  79 static void memtrack_log(const char *fmt, ...);
  80 static void memory_tracker_dump();
  81 static void memory_tracker_check_integrity(char *file, unsigned int line);
  82 static void memory_tracker_add(size_t addr, unsigned int size,
  83                                char *file, unsigned int line,
  84                                int padded);
  85 static int memory_tracker_remove(size_t addr);
  86 static struct mem_block *memory_tracker_find(size_t addr);
  87
  88 #if defined(NO_MUTEX)
  89 # define memory_tracker_lock_mutex() (!g_b_mem_tracker_inited)
  90 # define memory_tracker_unlock_mutex()
  91 #else
  92 static int memory_tracker_lock_mutex();
  93 static int memory_tracker_unlock_mutex();
  94 #endif
  95
  96 #ifndef VPX_NO_GLOBALS
  97 struct memory_tracker
  98 {
  99     struct mem_block *head,
 100             * tail;
 101     int len,
 102         totalsize;
 103     unsigned int current_allocated,
 104              max_allocated;
 105
 106 #if HAVE_PTHREAD_H
 107     pthread_mutex_t mutex;
 108 #elif defined(WIN32) || defined(_WIN32_WCE)
 109     HANDLE mutex;
 110 #elif defined(VXWORKS)
 111     SEM_ID mutex;
 112 #elif defined(NO_MUTEX)
 113 #else
 114 #error "No mutex type defined for this platform!"
 115 #endif
 116
 117     int padding_size,
 118         pad_value;
 119 };
 120
 121 static struct memory_tracker memtrack;   //our global memory allocation list
 122 static int g_b_mem_tracker_inited = 0;     //indicates whether the global list has
 123 //been initialized (1:yes/0:no)
 124 static struct
 125 {
 126     FILE *file;
 127     int type;
 128     void (*func)(void *userdata, const char *fmt, va_list args);
 129     void *userdata;
 130 } g_logging = {NULL, 0, NULL, NULL};
 131 #else
 132 # include "vpx_global_handling.h"
 133 #define g_b_mem_tracker_inited vpxglobalm(vpxmem,g_b_mem_tracker_inited)
 134 #define g_logging vpxglobalm(vpxmem,g_logging)
 135 #define memtrack vpxglobalm(vpxmem,memtrack)
 136 #endif // #ifndef VPX_NO_GLOBALS
 137
 138 extern void *vpx_malloc(size_t size);
 139 extern void vpx_free(void *memblk);
 140 extern void *vpx_memcpy(void *dest, const void *src, size_t length);
 141 extern void *vpx_memset(void *dest, int val, size_t length);
 142
 143 /*
 144  *
 145  * Exposed library functions
 146  *
 147 */
 148
 149 /*
 150     vpx_memory_tracker_init(int padding_size, int pad_value)
 151       padding_size - the size of the padding before and after each mem addr.
 152                      Values > 0 indicate that integrity checks can be performed
 153                      by inspecting these areas.
 154       pad_value - the initial value within the padding area before and after
 155                   each mem addr.
 156
 157     Initializes global memory tracker structure
 158     Allocates the head of the list
 159 */
 160 int vpx_memory_tracker_init(int padding_size, int pad_value)
 161 {
 162     if (!g_b_mem_tracker_inited)
 163     {
 164         if ((memtrack.head = (struct mem_block *)
 165                              MEM_TRACK_MALLOC(sizeof(struct mem_block))))
 166         {
 167             int ret;
 168
 169             MEM_TRACK_MEMSET(memtrack.head, 0, sizeof(struct mem_block));
 170
 171             memtrack.tail = memtrack.head;
 172
 173             memtrack.current_allocated = 0;
 174             memtrack.max_allocated     = 0;
 175
 176             memtrack.padding_size = padding_size;
 177             memtrack.pad_value    = pad_value;
 178
 179 #if HAVE_PTHREAD_H
 180             ret = pthread_mutex_init(&memtrack.mutex,
 181                                      NULL);            /*mutex attributes (NULL=default)*/
 182 #elif defined(WIN32) || defined(_WIN32_WCE)
 183             memtrack.mutex = CreateMutex(NULL,   /*security attributes*/
 184                                           FALSE,  /*we don't want initial ownership*/
 185                                           NULL);  /*mutex name*/
 186             ret = !memtrack.mutex;
 187 #elif defined(VXWORKS)
 188             memtrack.mutex = sem_bcreate(SEM_Q_FIFO, /*SEM_Q_FIFO non-priority based mutex*/
 189                                          SEM_FULL);  /*SEM_FULL initial state is unlocked*/
 190             ret = !memtrack.mutex;
 191 #elif defined(NO_MUTEX)
 192             ret = 0;
 193 #endif
 194
 195             if (ret)
 196             {
 197                 memtrack_log("vpx_memory_tracker_init: Error creating mutex!\n");
 198
 199                 MEM_TRACK_FREE(memtrack.head);
 200                 memtrack.head = NULL;
 201             }
 202             else
 203             {
 204                 memtrack_log("Memory Tracker init'd, v."vpx_mem_tracker_version" pad_size:%d pad_val:0x%x %d\n"
 205                              , padding_size
 206                              , pad_value
 207                              , pad_value);
 208                 g_b_mem_tracker_inited = 1;
 209             }
 210         }
 211     }
 212
 213     return g_b_mem_tracker_inited;
 214 }
 215
 216 /*
 217     vpx_memory_tracker_destroy()
 218     If our global struct was initialized zeros out all its members,
 219     frees memory and destroys it's mutex
 220 */
 221 void vpx_memory_tracker_destroy()
 222 {
 223     if (!memory_tracker_lock_mutex())
 224     {
 225         struct mem_block *p  = memtrack.head,
 226                                   * p2 = memtrack.head;
 227
 228         memory_tracker_dump();
 229
 230         while (p)
 231     {
 232             p2 = p;
 233             p  = p->next;
 234
 235             MEM_TRACK_FREE(p2);
 236         }
 237
 238         memtrack.head              = NULL;
 239         memtrack.tail              = NULL;
 240         memtrack.len               = 0;
 241         memtrack.current_allocated = 0;
 242         memtrack.max_allocated     = 0;
 243
 244         if (!g_logging.type && g_logging.file && g_logging.file != stderr)
 245         {
 246             fclose(g_logging.file);
 247             g_logging.file = NULL;
 248         }
 249
 250         memory_tracker_unlock_mutex();
 251
 252         g_b_mem_tracker_inited = 0;
 253     }
 254 }
 255
 256 /*
 257     vpx_memory_tracker_add(size_t addr, unsigned int size,
 258                          char * file, unsigned int line)
 259       addr - memory address to be added to list
 260       size - size of addr
 261       file - the file addr was referenced from
 262       line - the line in file addr was referenced from
 263     Adds memory address addr, it's size, file and line it came from
 264     to the global list via the thread safe internal library function
 265 */
 266 void vpx_memory_tracker_add(size_t addr, unsigned int size,
 267                             char *file, unsigned int line,
 268                             int padded)
 269 {
 270     memory_tracker_add(addr, size, file, line, padded);
 271 }
 272
 273 /*
 274     vpx_memory_tracker_remove(size_t addr)
 275       addr - memory address to be removed from list
 276     Removes addr from the global list via the thread safe
 277     internal remove function
 278     Return:
 279       Same as described for memory_tracker_remove
 280 */
 281 int vpx_memory_tracker_remove(size_t addr)
 282 {
 283     return memory_tracker_remove(addr);
 284 }
 285
 286 /*
 287     vpx_memory_tracker_find(size_t addr)
 288       addr - address to be found in list
 289     Return:
 290         If found, pointer to the memory block that matches addr
 291         NULL otherwise
 292 */
 293 struct mem_block *vpx_memory_tracker_find(size_t addr)
 294 {
 295     struct mem_block *p = NULL;
 296
 297     if (!memory_tracker_lock_mutex())
 298     {
 299         p = memory_tracker_find(addr);
 300         memory_tracker_unlock_mutex();
 301     }
 302
 303     return p;
 304 }
 305
 306 /*
 307     vpx_memory_tracker_dump()
 308     Locks the memory tracker's mutex and calls the internal
 309     library function to dump the current contents of the
 310     global memory allocation list
 311 */
 312 void vpx_memory_tracker_dump()
 313 {
 314     if (!memory_tracker_lock_mutex())
 315     {
 316         memory_tracker_dump();
 317         memory_tracker_unlock_mutex();
 318     }
 319 }
 320
 321 /*
 322     vpx_memory_tracker_check_integrity(char* file, unsigned int line)
 323       file - The file name where the check was placed
 324       line - The line in file where the check was placed
 325     Locks the memory tracker's mutex and calls the internal
 326     integrity check function to inspect every address in the global
 327     memory allocation list
 328 */
 329 void vpx_memory_tracker_check_integrity(char *file, unsigned int line)
 330 {
 331     if (!memory_tracker_lock_mutex())
 332     {
 333         memory_tracker_check_integrity(file, line);
 334         memory_tracker_unlock_mutex();
 335     }
 336 }
 337
 338 /*
 339     vpx_memory_tracker_set_log_type
 340     Sets the logging type for the memory tracker. Based on the value it will
 341     direct its output to the appropriate place.
 342     Return:
 343       0: on success
 344       -1: if the logging type could not be set, because the value was invalid
 345           or because a file could not be opened
 346 */
 347 int vpx_memory_tracker_set_log_type(int type, char *option)
 348 {
 349     int ret = -1;
 350
 351     switch (type)
 352     {
 353     case 0:
 354         g_logging.type = 0;
 355
 356         if (!option)
 357         {
 358             g_logging.file = stderr;
 359             ret = 0;
 360         }
 361         else
 362         {
 363             if ((g_logging.file = fopen((char *)option, "w")))
 364                 ret = 0;
 365         }
 366
 367         break;
 368 #if defined(WIN32) && !defined(_WIN32_WCE)
 369     case 1:
 370         g_logging.type = type;
 371         ret = 0;
 372         break;
 373 #endif
 374     default:
 375         break;
 376     }
 377
 378     //output the version to the new logging destination
 379     if (!ret)
 380         memtrack_log("Memory Tracker logging initialized, "
 381                      "Memory Tracker v."vpx_mem_tracker_version"\n");
 382
 383     return ret;
 384 }
 385
 386 /*
 387     vpx_memory_tracker_set_log_func
 388     Sets a logging function to be used by the memory tracker.
 389     Return:
 390       0: on success
 391       -1: if the logging type could not be set because logfunc was NULL
 392 */
 393 int vpx_memory_tracker_set_log_func(void *userdata,
 394                                     void(*logfunc)(void *userdata,
 395                                             const char *fmt, va_list args))
 396 {
 397     int ret = -1;
 398
 399     if (logfunc)
 400     {
 401         g_logging.type     = -1;
 402         g_logging.userdata = userdata;
 403         g_logging.func     = logfunc;
 404         ret = 0;
 405     }
 406
 407     //output the version to the new logging destination
 408     if (!ret)
 409         memtrack_log("Memory Tracker logging initialized, "
 410                      "Memory Tracker v."vpx_mem_tracker_version"\n");
 411
 412     return ret;
 413 }
 414
 415 /*
 416  *
 417  * END - Exposed library functions
 418  *
 419 */
 420
 421
 422 /*
 423  *
 424  * Internal library functions
 425  *
 426 */
 427
 428 static void memtrack_log(const char *fmt, ...)
 429 {
 430     va_list list;
 431
 432     va_start(list, fmt);
 433
 434     switch (g_logging.type)
 435     {
 436     case -1:
 437
 438         if (g_logging.func)
 439             g_logging.func(g_logging.userdata, fmt, list);
 440
 441         break;
 442     case 0:
 443
 444         if (g_logging.file)
 445         {
 446             vfprintf(g_logging.file, fmt, list);
 447             fflush(g_logging.file);
 448         }
 449
 450         break;
 451 #if defined(WIN32) && !defined(_WIN32_WCE)
 452     case 1:
 453     {
 454         char temp[1024];
 455         _vsnprintf(temp, sizeof(temp) / sizeof(char) - 1, fmt, list);
 456         OutputDebugString(temp);
 457     }
 458     break;
 459 #endif
 460     default:
 461         break;
 462     }
 463
 464     va_end(list);
 465 }
 466
 467 /*
 468     memory_tracker_dump()
 469     Dumps the current contents of the global memory allocation list
 470 */
 471 static void memory_tracker_dump()
 472 {
 473     int i = 0;
 474     struct mem_block *p = (memtrack.head ? memtrack.head->next : NULL);
 475
 476     memtrack_log("\n_currently Allocated= %d; Max allocated= %d\n",
 477                  memtrack.current_allocated, memtrack.max_allocated);
 478
 479     while (p)
 480     {
 481 #if defined(WIN32) && !defined(_WIN32_WCE)
 482
 483         /*when using outputdebugstring, output filenames so they
 484           can be clicked to be opened in visual studio*/
 485         if (g_logging.type == 1)
 486             memtrack_log("memblocks[%d].addr= 0x%.8x, memblocks[%d].size= %d, file:\n"
 487                          "  %s(%d):\n", i,
 488                          p->addr, i, p->size,
 489                          p->file, p->line);
 490         else
 491 #endif
 492             memtrack_log("memblocks[%d].addr= 0x%.8x, memblocks[%d].size= %d, file: %s, line: %d\n", i,
 493                          p->addr, i, p->size,
 494                          p->file, p->line);
 495
 496         p = p->next;
 497         ++i;
 498     }
 499
 500     memtrack_log("\n");
 501 }
 502
 503 /*
 504     memory_tracker_check_integrity(char* file, unsigned int file)
 505       file - the file name where the check was placed
 506       line - the line in file where the check was placed
 507     If a padding_size was supplied to vpx_memory_tracker_init()
 508     this function will check ea. addr in the list verifying that
 509     addr-padding_size and addr+padding_size is filled with pad_value
 510 */
 511 static void memory_tracker_check_integrity(char *file, unsigned int line)
 512 {
 513     if (memtrack.padding_size)
 514     {
 515         int i,
 516             index = 0;
 517         unsigned char *p_show_me,
 518                  * p_show_me2;
 519         unsigned int tempme = memtrack.pad_value,
 520                      dead1,
 521                      dead2;
 522         unsigned char *x_bounds;
 523         struct mem_block *p = memtrack.head->next;
 524
 525         while (p)
 526         {
 527             //x_bounds = (unsigned char*)p->addr;
 528             //back up VPX_BYTE_ALIGNMENT
 529             //x_bounds -= memtrack.padding_size;
 530
 531             if (p->padded)   // can the bounds be checked?
 532             {
 533                 /*yes, move to the address that was actually allocated
 534                 by the vpx_* calls*/
 535                 x_bounds = (unsigned char *)(((size_t *)p->addr)[-1]);
 536
 537                 for (i = 0; i < memtrack.padding_size; i += sizeof(unsigned int))
 538                 {
 539                     p_show_me = (x_bounds + i);
 540                     p_show_me2 = (unsigned char *)(p->addr + p->size + i);
 541
 542                     MEM_TRACK_MEMCPY(&dead1, p_show_me, sizeof(unsigned int));
 543                     MEM_TRACK_MEMCPY(&dead2, p_show_me2, sizeof(unsigned int));
 544
 545                     if ((dead1 != tempme) || (dead2 != tempme))
 546                     {
 547                         memtrack_log("\n[vpx_mem integrity check failed]:\n"
 548                                      "    index[%d,%d] {%s:%d} addr=0x%x, size=%d,"
 549                                      " file: %s, line: %d c0:0x%x c1:0x%x\n",
 550                                      index, i, file, line, p->addr, p->size, p->file,
 551                                      p->line, dead1, dead2);
 552                     }
 553                 }
 554             }
 555
 556             ++index;
 557             p = p->next;
 558         }
 559     }
 560 }
 561
 562 /*
 563     memory_tracker_add(size_t addr, unsigned int size,
 564                      char * file, unsigned int line)
 565     Adds an address (addr), it's size, file and line number to our list.
 566     Adjusts the total bytes allocated and max bytes allocated if necessary.
 567     If memory cannot be allocated the list will be destroyed.
 568 */
 569 void memory_tracker_add(size_t addr, unsigned int size,
 570                         char *file, unsigned int line,
 571                         int padded)
 572 {
 573     if (!memory_tracker_lock_mutex())
 574     {
 575         struct mem_block *p;
 576
 577         p = MEM_TRACK_MALLOC(sizeof(struct mem_block));
 578
 579         if (p)
 580         {
 581             p->prev       = memtrack.tail;
 582             p->prev->next = p;
 583             p->addr       = addr;
 584             p->size       = size;
 585             p->line       = line;
 586             p->file       = file;
 587             p->padded     = padded;
 588             p->next       = NULL;
 589
 590             memtrack.tail = p;
 591
 592             memtrack.current_allocated += size;
 593
 594             if (memtrack.current_allocated > memtrack.max_allocated)
 595                 memtrack.max_allocated = memtrack.current_allocated;
 596
 597             //memtrack_log("memory_tracker_add: added addr=0x%.8x\n", addr);
 598
 599             memory_tracker_unlock_mutex();
 600         }
 601         else
 602         {
 603             memtrack_log("memory_tracker_add: error allocating memory!\n");
 604             memory_tracker_unlock_mutex();
 605             vpx_memory_tracker_destroy();
 606         }
 607     }
 608 }
 609
 610 /*
 611     memory_tracker_remove(size_t addr)
 612     Removes an address and its corresponding size (if they exist)
 613     from the memory tracker list and adjusts the current number
 614     of bytes allocated.
 615     Return:
 616       0: on success
 617       -1: if the mutex could not be locked
 618       -2: if the addr was not found in the list
 619 */
 620 int memory_tracker_remove(size_t addr)
 621 {
 622     int ret = -1;
 623
 624     if (!memory_tracker_lock_mutex())
 625     {
 626         struct mem_block *p;
 627
 628         if ((p = memory_tracker_find(addr)))
 629         {
 630             memtrack.current_allocated -= p->size;
 631
 632             p->prev->next = p->next;
 633
 634             if (p->next)
 635                 p->next->prev = p->prev;
 636             else
 637                 memtrack.tail = p->prev;
 638
 639             ret = 0;
 640             MEM_TRACK_FREE(p);
 641         }
 642         else
 643         {
 644             if (addr)
 645                 memtrack_log("memory_tracker_remove(): addr not found in list,"
 646                              " 0x%.8x\n", addr);
 647
 648             ret = -2;
 649         }
 650
 651         memory_tracker_unlock_mutex();
 652     }
 653
 654     return ret;
 655 }
 656
 657 /*
 658     memory_tracker_find(size_t addr)
 659     Finds an address in our addrs list
 660     NOTE: the mutex MUST be locked in the other internal
 661           functions before calling this one. This avoids
 662           the need for repeated locking and unlocking as in Remove
 663     Returns: pointer to the mem block if found, NULL otherwise
 664 */
 665 static struct mem_block *memory_tracker_find(size_t addr)
 666 {
 667     struct mem_block *p = NULL;
 668
 669     if (memtrack.head)
 670     {
 671         p = memtrack.head->next;
 672
 673         while (p && (p->addr != addr))
 674             p = p->next;
 675     }
 676
 677     return p;
 678 }
 679
 680
 681 #if !defined(NO_MUTEX)
 682 /*
 683     memory_tracker_lock_mutex()
 684     Locks the memory tracker mutex with a platform specific call
 685     Returns:
 686         0: Success
 687        <0: Failure, either the mutex was not initialized
 688            or the call to lock the mutex failed
 689 */
 690 static int memory_tracker_lock_mutex()
 691 {
 692     int ret = -1;
 693
 694     if (g_b_mem_tracker_inited)
 695     {
 696
 697 #if HAVE_PTHREAD_H
 698         ret = pthread_mutex_lock(&memtrack.mutex);
 699 #elif defined(WIN32) || defined(_WIN32_WCE)
 700         ret = WaitForSingleObject(memtrack.mutex, INFINITE);
 701 #elif defined(VXWORKS)
 702         ret = sem_take(memtrack.mutex, WAIT_FOREVER);
 703 #endif
 704
 705         if (ret)
 706         {
 707             memtrack_log("memory_tracker_lock_mutex: mutex lock failed\n");
 708         }
 709     }
 710
 711     return ret;
 712 }
 713
 714 /*
 715     memory_tracker_unlock_mutex()
 716     Unlocks the memory tracker mutex with a platform specific call
 717     Returns:
 718         0: Success
 719        <0: Failure, either the mutex was not initialized
 720            or the call to unlock the mutex failed
 721 */
 722 static int memory_tracker_unlock_mutex()
 723 {
 724     int ret = -1;
 725
 726     if (g_b_mem_tracker_inited)
 727     {
 728
 729 #if HAVE_PTHREAD_H
 730         ret = pthread_mutex_unlock(&memtrack.mutex);
 731 #elif defined(WIN32) || defined(_WIN32_WCE)
 732         ret = !ReleaseMutex(memtrack.mutex);
 733 #elif defined(VXWORKS)
 734         ret = sem_give(memtrack.mutex);
 735 #endif
 736
 737         if (ret)
 738         {
 739             memtrack_log("memory_tracker_unlock_mutex: mutex unlock failed\n");
 740         }
 741     }
 742
 743     return ret;
 744 }
 745 #endif
 746
 747 /*
 748     vpx_memory_tracker_set_functions
 749
 750     Sets the function pointers for the standard library functions.
 751
 752     Return:
 753       0: on success
 754       -1: if the use global function pointers is not set.
 755 */
 756 int vpx_memory_tracker_set_functions(mem_track_malloc_func g_malloc_l
 757                                      , mem_track_calloc_func g_calloc_l
 758                                      , mem_track_realloc_func g_realloc_l
 759                                      , mem_track_free_func g_free_l
 760                                      , mem_track_memcpy_func g_memcpy_l
 761                                      , mem_track_memset_func g_memset_l
 762                                      , mem_track_memmove_func g_memmove_l)
 763 {
 764 #if USE_GLOBAL_FUNCTION_POINTERS
 765
 766     if (g_malloc_l)
 767         g_malloc = g_malloc_l;
 768
 769     if (g_calloc_l)
 770         g_calloc = g_calloc_l;
 771
 772     if (g_realloc_l)
 773         g_realloc = g_realloc_l;
 774
 775     if (g_free_l)
 776         g_free = g_free_l;
 777
 778     if (g_memcpy_l)
 779         g_memcpy = g_memcpy_l;
 780
 781     if (g_memset_l)
 782         g_memset = g_memset_l;
 783
 784     if (g_memmove_l)
 785         g_memmove = g_memmove_l;
 786
 787     return 0;
 788 #else
 789     (void)g_malloc_l;
 790     (void)g_calloc_l;
 791     (void)g_realloc_l;
 792     (void)g_free_l;
 793     (void)g_memcpy_l;
 794     (void)g_memset_l;
 795     (void)g_memmove_l;
 796     return -1;
 797 #endif
 798 }