diff options
author | Havoc Pennington <hp@redhat.com> | 2003-03-16 08:08:21 +0000 |
---|---|---|
committer | Havoc Pennington <hp@redhat.com> | 2003-03-16 08:08:21 +0000 |
commit | ce173b29fc1e9432cb5956952afdbe775da12415 (patch) | |
tree | bafd96156eba1879568131fe97789e60fd7e6062 /dbus/dbus-memory.c | |
parent | f587ce7845edb0eb01451368d01b5bc86b5904cd (diff) |
2003-03-16 Havoc Pennington <hp@pobox.com>
Oops - test code was only testing failure of around 30 of the
mallocs in the test path, but it turns out there are 500+
mallocs. I believe this was due to misguided linking setup such
that there was one copy of dbus_malloc etc. in the daemon and one
in the shared lib, and only daemon mallocs were tested. In any
case, the test case now tests all 500+ mallocs, and doesn't pass
yet, though there are lots of fixes in this patch.
* dbus/dbus-connection.c (dbus_connection_dispatch_message): fix
this so that it doesn't need to allocate memory, since it
has no way of indicating failure due to OOM (and would be
annoying if it did).
* dbus/dbus-list.c (_dbus_list_pop_first_link): new function
* bus/Makefile.am: rearrange to create two self-contained
libraries, to avoid having libraries with overlapping symbols.
that was resulting in weirdness, e.g. I'm pretty sure there
were two copies of global static variables.
* dbus/dbus-internals.c: move the malloc debug stuff to
dbus-memory.c
* dbus/dbus-list.c (free_link): free list mempool if it becomes
empty.
* dbus/dbus-memory.c (_dbus_disable_mem_pools): new function
* dbus/dbus-address.c (dbus_parse_address): free list nodes
on failure.
* bus/dispatch.c (bus_dispatch_add_connection): free
message_handler_slot when no longer using it, so
memory leak checkers are happy for the test suite.
* dbus/dbus-server-debug-pipe.c (debug_finalize): free server name
* bus/bus.c (new_connection_callback): disconnect in here if
bus_connections_setup_connection fails.
* bus/connection.c (bus_connections_unref): fix to free the
connections
(bus_connections_setup_connection): if this fails, don't
disconnect the connection, just be sure there are no side
effects.
* dbus/dbus-string.c (undo_alignment): unbreak this
* dbus/dbus-auth.c (_dbus_auth_unref): free some stuff we were
leaking
(_dbus_auth_new): fix the order in which we free strings
on OOM failure
* bus/connection.c (bus_connection_disconnected): fix to
not send ServiceDeleted multiple times in case of memory
allocation failure
* dbus/dbus-bus.c (dbus_bus_get_base_service): new function to
get the base service name
(dbus_bus_register_client): don't return base service name,
instead store it on the DBusConnection and have an accessor
function for it.
(dbus_bus_register_client): rename dbus_bus_register()
* bus/dispatch.c (check_hello_message): verify that other
connections on the bus also got the correct results, not
just the one sending hello
Diffstat (limited to 'dbus/dbus-memory.c')
-rw-r--r-- | dbus/dbus-memory.c | 124 |
1 files changed, 103 insertions, 21 deletions
diff --git a/dbus/dbus-memory.c b/dbus/dbus-memory.c index e1075228..a426b371 100644 --- a/dbus/dbus-memory.c +++ b/dbus/dbus-memory.c @@ -23,6 +23,7 @@ #include "dbus-memory.h" #include "dbus-internals.h" +#include "dbus-sysdeps.h" #include <stdlib.h> @@ -73,10 +74,13 @@ */ #ifdef DBUS_BUILD_TESTS -static dbus_bool_t inited = FALSE; +static dbus_bool_t debug_initialized = FALSE; static int fail_counts = -1; static size_t fail_size = 0; +static int fail_alloc_counter = _DBUS_INT_MAX; static dbus_bool_t guards = FALSE; +static dbus_bool_t disable_mem_pools = FALSE; + /** value stored in guard padding for debugging buffer overrun */ #define GUARD_VALUE 0xdeadbeef /** size of the information about the block stored in guard mode */ @@ -89,27 +93,114 @@ static dbus_bool_t guards = FALSE; #define GUARD_START_OFFSET (GUARD_START_PAD + GUARD_INFO_SIZE) /** total extra size over the requested allocation for guard stuff */ #define GUARD_EXTRA_SIZE (GUARD_START_OFFSET + GUARD_END_PAD) -#endif -#ifdef DBUS_BUILD_TESTS static void -initialize_malloc_debug (void) +_dbus_initialize_malloc_debug (void) { - if (!inited) + if (!debug_initialized) { + debug_initialized = TRUE; + if (_dbus_getenv ("DBUS_MALLOC_FAIL_NTH") != NULL) { fail_counts = atoi (_dbus_getenv ("DBUS_MALLOC_FAIL_NTH")); - _dbus_set_fail_alloc_counter (fail_counts); + fail_alloc_counter = fail_counts; + _dbus_verbose ("Will fail malloc every %d times\n", fail_counts); } if (_dbus_getenv ("DBUS_MALLOC_FAIL_GREATER_THAN") != NULL) - fail_size = atoi (_dbus_getenv ("DBUS_MALLOC_FAIL_GREATER_THAN")); + { + fail_size = atoi (_dbus_getenv ("DBUS_MALLOC_FAIL_GREATER_THAN")); + _dbus_verbose ("Will fail mallocs over %d bytes\n", + fail_size); + } if (_dbus_getenv ("DBUS_MALLOC_GUARDS") != NULL) - guards = TRUE; + { + guards = TRUE; + _dbus_verbose ("Will use malloc guards\n"); + } + + if (_dbus_getenv ("DBUS_DISABLE_MEM_POOLS") != NULL) + { + disable_mem_pools = TRUE; + _dbus_verbose ("Will disable memory pools\n"); + } + } +} + +/** + * 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; +} + +/** + * 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; + + _dbus_verbose ("Set fail alloc counter = %d\n", fail_alloc_counter); +} + +/** + * 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 (fail_counts >= 0) + fail_alloc_counter = fail_counts; + else + fail_alloc_counter = _DBUS_INT_MAX; + + _dbus_verbose ("reset fail alloc counter to %d\n", fail_alloc_counter); - inited = TRUE; + return TRUE; + } + else + { + fail_alloc_counter -= 1; + return FALSE; } } @@ -250,13 +341,10 @@ void* dbus_malloc (size_t bytes) { #ifdef DBUS_BUILD_TESTS - initialize_malloc_debug (); + _dbus_initialize_malloc_debug (); if (_dbus_decrement_fail_alloc_counter ()) { - if (fail_counts != -1) - _dbus_set_fail_alloc_counter (fail_counts); - _dbus_verbose (" FAILING malloc of %d bytes\n", bytes); return NULL; @@ -293,13 +381,10 @@ void* dbus_malloc0 (size_t bytes) { #ifdef DBUS_BUILD_TESTS - initialize_malloc_debug (); + _dbus_initialize_malloc_debug (); if (_dbus_decrement_fail_alloc_counter ()) { - if (fail_counts != -1) - _dbus_set_fail_alloc_counter (fail_counts); - _dbus_verbose (" FAILING malloc0 of %d bytes\n", bytes); return NULL; @@ -338,13 +423,10 @@ dbus_realloc (void *memory, size_t bytes) { #ifdef DBUS_BUILD_TESTS - initialize_malloc_debug (); + _dbus_initialize_malloc_debug (); if (_dbus_decrement_fail_alloc_counter ()) { - if (fail_counts != -1) - _dbus_set_fail_alloc_counter (fail_counts); - _dbus_verbose (" FAILING realloc of %d bytes\n", bytes); return NULL; |