merge
authorRusty Russell <rusty@rustcorp.com.au>
Tue, 5 Aug 2008 03:58:32 +0000 (13:58 +1000)
committerRusty Russell <rusty@rustcorp.com.au>
Tue, 5 Aug 2008 03:58:32 +0000 (13:58 +1000)
ccan/talloc/TODO [deleted file]
ccan/talloc/talloc.c
ccan/talloc/talloc.h
ccan/talloc/test/run-external-alloc.c
ccan/talloc/test/run.c

diff --git a/ccan/talloc/TODO b/ccan/talloc/TODO
deleted file mode 100644 (file)
index 0671a6d..0000000
+++ /dev/null
@@ -1,2 +0,0 @@
-- Remove talloc.h cruft
-- Restore errno around (successful) talloc_free.
index ba998f5424b6570571a3bbe64b0bbdff82bba2ba..815f255f7f2ef4c11f905502fdbab0f7d05c445b 100644 (file)
 static void *null_context;
 static pid_t *autofree_context;
 
-static void *(*tc_external_alloc)(void *parent, size_t size);
-static void (*tc_external_free)(void *ptr, void *parent);
-static void *(*tc_external_realloc)(void *ptr, void *parent, size_t size);
+static void *(*tc_external_realloc)(const void *parent, void *ptr, size_t size);
+static void (*tc_lock)(void *);
+static void (*tc_unlock)(void *);
+static void *tc_lock_data;
 
 struct talloc_reference_handle {
        struct talloc_reference_handle *next, *prev;
@@ -149,6 +150,17 @@ do { \
        if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
 } while (0)
 
+static inline void lock(void)
+{
+       if (tc_lock)
+               tc_lock(tc_lock_data);
+}
+
+static inline void unlock(void)
+{
+       if (tc_lock)
+               tc_unlock(tc_lock_data);
+}
 
 /*
   return the parent chunk of a pointer
@@ -169,7 +181,11 @@ static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr)
 
 void *talloc_parent(const void *ptr)
 {
-       struct talloc_chunk *tc = talloc_parent_chunk(ptr);
+       struct talloc_chunk *tc;
+
+       lock();
+       tc = talloc_parent_chunk(ptr);
+       unlock();
        return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
 }
 
@@ -178,49 +194,32 @@ void *talloc_parent(const void *ptr)
 */
 const char *talloc_parent_name(const void *ptr)
 {
-       struct talloc_chunk *tc = talloc_parent_chunk(ptr);
+       struct talloc_chunk *tc;
+
+       lock();
+       tc = talloc_parent_chunk(ptr);
+       unlock();
+
        return tc? tc->name : NULL;
 }
 
-/* 
-   Allocate a bit of memory as a child of an existing pointer
-*/
-static inline void *__talloc(const void *context, size_t size)
+static void *init_talloc(struct talloc_chunk *parent,
+                        struct talloc_chunk *tc,
+                        size_t size, int external)
 {
-       struct talloc_chunk *tc;
-       struct talloc_chunk *parent = NULL; /* Prevent spurious gcc warning */
-       unsigned flags = TALLOC_MAGIC;
-
-       if (unlikely(context == NULL)) {
-               context = null_context;
-       }
-
-       if (unlikely(size >= MAX_TALLOC_SIZE)) {
+       if (unlikely(tc == NULL))
                return NULL;
-       }
-
-       if (likely(context)) {
-               parent = talloc_chunk_from_ptr(context);
-               if (unlikely(parent->flags & TALLOC_FLAG_EXT_ALLOC)) {
-                       tc = tc_external_alloc(TC_PTR_FROM_CHUNK(parent),
-                                              TC_HDR_SIZE+size);
-                       flags |= TALLOC_FLAG_EXT_ALLOC;
-                       goto alloc_done;
-               }
-       }
-
-       tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
-alloc_done:
-       if (unlikely(tc == NULL)) return NULL;
 
        tc->size = size;
-       tc->flags = flags;
+       tc->flags = TALLOC_MAGIC;
+       if (external)
+               tc->flags |= TALLOC_FLAG_EXT_ALLOC;
        tc->destructor = NULL;
        tc->child = NULL;
        tc->name = NULL;
        tc->refs = NULL;
 
-       if (likely(context)) {
+       if (likely(parent)) {
                if (parent->child) {
                        parent->child->parent = NULL;
                        tc->next = parent->child;
@@ -238,6 +237,38 @@ alloc_done:
        return TC_PTR_FROM_CHUNK(tc);
 }
 
+/* 
+   Allocate a bit of memory as a child of an existing pointer
+*/
+static inline void *__talloc(const void *context, size_t size)
+{
+       struct talloc_chunk *tc;
+       struct talloc_chunk *parent = NULL;
+       int external = 0;
+
+       if (unlikely(context == NULL)) {
+               context = null_context;
+       }
+
+       if (unlikely(size >= MAX_TALLOC_SIZE)) {
+               return NULL;
+       }
+
+       if (likely(context)) {
+               parent = talloc_chunk_from_ptr(context);
+               if (unlikely(parent->flags & TALLOC_FLAG_EXT_ALLOC)) {
+                       tc = tc_external_realloc(context, NULL,
+                                                TC_HDR_SIZE+size);
+                       external = 1;
+                       goto alloc_done;
+               }
+       }
+
+       tc = (struct talloc_chunk *)malloc(TC_HDR_SIZE+size);
+alloc_done:
+       return init_talloc(parent, tc, size, external);
+}
+
 /*
   setup a destructor to be called on free of a pointer
   the destructor should return 0 on success, or -1 on failure.
@@ -315,11 +346,15 @@ void *_talloc_reference(const void *context, const void *ptr)
        struct talloc_reference_handle *handle;
        if (unlikely(ptr == NULL)) return NULL;
 
+       lock();
        tc = talloc_chunk_from_ptr(ptr);
        handle = (struct talloc_reference_handle *)_talloc_named_const(context,
                                                   sizeof(struct talloc_reference_handle),
                                                   TALLOC_MAGIC_REFERENCE);
-       if (unlikely(handle == NULL)) return NULL;
+       if (unlikely(handle == NULL)) {
+               unlock();
+               return NULL;
+       }
 
        /* note that we hang the destructor off the handle, not the
           main context as that allows the caller to still setup their
@@ -327,9 +362,90 @@ void *_talloc_reference(const void *context, const void *ptr)
        talloc_set_destructor(handle, talloc_reference_destructor);
        handle->ptr = discard_const_p(void, ptr);
        _TLIST_ADD(tc->refs, handle);
+       unlock();
        return handle->ptr;
 }
 
+/*
+  return 1 if ptr is a parent of context
+*/
+static int _talloc_is_parent(const void *context, const void *ptr)
+{
+       struct talloc_chunk *tc;
+
+       if (context == NULL) {
+               return 0;
+       }
+
+       tc = talloc_chunk_from_ptr(context);
+       while (tc) {
+               if (TC_PTR_FROM_CHUNK(tc) == ptr) {
+                       return 1;
+               }
+               while (tc && tc->prev) tc = tc->prev;
+               if (tc) {
+                       tc = tc->parent;
+               }
+       }
+       return 0;
+}
+
+/* 
+   move a lump of memory from one talloc context to another return the
+   ptr on success, or NULL if it could not be transferred.
+   passing NULL as ptr will always return NULL with no side effects.
+*/
+static void *__talloc_steal(const void *new_ctx, const void *ptr)
+{
+       struct talloc_chunk *tc, *new_tc;
+
+       if (unlikely(!ptr)) {
+               return NULL;
+       }
+
+       if (unlikely(new_ctx == NULL)) {
+               new_ctx = null_context;
+       }
+
+       tc = talloc_chunk_from_ptr(ptr);
+
+       if (unlikely(new_ctx == NULL)) {
+               if (tc->parent) {
+                       _TLIST_REMOVE(tc->parent->child, tc);
+                       if (tc->parent->child) {
+                               tc->parent->child->parent = tc->parent;
+                       }
+               } else {
+                       if (tc->prev) tc->prev->next = tc->next;
+                       if (tc->next) tc->next->prev = tc->prev;
+               }
+               
+               tc->parent = tc->next = tc->prev = NULL;
+               return discard_const_p(void, ptr);
+       }
+
+       new_tc = talloc_chunk_from_ptr(new_ctx);
+
+       if (unlikely(tc == new_tc || tc->parent == new_tc)) {
+               return discard_const_p(void, ptr);
+       }
+
+       if (tc->parent) {
+               _TLIST_REMOVE(tc->parent->child, tc);
+               if (tc->parent->child) {
+                       tc->parent->child->parent = tc->parent;
+               }
+       } else {
+               if (tc->prev) tc->prev->next = tc->next;
+               if (tc->next) tc->next->prev = tc->prev;
+       }
+
+       tc->parent = new_tc;
+       if (new_tc->child) new_tc->child->parent = NULL;
+       _TLIST_ADD(new_tc->child, tc);
+
+       return discard_const_p(void, ptr);
+}
 
 /* 
    internal talloc_free call
@@ -354,7 +470,7 @@ static inline int _talloc_free(void *ptr)
                 * call another instance of talloc_free() on the current
                 * pointer.
                 */
-               is_child = talloc_is_parent(tc->refs, ptr);
+               is_child = _talloc_is_parent(tc->refs, ptr);
                _talloc_free(tc->refs);
                if (is_child) {
                        return _talloc_free(ptr);
@@ -412,79 +528,30 @@ static inline int _talloc_free(void *ptr)
                                struct talloc_chunk *p = talloc_parent_chunk(ptr);
                                if (p) new_parent = TC_PTR_FROM_CHUNK(p);
                        }
-                       talloc_steal(new_parent, child);
+                       __talloc_steal(new_parent, child);
                }
        }
 
        tc->flags |= TALLOC_FLAG_FREE;
 
        if (unlikely(tc->flags & TALLOC_FLAG_EXT_ALLOC))
-               tc_external_free(tc, oldparent);
+               tc_external_realloc(oldparent, tc, 0);
        else
                free(tc);
 
        return 0;
 }
 
-/* 
-   move a lump of memory from one talloc context to another return the
-   ptr on success, or NULL if it could not be transferred.
-   passing NULL as ptr will always return NULL with no side effects.
-*/
 void *_talloc_steal(const void *new_ctx, const void *ptr)
 {
-       struct talloc_chunk *tc, *new_tc;
+       void *p;
 
-       if (unlikely(!ptr)) {
-               return NULL;
-       }
-
-       if (unlikely(new_ctx == NULL)) {
-               new_ctx = null_context;
-       }
-
-       tc = talloc_chunk_from_ptr(ptr);
-
-       if (unlikely(new_ctx == NULL)) {
-               if (tc->parent) {
-                       _TLIST_REMOVE(tc->parent->child, tc);
-                       if (tc->parent->child) {
-                               tc->parent->child->parent = tc->parent;
-                       }
-               } else {
-                       if (tc->prev) tc->prev->next = tc->next;
-                       if (tc->next) tc->next->prev = tc->prev;
-               }
-               
-               tc->parent = tc->next = tc->prev = NULL;
-               return discard_const_p(void, ptr);
-       }
-
-       new_tc = talloc_chunk_from_ptr(new_ctx);
-
-       if (unlikely(tc == new_tc || tc->parent == new_tc)) {
-               return discard_const_p(void, ptr);
-       }
-
-       if (tc->parent) {
-               _TLIST_REMOVE(tc->parent->child, tc);
-               if (tc->parent->child) {
-                       tc->parent->child->parent = tc->parent;
-               }
-       } else {
-               if (tc->prev) tc->prev->next = tc->next;
-               if (tc->next) tc->next->prev = tc->prev;
-       }
-
-       tc->parent = new_tc;
-       if (new_tc->child) new_tc->child->parent = NULL;
-       _TLIST_ADD(new_tc->child, tc);
-
-       return discard_const_p(void, ptr);
+       lock();
+       p = __talloc_steal(new_ctx, ptr);
+       unlock();
+       return p;
 }
 
-
-
 /*
   remove a secondary reference to a pointer. This undo's what
   talloc_reference() has done. The context and pointer arguments
@@ -531,16 +598,20 @@ int talloc_unlink(const void *context, void *ptr)
                context = null_context;
        }
 
+       lock();
        if (talloc_unreference(context, ptr) == 0) {
+               unlock();
                return 0;
        }
 
        if (context == NULL) {
                if (talloc_parent_chunk(ptr) != NULL) {
+                       unlock();
                        return -1;
                }
        } else {
                if (talloc_chunk_from_ptr(context) != talloc_parent_chunk(ptr)) {
+                       unlock();
                        return -1;
                }
        }
@@ -548,7 +619,9 @@ int talloc_unlink(const void *context, void *ptr)
        tc_p = talloc_chunk_from_ptr(ptr);
 
        if (tc_p->refs == NULL) {
-               return _talloc_free(ptr);
+               int ret = _talloc_free(ptr);
+               unlock();
+               return ret;
        }
 
        new_p = talloc_parent_chunk(tc_p->refs);
@@ -559,10 +632,12 @@ int talloc_unlink(const void *context, void *ptr)
        }
 
        if (talloc_unreference(new_parent, ptr) != 0) {
+               unlock();
                return -1;
        }
 
-       talloc_steal(new_parent, ptr);
+       __talloc_steal(new_parent, ptr);
+       unlock();
 
        return 0;
 }
@@ -607,7 +682,9 @@ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
        void *ptr;
        const char *name;
 
+       lock();
        ptr = __talloc(context, size);
+       unlock();
        if (unlikely(ptr == NULL)) return NULL;
 
        va_start(ap, fmt);
@@ -615,7 +692,7 @@ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
        va_end(ap);
 
        if (unlikely(name == NULL)) {
-               _talloc_free(ptr);
+               talloc_free(ptr);
                return NULL;
        }
 
@@ -670,7 +747,9 @@ void *talloc_init(const char *fmt, ...)
         */
        talloc_enable_null_tracking();
 
+       lock();
        ptr = __talloc(NULL, 0);
+       unlock();
        if (unlikely(ptr == NULL)) return NULL;
 
        va_start(ap, fmt);
@@ -678,50 +757,13 @@ void *talloc_init(const char *fmt, ...)
        va_end(ap);
 
        if (unlikely(name == NULL)) {
-               _talloc_free(ptr);
+               talloc_free(ptr);
                return NULL;
        }
 
        return ptr;
 }
 
