*/
#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.
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);
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 */