gwmem.h File Reference

Go to the source code of this file.

Macros
#define	malloc(n)   do_not_call_malloc_directly
#define	calloc(a, b)   do_not_use_calloc
#define	realloc(p, n)   do_not_call_realloc_directly
#define	free(p)   do_not_call_free_directly
#define	strdup(p)   do_not_call_strdup_directly

Functions
void *	gw_native_noop (void *ptr)
void	gw_native_init (void)
void	gw_native_check_leaks (void)
void *	gw_native_malloc (size_t size)
void *	gw_native_calloc (int nmemb, size_t size)
void *	gw_native_realloc (void *ptr, size_t size)
void	gw_native_free (void *ptr)
char *	gw_native_strdup (const char *str)
void	gw_native_shutdown (void)
void	gw_check_init_mem (int slow_flag)
void	gw_check_check_leaks (void)
void *	gw_check_malloc (size_t size, const char *filename, long line, const char *function)
void *	gw_check_calloc (int nmemb, size_t size, const char *filename, long line, const char *function)
void *	gw_check_realloc (void *p, size_t size, const char *filename, long line, const char *function)
void	gw_check_free (void *p, const char *filename, long line, const char *function)
char *	gw_check_strdup (const char *str, const char *filename, long line, const char *function)
int	gw_check_is_allocated (void *p)
long	gw_check_area_size (void *p)
void *	gw_check_claim_area (void *p, const char *filename, long line, const char *function)
void	gw_check_shutdown (void)

Macro Definition Documentation

calloc

#define calloc	(		a,
			b
	)		do_not_use_calloc

Definition at line 192 of file gwmem.h.

Referenced by gw_check_calloc(), gw_native_calloc(), and ws_calloc().

free

#define free

(

p

)

do_not_call_free_directly

Definition at line 194 of file gwmem.h.

malloc

#define malloc

(

n

)

do_not_call_malloc_directly

Definition at line 191 of file gwmem.h.

realloc

#define realloc	(		p,
			n
	)		do_not_call_realloc_directly

Definition at line 193 of file gwmem.h.

Referenced by CodepageAttrvalueName(), DumpNode(), gw_native_realloc(), Read_termstr_rtn(), ReadBinary(), and ws_realloc().

strdup

#define strdup

(

p

)

do_not_call_strdup_directly

Definition at line 195 of file gwmem.h.

Referenced by AddStringNode(), CodepageAttrstartName(), CodepageAttrvalueName(), DumpNode(), and parse_options().

Function Documentation

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

gw_native_calloc()

void* gw_native_calloc	(	int	nmemb,
		size_t	size
	)

Definition at line 94 of file gwmem-native.c.

References calloc, gw_assert(), panic, and size.

{
    void *ptr;

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

    ptr = calloc(nmemb, size);
    if (ptr == NULL)
        panic(errno, "Memory allocation failed");

    return ptr;
}

gw_native_check_leaks()

void gw_native_check_leaks

(

void

)

gw_native_free()

void gw_native_free

(

void *

ptr

)

Definition at line 123 of file gwmem-native.c.

References free().

Referenced by gw_backtrace().

{
    free(ptr);
}

gw_native_init()

void gw_native_init

(

void

)

gw_native_malloc()

void* gw_native_malloc

(

size_t

size

)

Definition at line 80 of file gwmem-native.c.

References gw_assert(), malloc(), panic, and size.

Referenced by gw_native_strdup().

{
    void *ptr;

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

    ptr = malloc(size);
    if (ptr == NULL)
        panic(errno, "Memory allocation failed");

    return ptr;
}

gw_native_noop()

void* gw_native_noop

(

void *

ptr

)

Definition at line 78 of file gwmem-native.c.

{ return ptr; }

gw_native_realloc()

void* gw_native_realloc	(	void *	ptr,
		size_t	size
	)

Definition at line 109 of file gwmem-native.c.

References gw_assert(), panic, realloc, and size.

{
    void *new_ptr;

    gw_assert(size > 0);

    new_ptr = realloc(ptr, size);
    if (new_ptr == NULL)
        panic(errno, "Memory re-allocation failed");

    return new_ptr;
}

gw_native_shutdown()

void gw_native_shutdown

(

void

)

gw_native_strdup()

char* gw_native_strdup

(

const char *

str

)

Definition at line 129 of file gwmem-native.c.

References gw_assert(), gw_native_malloc(), and size.

{
    char *copy;
    int size;

    gw_assert(str != NULL);
    size = strlen(str) + 1;

    copy = gw_native_malloc(size);
    memcpy(copy, str, size);
    return copy;
}