-/*
-  this is a replacement for the Samba3 talloc_destroy_pool functionality. It
-  should probably not be used in new code. It's in here to keep the talloc
-  code consistent across Samba 3 and 4.
-*/
-void talloc_free_children(void *ptr)
-{
-       struct talloc_chunk *tc;
-
-       if (unlikely(ptr == NULL)) {
-               return;
-       }
-
-       tc = talloc_chunk_from_ptr(ptr);
-
-       while (tc->child) {
-               /* we need to work out who will own an abandoned child
-                  if it cannot be freed. In priority order, the first
-                  choice is owner of any remaining reference to this
-                  pointer, the second choice is our parent, and the
-                  final choice is the null context. */
-               void *child = TC_PTR_FROM_CHUNK(tc->child);
-               const void *new_parent = null_context;
-               if (unlikely(tc->child->refs)) {
-                       struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
-                       if (p) new_parent = TC_PTR_FROM_CHUNK(p);
-               }
-               if (unlikely(_talloc_free(child) == -1)) {
-                       if (new_parent == null_context) {
-                               struct talloc_chunk *p = talloc_parent_chunk(ptr);
-                               if (p) new_parent = TC_PTR_FROM_CHUNK(p);
-                       }
-                       talloc_steal(new_parent, child);
-               }
-       }
-}
-
 /* 
    Allocate a bit of memory as a child of an existing pointer
 */
