[rename] renamed kdbus related macros

[platform/upstream/dbus.git] / dbus / dbus-memory.c

diff --git a/dbus/dbus-memory.c b/dbus/dbus-memory.c
index c5f4641..d59e8f8 100644 (file)
--- a/dbus/dbus-memory.c
+++ b/dbus/dbus-memory.c
@@ -26,6 +26,7 @@
 #include "dbus-internals.h"
 #include "dbus-sysdeps.h"
 #include "dbus-list.h"
+#include "dbus-threads.h"
 #include <stdlib.h>
 
 /**
@@ -96,7 +97,7 @@
  * @{
  */
 
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
 static dbus_bool_t debug_initialized = FALSE;
 static int fail_nth = -1;
 static size_t fail_size = 0;
@@ -106,6 +107,7 @@ static int n_failures_this_failure = 0;
 static dbus_bool_t guards = FALSE;
 static dbus_bool_t disable_mem_pools = FALSE;
 static dbus_bool_t backtrace_on_fail_alloc = FALSE;
+static dbus_bool_t malloc_cannot_fail = FALSE;
 static DBusAtomic n_blocks_outstanding = {0};
 
 /** value stored in guard padding for debugging buffer overrun */
@@ -132,7 +134,7 @@ _dbus_initialize_malloc_debug (void)
        {
          fail_nth = atoi (_dbus_getenv ("DBUS_MALLOC_FAIL_NTH"));
           fail_alloc_counter = fail_nth;
-          _dbus_verbose ("Will fail malloc every %d times\n", fail_nth);
+          _dbus_verbose ("Will fail dbus_malloc every %d times\n", fail_nth);
        }
       
       if (_dbus_getenv ("DBUS_MALLOC_FAIL_GREATER_THAN") != NULL)
@@ -145,7 +147,7 @@ _dbus_initialize_malloc_debug (void)
       if (_dbus_getenv ("DBUS_MALLOC_GUARDS") != NULL)
         {
           guards = TRUE;
-          _dbus_verbose ("Will use malloc guards\n");
+          _dbus_verbose ("Will use dbus_malloc guards\n");
         }
 
       if (_dbus_getenv ("DBUS_DISABLE_MEM_POOLS") != NULL)
@@ -157,7 +159,13 @@ _dbus_initialize_malloc_debug (void)
       if (_dbus_getenv ("DBUS_MALLOC_BACKTRACES") != NULL)
         {
           backtrace_on_fail_alloc = TRUE;
-          _dbus_verbose ("Will backtrace on failing a malloc\n");
+          _dbus_verbose ("Will backtrace on failing a dbus_malloc\n");
+        }
+
+      if (_dbus_getenv ("DBUS_MALLOC_CANNOT_FAIL") != NULL)
+        {
+          malloc_cannot_fail = TRUE;
+          _dbus_verbose ("Will abort if system malloc() and friends fail\n");
         }
     }
 }
@@ -232,7 +240,7 @@ _dbus_get_fail_alloc_failures (void)
   return n_failures_per_failure;
 }
 
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
 /**
  * Called when about to alloc some memory; if
  * it returns #TRUE, then the allocation should
@@ -286,7 +294,7 @@ _dbus_decrement_fail_alloc_counter (void)
       return FALSE;
     }
 }
-#endif /* DBUS_BUILD_TESTS */
+#endif /* DBUS_ENABLE_EMBEDDED_TESTS */
 
 /**
  * Get the number of outstanding malloc()'d blocks.
@@ -452,7 +460,7 @@ set_guards (void       *real_block,
 void*
 dbus_malloc (size_t bytes)
 {
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
   _dbus_initialize_malloc_debug ();
   
   if (_dbus_decrement_fail_alloc_counter ())
@@ -464,7 +472,7 @@ dbus_malloc (size_t bytes)
 
   if (bytes == 0) /* some system mallocs handle this, some don't */
     return NULL;
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
   else if (fail_size != 0 && bytes > fail_size)
     return NULL;
   else if (guards)
@@ -473,7 +481,15 @@ dbus_malloc (size_t bytes)
 
       block = malloc (bytes + GUARD_EXTRA_SIZE);
       if (block)
-       _dbus_atomic_inc (&n_blocks_outstanding);
+        {
+          _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);
     }
@@ -482,10 +498,19 @@ dbus_malloc (size_t bytes)
     {
       void *mem;
       mem = malloc (bytes);
-#ifdef DBUS_BUILD_TESTS
+
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
       if (mem)
-       _dbus_atomic_inc (&n_blocks_outstanding);
+        {
+          _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;
     }
 }
