gwmem-check.c File Reference

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

Go to the source code of this file.

Data Structures
struct	location
struct	area

Macros
#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
static void	lock (void)
static void	unlock (void)
static unsigned long	round_pow2 (unsigned long num)
static void	fill (unsigned char *p, size_t bytes, long pattern)
static int	untouched (unsigned char *p, size_t bytes, long pattern)
static void	endmark (unsigned char *p, size_t size)
static void	startmark (unsigned char *p, long number)
static long	check_startmark (unsigned char *p)
static int	check_endmark (unsigned char *p, size_t size)
static int	check_marks (struct area *area, long index)
static void	dump_area (struct area *area)
static struct area *	find_area (unsigned char *p)
static void	change_total_size (long change)
static struct area *	record_allocation (unsigned char *p, size_t size, const char *filename, long lineno, const char *function)
static void	remove_allocation (struct area *area)
static void	drop_from_free_ring (long index)
static void	put_on_free_ring (struct area *area)
static 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_calloc (int nmemb, 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
static int	initialized = 0
static int	slow = 0
static Mutex	gwmem_lock
static struct area	allocated [MAX_ALLOCATIONS]
static struct area	free_ring [FREE_RING_SIZE]
static long	num_allocations
static long	free_ring_start
static long	free_ring_len
static long	highest_num_allocations
static long	highest_total_size
static long	total_size

Macro Definition Documentation

END_MARK_PATTERN

#define END_MARK_PATTERN   0xadadafec

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

Referenced by check_endmark(), endmark(), and find_area().

FREE_AREA_PATTERN

#define FREE_AREA_PATTERN   0xdeadbeef

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

Referenced by drop_from_free_ring(), find_area(), and free_area().

FREE_RING_SIZE

#define FREE_RING_SIZE   1024

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

Referenced by put_on_free_ring().

MARKER_SIZE

#define MARKER_SIZE   16

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

Referenced by check_endmark(), check_startmark(), drop_from_free_ring(), endmark(), gw_check_calloc(), gw_check_malloc(), gw_check_realloc(), and startmark().

MAX_ALLOCATIONS

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

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

Referenced by record_allocation().

MAX_DUMP

#define MAX_DUMP   16

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

Referenced by dump_area().

MAX_TAB_SIZE

#define MAX_TAB_SIZE   (100*1024*1024L)

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

NEW_AREA_PATTERN

#define NEW_AREA_PATTERN   0xcafebabe

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

Referenced by find_area(), gw_check_malloc(), and gw_check_realloc().

START_MARK_PATTERN

#define START_MARK_PATTERN   0xdadaface

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

Referenced by check_startmark(), find_area(), and startmark().

Function Documentation

change_total_size()

static void change_total_size ( long  change )

static

Definition at line 411 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;
}

check_endmark()

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

static

Definition at line 286 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;
}

check_marks()

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

static

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

References area::area, area::area_size, check_endmark(), check_startmark(), and error().

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;
}

check_startmark()

static long check_startmark ( unsigned char *  p )

static

Definition at line 276 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;
}

drop_from_free_ring()

static void drop_from_free_ring ( long  index )

static

Definition at line 462 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);
}

dump_area()

static void dump_area ( struct area *  area )

static

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

References area::allocator, area::area, area::area_size, area::claimer, debug(), location::filename, 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
}

endmark()

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

inlinestatic

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

References END_MARK_PATTERN, fill(), MARKER_SIZE, and size.

Referenced by conn_read_packet(), gw_check_realloc(), and record_allocation().

{
    fill(p + size, MARKER_SIZE, END_MARK_PATTERN);
}

fill()

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

static

Definition at line 229 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);
}

find_area()

static struct area* find_area ( unsigned char *  p )

static

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

References allocated, area::area, area::area_size, check_endmark(), check_startmark(), dump_area(), END_MARK_PATTERN, 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;
}

free_area()

static void free_area ( struct area *  area )

static

Definition at line 494 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);
}

gw_check_area_size()

long gw_check_area_size

(

void *

p

)

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

References area::area, 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;
}

gw_check_calloc()

void* gw_check_calloc	(	int	nmemb,
		size_t	size,
		const char *	filename,
		long	lineno,
		const char *	function
	)

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

References calloc, filename, gw_assert(), initialized, lock(), MARKER_SIZE, panic, record_allocation(), size, and unlock().

{
    unsigned char *p;

    gw_assert(initialized);

    /* ANSI C89 says malloc(0) is implementation-defined.  Avoid it. */
    gw_assert(size > 0);
    gw_assert(nmemb > 0);

    p = calloc(1, (nmemb*size) + 2 * MARKER_SIZE);
    if (p == NULL)
        panic(errno, "Memory allocation of %ld bytes failed.", (long)size);

    p += MARKER_SIZE;

    lock();
    record_allocation(p, size, filename, lineno, function);
    unlock();

    return p;
}