@@ -745,7 +787,11 @@ void talloc_set_name_const(const void *ptr, const char *name)
 */
 void *talloc_named_const(const void *context, size_t size, const char *name)
 {
-       return _talloc_named_const(context, size, name);
+       void *p;
+       lock();
+       p = _talloc_named_const(context, size, name);
+       unlock();
+       return p;
 }
 
 /* 
@@ -759,7 +805,9 @@ void *talloc_named_const(const void *context, size_t size, const char *name)
 int talloc_free(void *ptr)
 {
        int saved_errno = errno, ret;
+       lock();
        ret = _talloc_free(ptr);
+       unlock();
        if (ret == 0)
                errno = saved_errno;
        return ret;
@@ -778,7 +826,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 
        /* size zero is equivalent to free() */
        if (unlikely(size == 0)) {
-               _talloc_free(ptr);
+               talloc_free(ptr);
                return NULL;
        }
 
@@ -788,7 +836,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 
        /* realloc(NULL) is equivalent to malloc() */
        if (ptr == NULL) {
-               return _talloc_named_const(context, size, name);
+               return talloc_named_const(context, size, name);
        }
 
        tc = talloc_chunk_from_ptr(ptr);
@@ -798,11 +846,12 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
                return NULL;
        }
 
+       lock();
        if (unlikely(tc->flags & TALLOC_FLAG_EXT_ALLOC)) {
                /* need to get parent before setting free flag. */
                void *parent = talloc_parent(ptr);
                tc->flags |= TALLOC_FLAG_FREE;
-               new_ptr = tc_external_realloc(tc, parent, size + TC_HDR_SIZE);
+               new_ptr = tc_external_realloc(parent, tc, size + TC_HDR_SIZE);
        } else {
                /* by resetting magic we catch users of the old memory */
                tc->flags |= TALLOC_FLAG_FREE;
@@ -820,6 +869,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 
        if (unlikely(!new_ptr)) {       
                tc->flags &= ~TALLOC_FLAG_FREE; 
+               unlock();
                return NULL; 
        }
 
@@ -841,6 +891,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
 
        tc->size = size;
        _talloc_set_name_const(TC_PTR_FROM_CHUNK(tc), name);
+       unlock();
 
        return TC_PTR_FROM_CHUNK(tc);
 }
