/**
* Gets the number of successful allocs until we'll simulate
* a failed alloc.
*
* @returns current counter value
*/
int
_dbus_get_fail_alloc_counter (void)
{
_dbus_initialize_malloc_debug ();
return fail_alloc_counter;
}
/**
* Called when about to alloc some memory; if
* it returns #TRUE, then the allocation should
* fail. If it returns #FALSE, then the allocation
* should not fail.
*
* @returns #TRUE if this alloc should fail
*/
dbus_bool_t
_dbus_decrement_fail_alloc_counter (void)
{
_dbus_initialize_malloc_debug ();
if (fail_alloc_counter <= 0)
{
if (backtrace_on_fail_alloc)
_dbus_print_backtrace ();
_dbus_verbose ("failure %d\n", n_failures_this_failure);
n_failures_this_failure += 1;
if (n_failures_this_failure >= n_failures_per_failure)
{
if (fail_nth >= 0)
fail_alloc_counter = fail_nth;
else
fail_alloc_counter = _DBUS_INT_MAX;
n_failures_this_failure = 0;
_dbus_verbose ("reset fail alloc counter to %d\n", fail_alloc_counter);
}
return TRUE;
}
else
{
fail_alloc_counter -= 1;
return FALSE;
}
}
/**
* Allocates the given number of bytes, as with standard malloc(), but
* all bytes are initialized to zero as with calloc(). Guaranteed to
* return #NULL if bytes is zero on all platforms. Returns #NULL if the
* allocation fails. The memory must be released with dbus_free().
*
* dbus_malloc0() memory is NOT safe to free with regular free() from
* the C library. Free it with dbus_free() only.
*
* @param bytes number of bytes to allocate
* @return allocated memory, or #NULL if the allocation fails.
*/
void*
dbus_malloc0 (size_t bytes)
{
#ifdef DBUS_BUILD_TESTS
_dbus_initialize_malloc_debug ();
if (_dbus_decrement_fail_alloc_counter ())
{
_dbus_verbose (" FAILING malloc0 of %ld bytes\n", (long) bytes);
return NULL;
}
#endif
if (bytes == 0)
return NULL;
#ifdef DBUS_BUILD_TESTS
else if (fail_size != 0 && bytes > fail_size)
return NULL;
else if (guards)
{
void *block;
block = calloc (bytes + GUARD_EXTRA_SIZE, 1);
if (block)
{
_dbus_atomic_inc (&n_blocks_outstanding);
}
else if (malloc_cannot_fail)
{
_dbus_warn ("out of memory: calloc (%ld + %ld, 1)\n",
(long) bytes, (long) GUARD_EXTRA_SIZE);
_dbus_abort ();
}
return set_guards (block, bytes, SOURCE_MALLOC_ZERO);
}
#endif
else
{
void *mem;
mem = calloc (bytes, 1);
#ifdef DBUS_BUILD_TESTS
if (mem)
{
_dbus_atomic_inc (&n_blocks_outstanding);
}
else if (malloc_cannot_fail)
{
_dbus_warn ("out of memory: calloc (%ld)\n", (long) bytes);
_dbus_abort ();
}
#endif
return mem;
}
}
/**
* Allocates the given number of bytes, as with standard
* malloc(). Guaranteed to return #NULL if bytes is zero
* on all platforms. Returns #NULL if the allocation fails.
* The memory must be released with dbus_free().
*
* dbus_malloc() memory is NOT safe to free with regular free() from
* the C library. Free it with dbus_free() only.
*
* @param bytes number of bytes to allocate
* @return allocated memory, or #NULL if the allocation fails.
*/
void*
dbus_malloc (size_t bytes)
{
#ifdef DBUS_ENABLE_EMBEDDED_TESTS
_dbus_initialize_malloc_debug ();
if (_dbus_decrement_fail_alloc_counter ())
{
_dbus_verbose (" FAILING malloc of %ld bytes\n", (long) bytes);
return NULL;
}
#endif
if (bytes == 0) /* some system mallocs handle this, some don't */
return NULL;
#ifdef DBUS_ENABLE_EMBEDDED_TESTS
else if (fail_size != 0 && bytes > fail_size)
return NULL;
else if (guards)
{
void *block;
block = malloc (bytes + GUARD_EXTRA_SIZE);
if (block)
{
_dbus_atomic_inc (&n_blocks_outstanding);
}
else if (malloc_cannot_fail)
{
_dbus_warn ("out of memory: malloc (%ld + %ld)\n",
(long) bytes, (long) GUARD_EXTRA_SIZE);
_dbus_abort ();
}
return set_guards (block, bytes, SOURCE_MALLOC);
}
#endif
else
{
void *mem;
mem = malloc (bytes);
#ifdef DBUS_ENABLE_EMBEDDED_TESTS
if (mem)
{
_dbus_atomic_inc (&n_blocks_outstanding);
}
else if (malloc_cannot_fail)
{
_dbus_warn ("out of memory: malloc (%ld)\n", (long) bytes);
_dbus_abort ();
}
#endif
return mem;
}
}
/**
* Sets the number of allocations until we simulate a failed
* allocation. If set to 0, the next allocation to run
* fails; if set to 1, one succeeds then the next fails; etc.
* Set to _DBUS_INT_MAX to not fail anything.
*
* @param until_next_fail number of successful allocs before one fails
*/
void
_dbus_set_fail_alloc_counter (int until_next_fail)
{
_dbus_initialize_malloc_debug ();
fail_alloc_counter = until_next_fail;
#if 0
_dbus_verbose ("Set fail alloc counter = %d\n", fail_alloc_counter);
#endif
}
/**
* Called when about to alloc some memory; if
* it returns #TRUE, then the allocation should
* fail. If it returns #FALSE, then the allocation
* should not fail.
*
* @returns #TRUE if this alloc should fail
*/
dbus_bool_t
_dbus_decrement_fail_alloc_counter (void)
{
_dbus_initialize_malloc_debug ();
#ifdef DBUS_WIN_FIXME
{
static dbus_bool_t called = 0;
if (!called)
{
_dbus_verbose("TODO: memory allocation testing errors disabled for now\n");
called = 1;
}
return FALSE;
}
#endif
if (fail_alloc_counter <= 0)
{
if (backtrace_on_fail_alloc)
_dbus_print_backtrace ();
_dbus_verbose ("failure %d\n", n_failures_this_failure);
n_failures_this_failure += 1;
if (n_failures_this_failure >= n_failures_per_failure)
{
if (fail_nth >= 0)
fail_alloc_counter = fail_nth;
else
fail_alloc_counter = _DBUS_INT_MAX;
n_failures_this_failure = 0;
_dbus_verbose ("reset fail alloc counter to %d\n", fail_alloc_counter);
}
return TRUE;
}
else
{
fail_alloc_counter -= 1;
return FALSE;
}
}
/**
* Allocates the given number of bytes, as with standard
* malloc(). Guaranteed to return #NULL if bytes is zero
* on all platforms. Returns #NULL if the allocation fails.
* The memory must be released with dbus_free().
*
* @param bytes number of bytes to allocate
* @return allocated memory, or #NULL if the allocation fails.
*/
void*
dbus_malloc (size_t bytes)
{
#ifdef DBUS_BUILD_TESTS
_dbus_initialize_malloc_debug ();
if (_dbus_decrement_fail_alloc_counter ())
{
_dbus_verbose (" FAILING malloc of %ld bytes\n", (long) bytes);
return NULL;
}
#endif
if (bytes == 0) /* some system mallocs handle this, some don't */
return NULL;
#ifdef DBUS_BUILD_TESTS
else if (fail_size != 0 && bytes > fail_size)
return NULL;
else if (guards)
{
void *block;
block = malloc (bytes + GUARD_EXTRA_SIZE);
if (block)
n_blocks_outstanding += 1;
return set_guards (block, bytes, SOURCE_MALLOC);
}
#endif
else
{
void *mem;
mem = malloc (bytes);
#ifdef DBUS_BUILD_TESTS
if (mem)
n_blocks_outstanding += 1;
#endif
return mem;
}
}
/**
* Resizes a block of memory previously allocated by dbus_malloc() or
* dbus_malloc0(). Guaranteed to free the memory and return #NULL if bytes
* is zero on all platforms. Returns #NULL if the resize fails.
* If the resize fails, the memory is not freed.
*
* @param memory block to be resized
* @param bytes new size of the memory block
* @return allocated memory, or #NULL if the resize fails.
*/
void*
dbus_realloc (void *memory,
size_t bytes)
{
#ifdef DBUS_BUILD_TESTS
_dbus_initialize_malloc_debug ();
if (_dbus_decrement_fail_alloc_counter ())
{
_dbus_verbose (" FAILING realloc of %ld bytes\n", (long) bytes);
return NULL;
}
#endif
if (bytes == 0) /* guarantee this is safe */
{
dbus_free (memory);
return NULL;
}
#ifdef DBUS_BUILD_TESTS
else if (fail_size != 0 && bytes > fail_size)
return NULL;
else if (guards)
{
if (memory)
{
size_t old_bytes;
void *block;
check_guards (memory, FALSE);
block = realloc (((unsigned char*)memory) - GUARD_START_OFFSET,
bytes + GUARD_EXTRA_SIZE);
old_bytes = *(dbus_uint32_t*)block;
if (block && bytes >= old_bytes)
/* old guards shouldn't have moved */
check_guards (((unsigned char*)block) + GUARD_START_OFFSET, FALSE);
return set_guards (block, bytes, SOURCE_REALLOC);
}
else
{
void *block;
block = malloc (bytes + GUARD_EXTRA_SIZE);
if (block)
_dbus_atomic_inc (&n_blocks_outstanding);
return set_guards (block, bytes, SOURCE_REALLOC_NULL);
}
}
#endif
else
{
void *mem;
mem = realloc (memory, bytes);
#ifdef DBUS_BUILD_TESTS
if (memory == NULL && mem != NULL)
_dbus_atomic_inc (&n_blocks_outstanding);
#endif
return mem;
}
}
/**
* Whether to turn off mem pools, useful for leak checking.
*
* @returns #TRUE if mempools should not be used.
*/
dbus_bool_t
_dbus_disable_mem_pools (void)
{
_dbus_initialize_malloc_debug ();
return disable_mem_pools;
}
/**
* Resizes a block of memory previously allocated by dbus_malloc() or
* dbus_malloc0(). Guaranteed to free the memory and return #NULL if bytes
* is zero on all platforms. Returns #NULL if the resize fails.
* If the resize fails, the memory is not freed.
*
* @param memory block to be resized
* @param bytes new size of the memory block
* @return allocated memory, or #NULL if the resize fails.
*/
void*
_dbus_realloc (void *memory,
size_t bytes,
const char *file,
int line)
{
#ifdef DBUS_ENABLE_EMBEDDED_TESTS
_dbus_initialize_malloc_debug ();
if (_dbus_decrement_fail_alloc_counter ())
{
_dbus_verbose (" FAILING realloc of %ld bytes\n", (long) bytes);
return NULL;
}
#endif
if (bytes == 0) /* guarantee this is safe */
{
dbus_free (memory);
return NULL;
}
#ifdef DBUS_ENABLE_EMBEDDED_TESTS
else if (fail_size != 0 && bytes > fail_size)
return NULL;
else if (guards)
{
if (memory)
{
size_t old_bytes;
void *block;
check_guards (memory, FALSE);
block = realloc (((unsigned char*)memory) - GUARD_START_OFFSET,
bytes + GUARD_EXTRA_SIZE);
if (block == NULL)
{
if (malloc_cannot_fail)
{
_dbus_warn ("out of memory: realloc (%p, %ld + %ld)\n",
memory, (long) bytes, (long) GUARD_EXTRA_SIZE);
_dbus_abort ();
}
return NULL;
}
dbus_track_free (((unsigned char*)memory) - GUARD_START_OFFSET);
dbus_track_realloc (((unsigned char*)memory) - GUARD_START_OFFSET, bytes + GUARD_EXTRA_SIZE, file, line);
old_bytes = *(dbus_uint32_t*)block;
if (bytes >= old_bytes)
/* old guards shouldn't have moved */
check_guards (((unsigned char*)block) + GUARD_START_OFFSET, FALSE);
return set_guards (block, bytes, SOURCE_REALLOC);
}
else
{
void *block;
block = malloc (bytes + GUARD_EXTRA_SIZE);
if (block)
{
_dbus_atomic_inc (&n_blocks_outstanding);
dbus_track_malloc(block, bytes + GUARD_EXTRA_SIZE, file, line);
}
else if (malloc_cannot_fail)
{
_dbus_warn ("out of memory: malloc (%ld + %ld)\n",
(long) bytes, (long) GUARD_EXTRA_SIZE);
_dbus_abort ();
}
return set_guards (block, bytes, SOURCE_REALLOC_NULL);
}
}
#endif
else
{
void *mem;
mem = realloc (memory, bytes);
#ifdef DBUS_ENABLE_EMBEDDED_TESTS
if (mem == NULL && malloc_cannot_fail)
{
_dbus_warn ("out of memory: malloc (%ld)\n", (long) bytes);
_dbus_abort ();
}
if (memory == NULL && mem != NULL)
_dbus_atomic_inc (&n_blocks_outstanding);
#endif
dbus_track_free (memory);
dbus_track_realloc (mem, bytes, file, line);
return mem;
}
}
