Simple locking for talloc.

ccan/talloc/talloc.h

@@ -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.
@@ -945,6 +930,24 @@ void *talloc_add_external(const void *ctx,
 			  void *(*realloc)(const void *parent,
 					   void *ptr, size_t));
 
+/**
+ * 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
+ *
+ * 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);
 void _talloc_set_destructor(const void *ptr, int (*destructor)(void *));
@@ -964,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 */

ccan/talloc/test/run.c

@@ -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();
 }