grab_fd and grab_file: add a size arg, use everywhere.
[ccan] / ccan / talloc / talloc.h
index 7da8d975d5bdfd7eda86dc2246987d923c6683cb..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.
@@ -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__)
 
@@ -928,6 +913,41 @@ size_t talloc_get_size(const void *ctx);
  */
 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
+ *
+ * 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 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));
+
+/**
+ * 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 *));
@@ -947,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 */