@@ -505,7 +530,7 @@ dbus_malloc (size_t bytes)
 void*
 dbus_malloc0 (size_t bytes)
 {
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
   _dbus_initialize_malloc_debug ();
   
   if (_dbus_decrement_fail_alloc_counter ())
@@ -518,7 +543,7 @@ dbus_malloc0 (size_t bytes)
   
   if (bytes == 0)
     return NULL;
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
   else if (fail_size != 0 && bytes > fail_size)
     return NULL;
   else if (guards)
@@ -526,8 +551,18 @@ dbus_malloc0 (size_t bytes)
       void *block;
 
       block = calloc (bytes + GUARD_EXTRA_SIZE, 1);
+
       if (block)
-       _dbus_atomic_inc (&n_blocks_outstanding);
+        {
+          _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
@@ -535,10 +570,19 @@ dbus_malloc0 (size_t bytes)
     {
       void *mem;
       mem = calloc (bytes, 1);
-#ifdef DBUS_BUILD_TESTS
+
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
       if (mem)
-       _dbus_atomic_inc (&n_blocks_outstanding);
+        {
+          _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;
     }
 }
@@ -557,7 +601,7 @@ void*
 dbus_realloc (void  *memory,
               size_t bytes)
 {
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
   _dbus_initialize_malloc_debug ();
   
   if (_dbus_decrement_fail_alloc_counter ())
@@ -573,7 +617,7 @@ dbus_realloc (void  *memory,
       dbus_free (memory);
       return NULL;
     }
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
   else if (fail_size != 0 && bytes > fail_size)
     return NULL;
   else if (guards)
@@ -588,8 +632,20 @@ dbus_realloc (void  *memory,
           block = realloc (((unsigned char*)memory) - GUARD_START_OFFSET,
                            bytes + GUARD_EXTRA_SIZE);
 
-         old_bytes = *(dbus_uint32_t*)block;
-          if (block && bytes >= old_bytes)
+          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;
+            }
+
+          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);
           
@@ -602,8 +658,16 @@ dbus_realloc (void  *memory,
           block = malloc (bytes + GUARD_EXTRA_SIZE);
 
           if (block)
-           _dbus_atomic_inc (&n_blocks_outstanding);
-          
+            {
+              _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_REALLOC_NULL);   
         }
     }
@@ -612,7 +676,14 @@ dbus_realloc (void  *memory,
     {
       void *mem;
       mem = realloc (memory, bytes);
-#ifdef DBUS_BUILD_TESTS
+
+#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
@@ -629,7 +700,7 @@ dbus_realloc (void  *memory,
 void
 dbus_free (void  *memory)
 {
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
   if (guards)
     {
       check_guards (memory, TRUE);
@@ -653,7 +724,7 @@ dbus_free (void  *memory)
     
   if (memory) /* we guarantee it's safe to free (NULL) */
     {
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
 #ifdef DBUS_DISABLE_ASSERT
       _dbus_atomic_dec (&n_blocks_outstanding);
 #else
@@ -724,7 +795,7 @@ struct ShutdownClosure
   void *data;                /**< Data for function */
 };
 
-_DBUS_DEFINE_GLOBAL_LOCK (shutdown_funcs);
+/* Protected by _DBUS_LOCK (shutdown_funcs) */
 static ShutdownClosure *registered_globals = NULL;
 
 /**
@@ -739,6 +810,20 @@ dbus_bool_t
 _dbus_register_shutdown_func (DBusShutdownFunction  func,
                               void                 *data)
 {
+  dbus_bool_t ok;
+
+  if (!_DBUS_LOCK (shutdown_funcs))
+    return FALSE;
+
+  ok = _dbus_register_shutdown_func_unlocked (func, data);
+  _DBUS_UNLOCK (shutdown_funcs);
+  return ok;
+}
+
+dbus_bool_t
+_dbus_register_shutdown_func_unlocked (DBusShutdownFunction  func,
+                                       void                 *data)
+{
   ShutdownClosure *c;
 
   c = dbus_new (ShutdownClosure, 1);
@@ -749,13 +834,9 @@ _dbus_register_shutdown_func (DBusShutdownFunction  func,
   c->func = func;
   c->data = data;
 
-  _DBUS_LOCK (shutdown_funcs);
-  
   c->next = registered_globals;
   registered_globals = c;
 
-  _DBUS_UNLOCK (shutdown_funcs);
-  
   return TRUE;
 }
 
@@ -820,12 +901,18 @@ dbus_shutdown (void)
       dbus_free (c);
     }
 
+  /* We wrap this in the thread-initialization lock because
+   * dbus_threads_init() uses the current generation to tell whether
+   * we're initialized, so we need to make sure that un-initializing
+   * propagates into all threads. */
+  _dbus_threads_lock_platform_specific ();
   _dbus_current_generation += 1;
+  _dbus_threads_unlock_platform_specific ();
 }
 
 /** @} */ /** End of public API docs block */
 
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
 #include "dbus-test.h"
 
 /**