src/gallium/auxiliary/util/p_debug_mem.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /**
  29  * @file
  30  * Memory debugging.
  31  *
  32  * @author José Fonseca <jrfonseca@tungstengraphics.com>
  33  */
  34
  35 #include "pipe/p_config.h"
  36
  37 #if defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
  38 #include <windows.h>
  39 #include <winddi.h>
  40 #elif defined(PIPE_SUBSYSTEM_WINDOWS_MINIPORT)
  41 #include <wdm.h>
  42 #else
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #endif
  46
  47 #include "pipe/p_debug.h"
  48 #include "util/u_double_list.h"
  49
  50
  51 #define DEBUG_MEMORY_MAGIC 0x6e34090aU
  52
  53
  54 #if defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) && !defined(WINCE)
  55 #define real_malloc(_size) EngAllocMem(0, _size, 'D3AG')
  56 #define real_free(_ptr) EngFreeMem(_ptr)
  57 #elif defined(PIPE_SUBSYSTEM_WINDOWS_MINIPORT)
  58 #define real_malloc(_size) ExAllocatePool(0, _size)
  59 #define real_free(_ptr) ExFreePool(_ptr)
  60 #else
  61 #define real_malloc(_size) malloc(_size)
  62 #define real_free(_ptr) free(_ptr)
  63 #endif
  64
  65
  66 struct debug_memory_header
  67 {
  68    struct list_head head;
  69
  70    unsigned long no;
  71    const char *file;
  72    unsigned line;
  73    const char *function;
  74    size_t size;
  75    unsigned magic;
  76 };
  77
  78 struct debug_memory_footer
  79 {
  80    unsigned magic;
  81 };
  82
  83
  84 static struct list_head list = { &list, &list };
  85
  86 static unsigned long last_no = 0;
  87
  88
  89 static INLINE struct debug_memory_header *
  90 header_from_data(void *data)
  91 {
  92    if(data)
  93       return (struct debug_memory_header *)((char *)data - sizeof(struct debug_memory_header));
  94    else
  95       return NULL;
  96 }
  97
  98 static INLINE void *
  99 data_from_header(struct debug_memory_header *hdr)
 100 {
 101    if(hdr)
 102       return (void *)((char *)hdr + sizeof(struct debug_memory_header));
 103    else
 104       return NULL;
 105 }
 106
 107 static INLINE struct debug_memory_footer *
 108 footer_from_header(struct debug_memory_header *hdr)
 109 {
 110    if(hdr)
 111       return (struct debug_memory_footer *)((char *)hdr + sizeof(struct debug_memory_header) + hdr->size);
 112    else
 113       return NULL;
 114 }
 115
 116
 117 void *
 118 debug_malloc(const char *file, unsigned line, const char *function,
 119              size_t size)
 120 {
 121    struct debug_memory_header *hdr;
 122    struct debug_memory_footer *ftr;
 123
 124    hdr = real_malloc(sizeof(*hdr) + size + sizeof(*ftr));
 125    if(!hdr)
 126       return NULL;
 127
 128    hdr->no = last_no++;
 129    hdr->file = file;
 130    hdr->line = line;
 131    hdr->function = function;
 132    hdr->size = size;
 133    hdr->magic = DEBUG_MEMORY_MAGIC;
 134
 135    ftr = footer_from_header(hdr);
 136    ftr->magic = DEBUG_MEMORY_MAGIC;
 137
 138    LIST_ADDTAIL(&hdr->head, &list);
 139
 140    return data_from_header(hdr);
 141 }
 142
 143 void
 144 debug_free(const char *file, unsigned line, const char *function,
 145            void *ptr)
 146 {
 147    struct debug_memory_header *hdr;
 148    struct debug_memory_footer *ftr;
 149
 150    if(!ptr)
 151       return;
 152
 153    hdr = header_from_data(ptr);
 154    if(hdr->magic != DEBUG_MEMORY_MAGIC) {
 155       debug_printf("%s:%u:%s: freeing bad or corrupted memory %p\n",
 156                    file, line, function,
 157                    ptr);
 158       debug_assert(0);
 159       return;
 160    }
 161
 162    ftr = footer_from_header(hdr);
 163    if(ftr->magic != DEBUG_MEMORY_MAGIC) {
 164       debug_printf("%s:%u:%s: buffer overflow %p\n",
 165                    hdr->file, hdr->line, hdr->function,
 166                    ptr);
 167       debug_assert(0);
 168    }
 169
 170    LIST_DEL(&hdr->head);
 171    hdr->magic = 0;
 172    ftr->magic = 0;
 173
 174    real_free(hdr);
 175 }
 176
 177 void *
 178 debug_calloc(const char *file, unsigned line, const char *function,
 179              size_t count, size_t size )
 180 {
 181    void *ptr = debug_malloc( file, line, function, count * size );
 182    if( ptr )
 183       memset( ptr, 0, count * size );
 184    return ptr;
 185 }
 186
 187 void *
 188 debug_realloc(const char *file, unsigned line, const char *function,
 189               void *old_ptr, size_t old_size, size_t new_size )
 190 {
 191    struct debug_memory_header *old_hdr, *new_hdr;
 192    struct debug_memory_footer *old_ftr, *new_ftr;
 193    void *new_ptr;
 194
 195    if(!old_ptr)
 196       return debug_malloc( file, line, function, new_size );
 197
 198    if(!new_size) {
 199       debug_free( file, line, function, old_ptr );
 200       return NULL;
 201    }
 202
 203    old_hdr = header_from_data(old_ptr);
 204    if(old_hdr->magic != DEBUG_MEMORY_MAGIC) {
 205       debug_printf("%s:%u:%s: reallocating bad or corrupted memory %p\n",
 206                    file, line, function,
 207                    old_ptr);
 208       debug_assert(0);
 209       return NULL;
 210    }
 211
 212    old_ftr = footer_from_header(old_hdr);
 213    if(old_ftr->magic != DEBUG_MEMORY_MAGIC) {
 214       debug_printf("%s:%u:%s: buffer overflow %p\n",
 215                    old_hdr->file, old_hdr->line, old_hdr->function,
 216                    old_ptr);
 217       debug_assert(0);
 218    }
 219
 220    /* alloc new */
 221    new_hdr = real_malloc(sizeof(*new_hdr) + new_size + sizeof(*new_ftr));
 222    if(!new_hdr)
 223       return NULL;
 224    new_hdr->no = old_hdr->no;
 225    new_hdr->file = old_hdr->file;
 226    new_hdr->line = old_hdr->line;
 227    new_hdr->function = old_hdr->function;
 228    new_hdr->size = new_size;
 229    new_hdr->magic = DEBUG_MEMORY_MAGIC;
 230
 231    new_ftr = footer_from_header(new_hdr);
 232    new_ftr->magic = DEBUG_MEMORY_MAGIC;
 233
 234    LIST_REPLACE(&old_hdr->head, &new_hdr->head);
 235
 236    /* copy data */
 237    new_ptr = data_from_header(new_hdr);
 238    memcpy( new_ptr, old_ptr, old_size < new_size ? old_size : new_size );
 239
 240    /* free old */
 241    old_hdr->magic = 0;
 242    old_ftr->magic = 0;
 243    real_free(old_hdr);
 244
 245    return new_ptr;
 246 }
 247
 248 unsigned long
 249 debug_memory_begin(void)
 250 {
 251    return last_no;
 252 }
 253
 254 void
 255 debug_memory_end(unsigned long start_no)
 256 {
 257    size_t total_size = 0;
 258    struct list_head *entry;
 259
 260    entry = list.prev;
 261    for (; entry != &list; entry = entry->prev) {
 262       struct debug_memory_header *hdr;
 263       void *ptr;
 264       hdr = LIST_ENTRY(struct debug_memory_header, entry, head);
 265       ptr = data_from_header(hdr);
 266       if((start_no <= hdr->no && hdr->no < last_no) ||
 267          (last_no < start_no && (hdr->no < last_no || start_no <= hdr->no))) {
 268          debug_printf("%s:%u:%s: %u bytes at %p not freed\n",
 269                       hdr->file, hdr->line, hdr->function,
 270                       hdr->size, ptr);
 271          total_size += hdr->size;
 272       }
 273    }
 274    if(total_size) {
 275       debug_printf("Total of %u KB of system memory apparently leaked\n",
 276                    (total_size + 1023)/1024);
 277    }
 278 }