@@ -860,18 +911,11 @@ void *_talloc_move(const void *new_ctx, const void *_pptr)
 /*
   return the total size of a talloc pool (subtree)
 */
-size_t talloc_total_size(const void *ptr)
+static size_t _talloc_total_size(const void *ptr)
 {
        size_t total = 0;
        struct talloc_chunk *c, *tc;
 
-       if (ptr == NULL) {
-               ptr = null_context;
-       }
-       if (ptr == NULL) {
-               return 0;
-       }
-
        tc = talloc_chunk_from_ptr(ptr);
 
        if (tc->flags & TALLOC_FLAG_LOOP) {
@@ -882,7 +926,7 @@ size_t talloc_total_size(const void *ptr)
 
        total = tc->size;
        for (c=tc->child;c;c=c->next) {
-               total += talloc_total_size(TC_PTR_FROM_CHUNK(c));
+               total += _talloc_total_size(TC_PTR_FROM_CHUNK(c));
        }
 
        tc->flags &= ~TALLOC_FLAG_LOOP;
@@ -890,10 +934,27 @@ size_t talloc_total_size(const void *ptr)
        return total;
 }
 
+size_t talloc_total_size(const void *ptr)
+{
+       size_t total;
+
+       if (ptr == NULL) {
+               ptr = null_context;
+       }
+       if (ptr == NULL) {
+               return 0;
+       }
+
+       lock();
+       total = _talloc_total_size(ptr);
+       unlock();
+       return total;
+}      
+
 /*
   return the total number of blocks in a talloc pool (subtree)
 */
-size_t talloc_total_blocks(const void *ptr)
+static size_t _talloc_total_blocks(const void *ptr)
 {
        size_t total = 0;
        struct talloc_chunk *c, *tc = talloc_chunk_from_ptr(ptr);
@@ -906,7 +967,7 @@ size_t talloc_total_blocks(const void *ptr)
 
        total++;
        for (c=tc->child;c;c=c->next) {
-               total += talloc_total_blocks(TC_PTR_FROM_CHUNK(c));
+               total += _talloc_total_blocks(TC_PTR_FROM_CHUNK(c));
        }
 
        tc->flags &= ~TALLOC_FLAG_LOOP;
@@ -914,6 +975,17 @@ size_t talloc_total_blocks(const void *ptr)
        return total;
 }
 
+size_t talloc_total_blocks(const void *ptr)
+{
+       size_t total;
+
+       lock();
+       total = _talloc_total_blocks(ptr);
+       unlock();
+
+       return total;
+}
+
 /*
   return the number of external references to a pointer
 */
@@ -923,16 +995,18 @@ size_t talloc_reference_count(const void *ptr)
        struct talloc_reference_handle *h;
        size_t ret = 0;
 
+       lock();
        for (h=tc->refs;h;h=h->next) {
                ret++;
        }
+       unlock();
        return ret;
 }
 
 /*
   report on memory usage by all children of a pointer, giving a full tree view
 */
