X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftalloc%2Ftalloc.h;h=e4f15aeecbb1b9dde7909525da89e88c727936e9;hp=e06f592b4630de7cdf1fa960a5253342231a1eed;hb=d7c0cfeb86f8a6474d2fa182c0325e0d3aee0ecd;hpb=794a6678aa37e8864845c72b14213ca44b9e159e

diff --git a/ccan/talloc/talloc.h b/ccan/talloc/talloc.h
index e06f592b..e4f15aee 100644
--- 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
@@ -87,6 +87,30 @@
  */
 #define talloc(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)
 
+/**
+ * talloc_set - allocate dynamic memory for a type, into a pointer
+ * @ptr: pointer to the pointer to assign.
+ * @ctx: context to be parent of this allocation, or NULL.
+ *
+ * talloc_set() does a talloc, but also adds a destructor which will make the
+ * pointer invalid when it is freed.  This can find many use-after-free bugs.
+ *
+ * Note that the destructor is chained off a zero-length allocation, and so
+ * is not affected by talloc_set_destructor().
+ *
+ * Example:
+ *	unsigned int *a;
+ *	a = talloc(NULL, unsigned int);
+ *	talloc_set(&b, a, unsigned int);
+ *	talloc_free(a);
+ *	*b = 1; // This will crash!
+ *
+ * See Also:
+ *	talloc.
+ */
+#define talloc_set(pptr, ctx) \
+	_talloc_set((pptr), (ctx), sizeof(&**(pptr)), __location__)
+
 /**
  * talloc_free - free talloc'ed memory and its children
  * @ptr: the talloced pointer to free
@@ -119,7 +143,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
@@ -172,7 +196,7 @@ int talloc_free(void *ptr);
  *	talloc, talloc_free
  */
 #define talloc_set_destructor(ptr, function)				      \
-	_talloc_set_destructor((ptr), typesafe_cb(int, (function), (ptr)))
+	_talloc_set_destructor((ptr), typesafe_cb_def(int, (function), (ptr)))
 
 /**
  * talloc_zero - allocate zeroed dynamic memory for a type
@@ -398,21 +422,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.
@@ -932,6 +941,8 @@ void *talloc_find_parent_byname(const void *ctx, const char *name);
  * 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_add_external() creates a node which uses a separate allocator.  All
  * children allocated from that node will also use that allocator.
@@ -939,14 +950,21 @@ void *talloc_find_parent_byname(const void *ctx, const char *name);
  * 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.
+ *
  * The parent pointers in realloc is the talloc pointer of the parent, if any.
  */
 void *talloc_add_external(const void *ctx,
 			  void *(*realloc)(const void *parent,
-					   void *ptr, size_t));
+					   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);
+void _talloc_set(void *ptr, const void *ctx, size_t size, const char *name);
 void _talloc_set_destructor(const void *ptr, int (*destructor)(void *));
 size_t talloc_reference_count(const void *ptr);
 void *_talloc_reference(const void *context, const void *ptr);