gwmem-check.c File Reference

#include "gw-config.h"
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <execinfo.h>
#include "gwlib.h"

Include dependency graph for gwmem-check.c:

Go to the source code of this file.

Data Structures
struct	location
struct	area
Defines
#define	NEW_AREA_PATTERN   0xcafebabe
#define	FREE_AREA_PATTERN   0xdeadbeef
#define	START_MARK_PATTERN   0xdadaface
#define	END_MARK_PATTERN   0xadadafec
#define	MAX_DUMP   16
#define	MARKER_SIZE   16
#define	MAX_TAB_SIZE   (100*1024*1024L)
#define	MAX_ALLOCATIONS   ((long) (MAX_TAB_SIZE/sizeof(struct area)))
#define	FREE_RING_SIZE   1024
Functions
void	lock (void)
void	unlock (void)
unsigned long	round_pow2 (unsigned long num)
void	fill (unsigned char *p, size_t bytes, long pattern)
int	untouched (unsigned char *p, size_t bytes, long pattern)
void	endmark (unsigned char *p, size_t size)
void	startmark (unsigned char *p, long number)
long	check_startmark (unsigned char *p)
int	check_endmark (unsigned char *p, size_t size)
int	check_marks (struct area *area, long index)
void	dump_area (struct area *area)
area *	find_area (unsigned char *p)
void	change_total_size (long change)
area *	record_allocation (unsigned char *p, size_t size, const char *filename, long lineno, const char *function)
void	remove_allocation (struct area *area)
void	drop_from_free_ring (long index)
void	put_on_free_ring (struct area *area)
void	free_area (struct area *area)
void	gw_check_init_mem (int slow_flag)
void	gw_check_shutdown (void)
void *	gw_check_malloc (size_t size, const char *filename, long lineno, const char *function)
void *	gw_check_realloc (void *p, size_t size, const char *filename, long lineno, const char *function)
void	gw_check_free (void *p, const char *filename, long lineno, const char *function)
char *	gw_check_strdup (const char *str, const char *filename, long lineno, const char *function)
void *	gw_check_claim_area (void *p, const char *filename, long lineno, const char *function)
void	gw_check_check_leaks (void)
int	gw_check_is_allocated (void *p)
long	gw_check_area_size (void *p)
Variables
int	initialized = 0
int	slow = 0
Mutex	gwmem_lock
area	allocated [MAX_ALLOCATIONS]
area	free_ring [FREE_RING_SIZE]
long	num_allocations
long	free_ring_start
long	free_ring_len
long	highest_num_allocations
long	highest_total_size
long	total_size

---

Define Documentation

#define END_MARK_PATTERN   0xadadafec

Definition at line 121 of file gwmem-check.c. Referenced by check_endmark(), and endmark().

#define FREE_AREA_PATTERN   0xdeadbeef

Definition at line 114 of file gwmem-check.c. Referenced by drop_from_free_ring(), find_area(), and free_area().

#define FREE_RING_SIZE   1024

Definition at line 174 of file gwmem-check.c.

#define MARKER_SIZE   16

Definition at line 163 of file gwmem-check.c. Referenced by check_endmark(), check_startmark(), drop_from_free_ring(), endmark(), gw_check_malloc(), gw_check_realloc(), and startmark().

#define MAX_ALLOCATIONS   ((long) (MAX_TAB_SIZE/sizeof(struct area)))

Definition at line 167 of file gwmem-check.c.

#define MAX_DUMP   16

Definition at line 124 of file gwmem-check.c. Referenced by dump_area().

#define MAX_TAB_SIZE   (100*1024*1024L)

Definition at line 166 of file gwmem-check.c.

#define NEW_AREA_PATTERN   0xcafebabe

Definition at line 110 of file gwmem-check.c. Referenced by find_area(), gw_check_malloc(), and gw_check_realloc().

#define START_MARK_PATTERN   0xdadaface

Definition at line 118 of file gwmem-check.c. Referenced by check_startmark(), find_area(), and startmark().

---

Function Documentation

void change_total_size (  long  change  )  [static]

