talloc_free() should take a const void *, a-la free().

[ccan] / ccan / talloc / talloc.h

diff --git a/ccan/talloc/talloc.h b/ccan/talloc/talloc.h
index da416a4b77e27acc619b10f4e676286444be1784..e38d05b8095ca9d55abdbd8e9ac833e31ca08c0c 100644 (file)
--- a/ccan/talloc/talloc.h
+++ b/ccan/talloc/talloc.h
@@ -26,8 +26,8 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <ccan/typesafe_cb/typesafe_cb.h>
 #include "config.h"
-#include "ccan/typesafe_cb/typesafe_cb.h"
 
 /*
   this uses a little trick to allow __LINE__ to be stringified
@@ -119,7 +119,7 @@
  * See Also:
  *     talloc_set_destructor, talloc_unlink
  */
-int talloc_free(void *ptr);
+int talloc_free(const void *ptr);
 
 /**
  * talloc_set_destructor: set a destructor for when this pointer is freed
@@ -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.
@@ -442,12 +427,12 @@ void talloc_free_children(void *ptr);
 #define talloc_zero_array(ctx, type, count) (type *)_talloc_zero_array(ctx, sizeof(type), count, #type)
 
 /**
- * talloc_zero_array - allocate an array of zeroed types
+ * talloc_array_size - allocate an array of elements of the given size
  * @ctx: context to be parent of this allocation, or NULL.
- * @type: the type to be allocated.
+ * @size: the size of each element
  * @count: the number of elements to be allocated.
  *
- * Just like talloc_array, but zeroes the memory.
+ * Typeless form of talloc_array.
  */
 #define talloc_array_size(ctx, size, count) _talloc_array(ctx, size, count, __location__)
 
@@ -929,30 +914,29 @@ 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
+ * @lock: the call to lock before manipulation of external nodes
+ * @unlock: the call to unlock after manipulation of external nodes
  *
- * 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.
  *
- * The parent pointers is the talloc pointer of the parent.
- */
-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));
-
-/**
- * talloc_mark_external - children of this note must use external allocators
- * @p: the talloc pointer
+ * Note: Currently there is only one external allocator, not per-node,
+ * and it is set with this function.
+ *
+ * @lock is handed a pointer which was previous returned from your realloc
+ * function; you should use that to figure out which lock to get if you have
+ * multiple external pools.
  *
- * 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.
+ * The parent pointers in realloc is the talloc pointer of the parent, if any.
  */
-void talloc_mark_external(void *ptr);
+void *talloc_add_external(const void *ctx,
+                         void *(*realloc)(const void *parent,
+                                          void *ptr, size_t),
+                         void (*lock)(const void *p),
+                         void (*unlock)(void));
 
 /* The following definitions come from talloc.c  */
 void *_talloc(const void *context, size_t size);