-void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
+static void _talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
                            void (*callback)(const void *ptr,
                                             int depth, int max_depth,
                                             int is_ref,
@@ -941,11 +1015,6 @@ void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
 {
        struct talloc_chunk *c, *tc;
 
-       if (ptr == NULL) {
-               ptr = null_context;
-       }
-       if (ptr == NULL) return;
-
        tc = talloc_chunk_from_ptr(ptr);
 
        if (tc->flags & TALLOC_FLAG_LOOP) {
@@ -964,12 +1033,29 @@ void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
                        struct talloc_reference_handle *h = (struct talloc_reference_handle *)TC_PTR_FROM_CHUNK(c);
                        callback(h->ptr, depth + 1, max_depth, 1, private_data);
                } else {
-                       talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
+                       _talloc_report_depth_cb(TC_PTR_FROM_CHUNK(c), depth + 1, max_depth, callback, private_data);
                }
        }
        tc->flags &= ~TALLOC_FLAG_LOOP;
 }
 
+void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
+                           void (*callback)(const void *ptr,
+                                            int depth, int max_depth,
+                                            int is_ref,
+                                            void *private_data),
+                           void *private_data)
+{
+       if (ptr == NULL) {
+               ptr = null_context;
+       }
+       if (ptr == NULL) return;
+
+       lock();
+       _talloc_report_depth_cb(ptr, depth, max_depth, callback, private_data);
+       unlock();
+}
+
 static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_f)
 {
        const char *name = talloc_get_name(ptr);
@@ -1063,9 +1149,11 @@ static void talloc_report_null_full(void)
 */
 void talloc_enable_null_tracking(void)
 {
+       lock();
        if (null_context == NULL) {
                null_context = _talloc_named_const(NULL, 0, "null_context");
        }
+       unlock();
 }
 
 /*
@@ -1073,8 +1161,10 @@ void talloc_enable_null_tracking(void)
 */
 void talloc_disable_null_tracking(void)
 {
+       lock();
        _talloc_free(null_context);
        null_context = NULL;
+       unlock();
 }
 
 /*
@@ -1100,7 +1190,11 @@ void talloc_enable_leak_report_full(void)
 */
 void *_talloc_zero(const void *ctx, size_t size, const char *name)
 {
-       void *p = _talloc_named_const(ctx, size, name);
+       void *p;
+
+       lock();
+       p = _talloc_named_const(ctx, size, name);
+       unlock();
 
        if (p) {
                memset(p, '\0', size);
@@ -1114,7 +1208,11 @@ void *_talloc_zero(const void *ctx, size_t size, const char *name)
 */
 void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
 {
-       void *newp = _talloc_named_const(t, size, name);
+       void *newp;
+
+       lock();
+       newp = _talloc_named_const(t, size, name);
+       unlock();
 
        if (likely(newp)) {
                memcpy(newp, p, size);
@@ -1175,7 +1273,9 @@ char *talloc_strndup(const void *t, const char *p, size_t n)
 
        for (len=0; len<n && p[len]; len++) ;
 
+       lock();
        ret = (char *)__talloc(t, len + 1);
+       unlock();
        if (!ret) { return NULL; }
        memcpy(ret, p, len);
        ret[len] = 0;
@@ -1198,7 +1298,9 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
                return NULL;
        }
 
+       lock();
        ret = (char *)__talloc(t, len+1);
+       unlock();
        if (ret) {
                va_copy(ap2, ap);
                vsnprintf(ret, len+1, fmt, ap2);
@@ -1291,10 +1393,15 @@ char *talloc_asprintf_append(char *s, const char *fmt, ...)
 */
 void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
 {
+       void *p;
+
        if (count >= MAX_TALLOC_SIZE/el_size) {
                return NULL;
        }
-       return _talloc_named_const(ctx, el_size * count, name);
+       lock();
+       p = _talloc_named_const(ctx, el_size * count, name);
+       unlock();
+       return p;
 }
 
 /*
@@ -1302,10 +1409,15 @@ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char
 */
 void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
 {
+       void *p;
+
        if (count >= MAX_TALLOC_SIZE/el_size) {
                return NULL;
        }
-       return _talloc_zero(ctx, el_size * count, name);
+       lock();
+       p = _talloc_zero(ctx, el_size * count, name);
+       unlock();
+       return p;
 }
 
 /*
@@ -1339,7 +1451,7 @@ static int talloc_autofree_destructor(void *ptr)
 static void talloc_autofree(void)
 {
        if (autofree_context && *autofree_context == getpid())
-               _talloc_free(autofree_context);
+               talloc_free(autofree_context);
 }
 
 /*
@@ -1382,9 +1494,11 @@ void *talloc_find_parent_byname(const void *context, const char *name)
                return NULL;
        }
 
+       lock();
        tc = talloc_chunk_from_ptr(context);
        while (tc) {
                if (tc->name && strcmp(tc->name, name) == 0) {
+                       unlock();
                        return TC_PTR_FROM_CHUNK(tc);
                }
                while (tc && tc->prev) tc = tc->prev;
@@ -1392,6 +1506,7 @@ void *talloc_find_parent_byname(const void *context, const char *name)
                        tc = tc->parent;
                }
        }
+       unlock();
        return NULL;
 }
 
@@ -1407,6 +1522,7 @@ void talloc_show_parents(const void *context, FILE *file)
                return;
        }
 
+       lock();
        tc = talloc_chunk_from_ptr(context);
        fprintf(file, "talloc parents of '%s'\n", talloc_get_name(context));
        while (tc) {
@@ -1416,48 +1532,46 @@ void talloc_show_parents(const void *context, FILE *file)
                        tc = tc->parent;
                }
        }
+       unlock();
        fflush(file);
 }
 
-/*
-  return 1 if ptr is a parent of context
-*/
 int talloc_is_parent(const void *context, const void *ptr)
 {
-       struct talloc_chunk *tc;
-
-       if (context == NULL) {
-               return 0;
-       }
-
-       tc = talloc_chunk_from_ptr(context);
-       while (tc) {
-               if (TC_PTR_FROM_CHUNK(tc) == ptr) return 1;
-               while (tc && tc->prev) tc = tc->prev;
-               if (tc) {
-                       tc = tc->parent;
-               }
-       }
-       return 0;
+       int ret;
+       lock();
+       ret = _talloc_is_parent(context, ptr);
+       unlock();
+       return ret;
 }
 
-void talloc_external_enable(void *(*alloc)(void *parent, size_t size),
-                           void (*free)(void *ptr, void *parent),
-                           void *(*realloc)(void *ptr, void *parent, size_t))
+void *talloc_add_external(const void *ctx,
+                         void *(*realloc)(const void *, void *, size_t))
 {
-       tc_external_alloc = alloc;
-       tc_external_free = free;
+       struct talloc_chunk *tc, *parent;
+       void *p;
+
+       lock();
+       if (tc_external_realloc && tc_external_realloc != realloc)
+               TALLOC_ABORT("talloc_add_external realloc replaced");
        tc_external_realloc = realloc;
-}
 
-void talloc_mark_external(void *context)
-{
-       struct talloc_chunk *tc;
+       if (unlikely(ctx == NULL)) {
+               ctx = null_context;
+               parent = NULL;
+       } else
+               parent = talloc_chunk_from_ptr(ctx);    
 
-       if (unlikely(context == NULL)) {
-               context = null_context;
-       }
+       tc = tc_external_realloc(ctx, NULL, TC_HDR_SIZE);
+       p = init_talloc(parent, tc, 0, 1);
+       unlock();
 
-       tc = talloc_chunk_from_ptr(context);
-       tc->flags |= TALLOC_FLAG_EXT_ALLOC;
+       return p;
+}
+
+void _talloc_locksafe(void (*lock)(void *), void (*unlock)(void *), void *data)
+{
+       tc_lock = lock;
+       tc_unlock = unlock;
+       tc_lock_data = data;
 }
index 8b0f8a38bc82d6782dbe29c2a56c4d3c1daaab63..2c55a12a987d4c0d4b2c83b993e85cf775d140bc 100644 (file)
@@ -398,21 +398,6 @@ void talloc_report(const void *ptr, FILE *f);
  */
 #define talloc_ptrtype(ctx, ptr) (_TALLOC_TYPEOF(ptr))talloc_size(ctx, sizeof(*(ptr)))
 
-/**
- * talloc_free_children - free talloc'ed memory's children only
- * @ptr: the talloced pointer whose children we want to free
- *
- * talloc_free_children() walks along the list of all children of a talloc
- * context @ptr and talloc_free()s only the children, not the context itself.
- * Example:
- *     unsigned int *a, *b;
- *     a = talloc(NULL, unsigned int);
- *     b = talloc(a, unsigned int);
- *     // Frees b
- *     talloc_free_children(a);
- */
-void talloc_free_children(void *ptr);
-
 /**
  * talloc_new - create a new context
  * @ctx: the context to use as a parent.
@@ -929,30 +914,39 @@ size_t talloc_get_size(const void *ctx);
 void *talloc_find_parent_byname(const void *ctx, const char *name);
 
 /**
- * talloc_external_enable - set external allocators for some nodes
- * @alloc: the malloc() equivalent
- * @free: the free() equivalent
+ * talloc_add_external - create an externally allocated node
+ * @ctx: the parent
  * @realloc: the realloc() equivalent
  *
- * talloc_mark_external() can be used to mark nodes whose children should
- * use separate allocators.  Currently the set of allocators is global, not
- * per-node, and is set with this function.
+ * talloc_add_external() creates a node which uses a separate allocator.  All
+ * children allocated from that node will also use that allocator.
+ *
+ * Note: Currently there is only one external allocator, not per-node,
+ * and it is set with this function.
  *
- * The parent pointers is the talloc pointer of the parent.
+ * The parent pointers in realloc is the talloc pointer of the parent, if any.
  */
-void talloc_external_enable(void *(*alloc)(void *parent, size_t size),
-                           void (*free)(void *ptr, void *parent),
-                           void *(*realloc)(void *ptr, void *parent, size_t));
+void *talloc_add_external(const void *ctx,
+                         void *(*realloc)(const void *parent,
+                                          void *ptr, size_t));
 
 /**
- * talloc_mark_external - children of this note must use external allocators
- * @p: the talloc pointer
+ * talloc_locksafe - set locking for talloc on shared memory
+ * @lock: function to use to lock memory
+ * @unlock: function to use to unlock memory
+ * @data: pointer to hand to @lock and @unlock
  *
- * This function indicates that all children (and children's children etc)
- * should use the allocators set up wth talloc_external_enable() rather than
- * normal malloc/free.
- */
-void talloc_mark_external(void *ptr);
+ * If talloc is actually dealing with shared memory (threads or shared
+ * memory using talloc_add_external()) then locking is required on
+ * allocation and free to avoid corruption.
+ *
+ * These hooks allow a very course-grained locking scheme: @lock is
+ * called before any internal alloc or free, and @unlock is called
+ * after. */
+#define talloc_locksafe(lock, unlock, data)                    \
+       _talloc_locksafe(typesafe_cb(void, lock, data),         \
+                        typesafe_cb(void, unlock, data),       \
+                        data)
 
 /* The following definitions come from talloc.c  */
 void *_talloc(const void *context, size_t size);
@@ -973,5 +967,6 @@ void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned
 void *talloc_realloc_fn(const void *context, void *ptr, size_t size);
 void talloc_show_parents(const void *context, FILE *file);
 int talloc_is_parent(const void *context, const void *ptr);
+void _talloc_locksafe(void (*lock)(void *), void (*unlock)(void *), void *);
 
 #endif /* CCAN_TALLOC_H */
index 85b3b0140f04d6178ea9efcc3085b1e8752b2294..fb1e17e95f1e14301b2d132b34dd0f0672fff67d 100644 (file)
@@ -5,47 +5,37 @@
 static int ext_alloc_count, ext_free_count, ext_realloc_count;
 static void *expected_parent;
 
-static void *ext_alloc(void *parent, size_t size)
+static void *ext_realloc(const void *parent, void *ptr, size_t size)
 {
        ok1(parent == expected_parent);
-       ext_alloc_count++;
-       return malloc(size);
-}
-
-static void ext_free(void *ptr, void *parent)
-{
-       ok1(parent == expected_parent);
-       ext_free_count++;
-       free(ptr);
-}
-
-static void *ext_realloc(void *ptr, void *parent, size_t size)
-{
-       ok1(parent == expected_parent);
-       ext_realloc_count++;
+       if (ptr == NULL)
+               ext_alloc_count++;
+       if (size == 0)
+               ext_free_count++;
+       if (ptr && size)
+               ext_realloc_count++;
        return realloc(ptr, size);
 }
 
 int main(void)
 {
        char *p, *p2, *head;
-       plan_tests(10);
+       plan_tests(12);
 
-       talloc_external_enable(ext_alloc, ext_free, ext_realloc);
-       head = talloc(NULL, char);
+       expected_parent = NULL;
+       head = talloc_add_external(NULL, ext_realloc);
        assert(head);
-       expected_parent = head;
-
-       talloc_mark_external(head);
+       ok1(ext_alloc_count == 1);
 
+       expected_parent = head;
        p = talloc_array(head, char, 1);
-       ok1(ext_alloc_count == 1);
+       ok1(ext_alloc_count == 2);
        assert(p);
 
        /* Child is also externally allocated */
        expected_parent = p;
        p2 = talloc(p, char);
-       ok1(ext_alloc_count == 2);
+       ok1(ext_alloc_count == 3);
 
        expected_parent = head;
        p = talloc_realloc(NULL, p, char, 1000);
index 7369186c08f5b5754c4988618b16a1561a63c3f9..32fe47b554cdc78ca75b11c5f8be8855c9d905eb 100644 (file)
@@ -861,11 +861,31 @@ static bool torture_local_talloc(struct torture_context *tctx)
        return ret;
 }
 
+static int lock_failed = 0, unlock_failed = 0;
+static void test_lock(int *locked)
+{
+       if (*locked)
+               lock_failed++;
+       *locked = 1;
+}
+
+static void test_unlock(int *locked)
+{
+       if (!*locked)
+               unlock_failed++;
+       *locked = 0;
+}
+
 int main(void)
 {
-       plan_tests(134);
+       int locked = 0;
+
+       plan_tests(136);
+       talloc_locksafe(test_lock, test_unlock, &locked);
 
        torture_local_talloc(NULL);
+       ok(!lock_failed, "lock_failed count %u should be zero", lock_failed);
+       ok(!unlock_failed, "unlock_failed count %u should be zero", unlock_failed);
        return exit_status();
 }