gw_check_check_leaks()

void gw_check_check_leaks

(

void

)

Definition at line 679 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();
}

gw_check_claim_area()

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

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

References area::area, area::claimer, location::filename, 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;
}

gw_check_free()

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

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

References area::area, 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();
}

gw_check_init_mem()

void gw_check_init_mem

(

int

slow_flag

)

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

References gwmem_lock, initialized, mutex_init_static, and slow.

{
    mutex_init_static(&gwmem_lock);
    slow = slow_flag;
    initialized = 1;
}

gw_check_is_allocated()

int gw_check_is_allocated

(

void *

p

)

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

References area::area, find_area(), lock(), and unlock().

{
    struct area *area;

    lock();
    area = find_area(p);
    unlock();
    return area != NULL;
}

gw_check_malloc()

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

Definition at line 514 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;
}

gw_check_realloc()

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

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

References area::allocator, area::area, area::area_size, change_total_size(), endmark(), location::filename, 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;
}

gw_check_shutdown()

void gw_check_shutdown

(

void

)

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

References gwmem_lock, initialized, and mutex_destroy().

{
    mutex_destroy(&gwmem_lock);
    initialized = 0;
}

gw_check_strdup()

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

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

References filename, gw_assert(), gw_check_malloc(), initialized, and size.

{
    char *copy;
    int size;

    gw_assert(initialized);
    gw_assert(str != NULL);

    size = strlen(str) + 1;
    copy = gw_check_malloc(size, filename, lineno, function);
    memcpy(copy, str, size);
    return copy;
}

lock()

static void lock ( void  )

inlinestatic

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

References gwmem_lock, and mutex_lock.

Referenced by gw_check_area_size(), gw_check_calloc(), gw_check_check_leaks(), gw_check_claim_area(), gw_check_free(), gw_check_is_allocated(), gw_check_malloc(), and gw_check_realloc().

{
    mutex_lock(&gwmem_lock);
}

put_on_free_ring()

static void put_on_free_ring ( struct area *  area )

static

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

References area::area, drop_from_free_ring(), free_ring, free_ring_len, FREE_RING_SIZE, 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;
}

record_allocation()

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

static

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

References allocated, area::allocator, area::area, area::area_size, change_total_size(), endmark(), location::filename, filename, location::function, highest_num_allocations, location::lineno, MAX_ALLOCATIONS, area::max_size, num_allocations, panic, size, and startmark().

Referenced by gw_check_calloc(), 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;
}

remove_allocation()

static void remove_allocation ( struct area *  area )

static

Definition at line 451 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);
}

round_pow2()

static unsigned long round_pow2 ( unsigned long  num )

static

Definition at line 208 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;
}

startmark()

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

static

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

References fill(), gw_assert(), MARKER_SIZE, number, and START_MARK_PATTERN.

Referenced by conn_read_packet(), 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);
}

unlock()

static void unlock ( void  )

inlinestatic

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

References gwmem_lock, and mutex_unlock.

Referenced by gw_check_area_size(), gw_check_calloc(), gw_check_check_leaks(), gw_check_claim_area(), gw_check_free(), gw_check_is_allocated(), gw_check_malloc(), and gw_check_realloc().

{
    mutex_unlock(&gwmem_lock);
}

untouched()

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

static

Definition at line 241 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

allocated

struct area allocated[MAX_ALLOCATIONS]

static

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

Referenced by find_area(), gw_check_check_leaks(), record_allocation(), and remove_allocation().

free_ring

struct area free_ring[FREE_RING_SIZE]

static

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

Referenced by drop_from_free_ring(), and put_on_free_ring().

free_ring_len

long free_ring_len

static

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

Referenced by gw_check_check_leaks(), and put_on_free_ring().

free_ring_start

long free_ring_start

static

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

Referenced by put_on_free_ring().

gwmem_lock

Mutex gwmem_lock

static

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

Referenced by gw_check_init_mem(), gw_check_shutdown(), lock(), and unlock().

highest_num_allocations

long highest_num_allocations

static

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

Referenced by gw_check_check_leaks(), and record_allocation().

highest_total_size

long highest_total_size

static

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

Referenced by change_total_size(), and gw_check_check_leaks().

initialized

int initialized = 0

static

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

Referenced by gw_check_calloc(), gw_check_check_leaks(), gw_check_free(), gw_check_init_mem(), gw_check_malloc(), gw_check_realloc(), gw_check_shutdown(), and gw_check_strdup().

num_allocations

long num_allocations

static

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

Referenced by find_area(), gw_check_check_leaks(), record_allocation(), and remove_allocation().

slow

int slow = 0

static

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

Referenced by find_area(), and gw_check_init_mem().

total_size

long total_size

static

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

Referenced by change_total_size(), and gw_check_check_leaks().