Definition at line 410 of file gwmem-check.c. References highest_total_size, and total_size. Referenced by gw_check_realloc(), record_allocation(), and remove_allocation(). { total_size += change; if (total_size > highest_total_size) highest_total_size = total_size; }

int check_endmark (  unsigned char *  p, size_t  size )  [static]

Definition at line 285 of file gwmem-check.c. References END_MARK_PATTERN, MARKER_SIZE, size, and untouched(). Referenced by check_marks(), and find_area(). { if (!untouched(p + size, MARKER_SIZE, END_MARK_PATTERN)) return -1; return 0; }

Here is the call graph for this function:

int check_marks (  struct area *  area, long  index )  [static]

Definition at line 292 of file gwmem-check.c. References area::area, area::area_size, check_endmark(), check_startmark(), error(), and result. Referenced by drop_from_free_ring(), gw_check_check_leaks(), and remove_allocation(). { int result = 0; if (check_startmark(area->area) != index) { error(0, "Start marker was damaged for area %ld", index); result = -1; } if (check_endmark(area->area, area->area_size) < 0) { error(0, "End marker was damaged for area %ld", index); result = -1; } return result; }

Here is the call graph for this function:

long check_startmark (  unsigned char *  p  )  [static]

Definition at line 275 of file gwmem-check.c. References MARKER_SIZE, number, START_MARK_PATTERN, and untouched(). Referenced by check_marks(), and find_area(). { long number; if (!untouched(p - MARKER_SIZE + sizeof(long), MARKER_SIZE - sizeof(long), START_MARK_PATTERN)) return -1; memcpy(&number, p - MARKER_SIZE, sizeof(number)); return number; }

Here is the call graph for this function:

void drop_from_free_ring (  long  index  )  [static]

Definition at line 461 of file gwmem-check.c. References area::area, area::area_size, check_marks(), dump_area(), error(), free, FREE_AREA_PATTERN, free_ring, MARKER_SIZE, and untouched(). Referenced by gw_check_check_leaks(), and put_on_free_ring(). { struct area *area; area = &free_ring[index]; if (check_marks(area, index) < 0 || !untouched(area->area, area->area_size, FREE_AREA_PATTERN)) { error(0, "Freed area %p has been tampered with.", area->area); dump_area(area); } free((unsigned char *)area->area - MARKER_SIZE); }

Here is the call graph for this function:

void dump_area (  struct area *  area  )  [static]

Definition at line 308 of file gwmem-check.c. References area::allocator, area::area, area::area_size, area::claimer, debug(), location::filename, area::frame_size, area::frames, free, location::function, location::lineno, MAX_DUMP, area::max_size, and area::reallocator. Referenced by drop_from_free_ring(), find_area(), and gw_check_check_leaks(). { debug("gwlib.gwmem", 0, "Area %p, size %ld, max_size %ld", area->area, (long) area->area_size, (long) area->max_size); debug("gwlib.gwmem", 0, "Allocated by %s() at %s:%ld", area->allocator.function, area->allocator.filename, area->allocator.lineno); if (area->reallocator.function) { debug("gwlib.gwmem", 0, "Re-allocated by %s() at %s:%ld", area->reallocator.function, area->reallocator.filename, area->reallocator.lineno); } if (area->claimer.function) { debug("gwlib.gwmem", 0, "Claimed by %s() at %s:%ld", area->claimer.function, area->claimer.filename, area->claimer.lineno); } if (area->area_size > 0) { size_t i; unsigned char *p; char buf[MAX_DUMP * 3 + 1]; p = area->area; buf[0] = '\0'; for (i = 0; i < area->area_size && i < MAX_DUMP; ++i) sprintf(strchr(buf, '\0'), "%02x ", p[i]); debug("gwlib.gwmem", 0, "Contents of area (first %d bytes):", MAX_DUMP); debug("gwlib.gwmem", 0, " %s", buf); } #if HAVE_BACKTRACE { size_t i; char **strings = backtrace_symbols(area->frames, area->frame_size); debug("gwlib.gwmem", 0, "Backtrace of last malloc/realloc:"); for (i = 0; i < area->frame_size; i++) { if (strings != NULL) debug("gwlib.gwmem", 0, "%s", strings[i]); else debug("gwlib.gwmem", 0, "%p", area->frames[i]); } free(strings); } #endif }

Here is the call graph for this function:

void endmark (  unsigned char *  p, size_t  size )  [inline, static]

Definition at line 254 of file gwmem-check.c. References END_MARK_PATTERN, fill(), MARKER_SIZE, and size. Referenced by gw_check_realloc(), and record_allocation(). { fill(p + size, MARKER_SIZE, END_MARK_PATTERN); }

Here is the call graph for this function:

void fill (  unsigned char *  p, size_t  bytes, long  pattern )  [static]

Definition at line 228 of file gwmem-check.c. Referenced by endmark(), free_area(), gw_check_malloc(), gw_check_realloc(), and startmark(). { while (bytes > sizeof(pattern)) { memcpy(p, &pattern, sizeof(pattern)); p += sizeof(pattern); bytes -= sizeof(pattern); } if (bytes > 0) memcpy(p, &pattern, bytes); }

struct area* find_area (  unsigned char *  p  )  [static]

Definition at line 357 of file gwmem-check.c. References allocated, area::area, area::area_size, check_endmark(), check_startmark(), dump_area(), error(), FREE_AREA_PATTERN, gw_assert, NEW_AREA_PATTERN, num_allocations, slow, and START_MARK_PATTERN. Referenced by gw_check_area_size(), gw_check_claim_area(), gw_check_free(), gw_check_is_allocated(), and gw_check_realloc(). { long index; struct area *area; long suspicious_pointer; unsigned long p_ul; gw_assert(p != NULL); p_ul = (unsigned long) p; suspicious_pointer = (sizeof(p) == sizeof(long) && (p_ul == NEW_AREA_PATTERN || p_ul == FREE_AREA_PATTERN || p_ul == START_MARK_PATTERN || p_ul == END_MARK_PATTERN)); if (slow || suspicious_pointer) { /* Extra check, which does not touch the (perhaps not allocated) * memory area. It's slow, but may help pinpoint problems that * would otherwise cause segfaults. */ for (index = 0; index < num_allocations; index++) { if (allocated[index].area == p) break; } if (index == num_allocations) { error(0, "Area %p not found in allocation table.", p); return NULL; } } index = check_startmark(p); if (index >= 0 && index < num_allocations && allocated[index].area == p) { area = &allocated[index]; if (check_endmark(p, area->area_size) < 0) { error(0, "End marker was damaged for area %p", p); dump_area(area); } return area; } error(0, "Start marker was damaged for area %p", p); for (index = 0; index < num_allocations; index++) { if (allocated[index].area == p) { area = &allocated[index]; dump_area(area); return area; } } error(0, "Could not find area information."); return NULL; }

Here is the call graph for this function:

void free_area (  struct area *  area  )  [static]

Definition at line 493 of file gwmem-check.c. References area::area, area::area_size, fill(), FREE_AREA_PATTERN, put_on_free_ring(), and remove_allocation(). Referenced by gw_check_free(), and gw_check_realloc(). { fill(area->area, area->area_size, FREE_AREA_PATTERN); put_on_free_ring(area); remove_allocation(area); }

Here is the call graph for this function:

long gw_check_area_size (  void *  p  )

Definition at line 696 of file gwmem-check.c. References area::area_size, find_area(), lock, size, unlock, and warning(). { struct area *area; size_t size; lock(); area = find_area(p); if (!area) { unlock(); warning(0, "Area_size called on non-allocated area %p", p); return -1; } size = area->area_size; unlock(); return size; }

Here is the call graph for this function:

void gw_check_check_leaks (  void   )

Definition at line 652 of file gwmem-check.c. References allocated, area::area_size, check_marks(), debug(), drop_from_free_ring(), dump_area(), free_ring_len, gw_assert, highest_num_allocations, highest_total_size, initialized, lock, num_allocations, total_size, and unlock. { long calculated_size; long index; gw_assert(initialized); lock(); for (index = 0; index < free_ring_len; index++) { drop_from_free_ring(index); } free_ring_len = 0; calculated_size = 0; for (index = 0; index < num_allocations; index++) { calculated_size += allocated[index].area_size; } gw_assert(calculated_size == total_size); debug("gwlib.gwmem", 0, "----------------------------------------"); debug("gwlib.gwmem", 0, "Current allocations: %ld areas, %ld bytes", num_allocations, total_size); debug("gwlib.gwmem", 0, "Highest number of allocations: %ld areas", highest_num_allocations); debug("gwlib.gwmem", 0, "Highest memory usage: %ld bytes", highest_total_size); for (index = 0; index < num_allocations; index++) { check_marks(&allocated[index], index); dump_area(&allocated[index]); } unlock(); }

Here is the call graph for this function:

void* gw_check_claim_area (  void *  p, const char *  filename, long  lineno, const char *  function )

Definition at line 627 of file gwmem-check.c. References area::claimer, location::filename, find_area(), location::function, location::lineno, lock, panic, and unlock. { struct area *area; /* Allow this for the convenience of wrapper macros. */ if (p == NULL) return NULL; lock(); area = find_area(p); if (!area) { unlock(); panic(0, "Claim_area called on non-allocated area"); } area->claimer.filename = filename; area->claimer.lineno = lineno; area->claimer.function = function; unlock(); /* For convenience of calling macros */ return p; }

Here is the call graph for this function:

void gw_check_free (  void *  p, const char *  filename, long  lineno, const char *  function )

Definition at line 594 of file gwmem-check.c. References find_area(), free_area(), gw_assert, initialized, lock, panic, and unlock. { struct area *area; gw_assert(initialized); if (p == NULL) return; lock(); area = find_area(p); if (!area) { unlock(); panic(0, "Free called on non-allocated area"); } free_area(area); unlock(); }

Here is the call graph for this function:

void gw_check_init_mem (  int  slow_flag  )

Definition at line 500 of file gwmem-check.c. References gwmem_lock, initialized, mutex_init_static, and slow. { mutex_init_static(&gwmem_lock); slow = slow_flag; initialized = 1; }

int gw_check_is_allocated (  void *  p  )

Definition at line 686 of file gwmem-check.c. References find_area(), lock, and unlock. { struct area *area; lock(); area = find_area(p); unlock(); return area != NULL; }

Here is the call graph for this function:

void* gw_check_malloc (  size_t  size, const char *  filename, long  lineno, const char *  function )

Definition at line 513 of file gwmem-check.c. References filename, fill(), gw_assert, initialized, lock, malloc, MARKER_SIZE, NEW_AREA_PATTERN, panic, record_allocation(), size, and unlock. Referenced by gw_check_realloc(), and gw_check_strdup(). { unsigned char *p; gw_assert(initialized); /* ANSI C89 says malloc(0) is implementation-defined. Avoid it. */ gw_assert(size > 0); p = malloc(size + 2 * MARKER_SIZE); if (p == NULL) panic(errno, "Memory allocation of %ld bytes failed.", (long)size); p += MARKER_SIZE; lock(); fill(p, size, NEW_AREA_PATTERN); record_allocation(p, size, filename, lineno, function); unlock(); return p; }

Here is the call graph for this function:

void* gw_check_realloc (  void *  p, size_t  size, const char *  filename, long  lineno, const char *  function )

Definition at line 536 of file gwmem-check.c. References area::allocator, area::area_size, change_total_size(), endmark(), filename, location::filename, fill(), find_area(), free_area(), location::function, gw_assert, gw_check_malloc(), initialized, location::lineno, lock, malloc, MARKER_SIZE, area::max_size, NEW_AREA_PATTERN, panic, area::reallocator, record_allocation(), round_pow2(), size, and unlock. { struct area *area; if (p == NULL) return gw_check_malloc(size, filename, lineno, function); gw_assert(initialized); gw_assert(size > 0); lock(); area = find_area(p); if (!area) { unlock(); panic(0, "Realloc called on non-allocated area"); } if (size == area->area_size) { /* No changes */ } else if (size <= area->max_size) { change_total_size(size - area->area_size); area->area_size = size; endmark(p, size); } else if (size > area->max_size) { /* The current block is not large enough for the reallocation. * We will allocate a new block, copy the data over, and free * the old block. We round the size up to a power of two, * to prevent frequent reallocations. */ struct area *new_area; size_t new_size; unsigned char *new_p; new_size = round_pow2(size + 2 * MARKER_SIZE); new_p = malloc(new_size); new_size -= 2 * MARKER_SIZE; new_p += MARKER_SIZE; memcpy(new_p, p, area->area_size); fill(new_p + area->area_size, size - area->area_size, NEW_AREA_PATTERN); new_area = record_allocation(new_p, size, area->allocator.filename, area->allocator.lineno, area->allocator.function); new_area->max_size = new_size; free_area(area); p = new_p; area = new_area; } area->reallocator.filename = filename; area->reallocator.lineno = lineno; area->reallocator.function = function; unlock(); return p; }

Here is the call graph for this function:

void gw_check_shutdown (  void   )

Definition at line 507 of file gwmem-check.c. References gwmem_lock, initialized, and mutex_destroy(). { mutex_destroy(&gwmem_lock); initialized = 0; }

Here is the call graph for this function:

char* gw_check_strdup (  const char *  str, const char *  filename, long  lineno, const char *  function )

Definition at line 614 of file gwmem-check.c. References filename, gw_assert, gw_check_malloc(), and initialized. { char *copy; gw_assert(initialized); gw_assert(str != NULL); copy = gw_check_malloc(strlen(str) + 1, filename, lineno, function); strcpy(copy, str); return copy; }

Here is the call graph for this function:

void lock (  void   )  [inline, static]

Definition at line 197 of file gwmem-check.c. References gwmem_lock, and mutex_lock. { mutex_lock(&gwmem_lock); }

void put_on_free_ring (  struct area *  area  )  [static]

Definition at line 474 of file gwmem-check.c. References area::area, drop_from_free_ring(), free_ring, free_ring_len, free_ring_start, and startmark(). Referenced by free_area(). { /* Simple case: We're still filling the free ring. */ if (free_ring_len < FREE_RING_SIZE) { free_ring[free_ring_len] = *area; startmark(area->area, free_ring_len); free_ring_len++; return; } /* Normal case: We need to check and release a free ring entry, * then put this one in its place. */ drop_from_free_ring(free_ring_start); free_ring[free_ring_start] = *area; startmark(area->area, free_ring_start); free_ring_start = (free_ring_start + 1) % FREE_RING_SIZE; }

Here is the call graph for this function:

struct area* record_allocation (  unsigned char *  p, size_t  size, const char *  filename, long  lineno, const char *  function )  [static]

Definition at line 417 of file gwmem-check.c. References allocated, area::allocator, area::area, area::area_size, change_total_size(), endmark(), location::filename, area::frame_size, area::frames, location::function, highest_num_allocations, location::lineno, area::max_size, num_allocations, panic, size, and startmark(). Referenced by gw_check_malloc(), and gw_check_realloc(). { struct area *area; static struct area empty_area; if (num_allocations == MAX_ALLOCATIONS) { panic(0, "Too many concurrent allocations."); } area = &allocated[num_allocations]; *area = empty_area; area->area = p; area->area_size = size; area->max_size = size; area->allocator.filename = filename; area->allocator.lineno = lineno; area->allocator.function = function; #if HAVE_BACKTRACE area->frame_size = backtrace(area->frames, sizeof(area->frames) / sizeof(void*)); #endif startmark(area->area, num_allocations); endmark(area->area, area->area_size); num_allocations++; if (num_allocations > highest_num_allocations) highest_num_allocations = num_allocations; change_total_size(size); return area; }

Here is the call graph for this function:

void remove_allocation (  struct area *  area  )  [static]

Definition at line 450 of file gwmem-check.c. References allocated, area::area, area::area_size, change_total_size(), check_marks(), num_allocations, and startmark(). Referenced by free_area(). { change_total_size(-1*area->area_size); num_allocations--; if (area == &allocated[num_allocations]) return; check_marks(&allocated[num_allocations], num_allocations); *area = allocated[num_allocations]; startmark(area->area, area - allocated); }

Here is the call graph for this function:

unsigned long round_pow2 (  unsigned long  num  )  [static]

Definition at line 207 of file gwmem-check.c. Referenced by gw_check_realloc(). { unsigned long i; if (num <= 16) return 16; for (i = 32; i < 0x80000000L; i <<= 1) { if (num <= i) return i; } /* We have to handle this case separately; the loop cannot go that * far because i would overflow. */ if (num <= 0x80000000L) return 0x80000000L; return 0xffffffffL; }

void startmark (  unsigned char *  p, long  number )  [static]

Definition at line 262 of file gwmem-check.c. References fill(), gw_assert, MARKER_SIZE, number, and START_MARK_PATTERN. Referenced by put_on_free_ring(), record_allocation(), and remove_allocation(). { gw_assert(MARKER_SIZE >= sizeof(long)); gw_assert(number >= 0); fill(p - MARKER_SIZE, sizeof(long), number); fill(p - MARKER_SIZE + sizeof(long), MARKER_SIZE - sizeof(long), START_MARK_PATTERN); }

Here is the call graph for this function:

void unlock (  void   )  [inline, static]

Definition at line 202 of file gwmem-check.c. References gwmem_lock, and mutex_unlock. { mutex_unlock(&gwmem_lock); }

int untouched (  unsigned char *  p, size_t  bytes, long  pattern )  [static]

Definition at line 240 of file gwmem-check.c. Referenced by check_endmark(), check_startmark(), and drop_from_free_ring(). { while (bytes > sizeof(pattern)) { if (memcmp(p, &pattern, sizeof(pattern)) != 0) return 0; p += sizeof(pattern); bytes -= sizeof(pattern); } if (bytes > 0 && memcmp(p, &pattern, bytes) != 0) return 0; return 1; }

---

Variable Documentation

struct area allocated[MAX_ALLOCATIONS] [static]

Definition at line 176 of file gwmem-check.c. Referenced by find_area(), gw_check_check_leaks(), record_allocation(), and remove_allocation().

struct area free_ring[FREE_RING_SIZE] [static]

Definition at line 177 of file gwmem-check.c. Referenced by drop_from_free_ring(), and put_on_free_ring().

long free_ring_len [static]

Definition at line 185 of file gwmem-check.c. Referenced by gw_check_check_leaks(), and put_on_free_ring().

long free_ring_start [static]

Definition at line 184 of file gwmem-check.c. Referenced by put_on_free_ring().

Mutex gwmem_lock [static]

Definition at line 134 of file gwmem-check.c. Referenced by gw_check_init_mem(), gw_check_shutdown(), lock(), and unlock().

long highest_num_allocations [static]

Definition at line 189 of file gwmem-check.c. Referenced by gw_check_check_leaks(), and record_allocation().

long highest_total_size [static]

Definition at line 191 of file gwmem-check.c. Referenced by change_total_size(), and gw_check_check_leaks().

int initialized = 0 [static]

Definition at line 126 of file gwmem-check.c. Referenced by gw_check_check_leaks(), gw_check_free(), gw_check_init_mem(), gw_check_malloc(), gw_check_realloc(), gw_check_shutdown(), and gw_check_strdup().

long num_allocations [static]

Definition at line 181 of file gwmem-check.c. Referenced by find_area(), gw_check_check_leaks(), record_allocation(), and remove_allocation().

int slow = 0 [static]

Definition at line 129 of file gwmem-check.c. Referenced by find_area(), and gw_check_init_mem().

long total_size [static]

Definition at line 193 of file gwmem-check.c. Referenced by change_total_size(), and gw_check_check_leaks().

See file LICENSE for details about the license agreement for using, modifying, copying or deriving work from this software.