summaryrefslogtreecommitdiffstats
path: root/ta
diff options
context:
space:
mode:
Diffstat (limited to 'ta')
-rw-r--r--ta/README39
-rw-r--r--ta/ta.c439
-rw-r--r--ta/ta.h146
-rw-r--r--ta/ta_talloc.c75
-rw-r--r--ta/ta_talloc.h74
-rw-r--r--ta/ta_utils.c320
6 files changed, 1093 insertions, 0 deletions
diff --git a/ta/README b/ta/README
new file mode 100644
index 0000000000..cd98c1a5ae
--- /dev/null
+++ b/ta/README
@@ -0,0 +1,39 @@
+TA ("Tree Allocator") is a wrapper around malloc() and related functions,
+adding features like automatically free sub-trees of memory allocations if
+a parent allocation is freed.
+
+Generally, the idea is that every TA allocation can have a parent (indicated
+by the ta_parent argument in allocation function calls). If a parent is freed,
+its child allocations are automatically freed as well. It's also allowed the
+free a child before the parent, or to move a child to another parent with
+ta_set_parent().
+
+It also provides a bunch of convenience macros and debugging facilities.
+
+The TA functions are documented in the implementation files (ta.c, ta_utils.c).
+
+TA is intended to be useable as library independent from mpv. It doesn't
+depend on anything mpv specific.
+
+Note:
+-----
+
+mpv doesn't use the TA API yet for two reasons: first, the TA API is not
+necessarily finalized yet. Second, it should be easily possible to revert
+the commit adding TA, and changing all the code would not allow this.
+
+Especially the naming schema for some TA functions is still somewhat
+undecided. (The talloc naming is a bit verbose at times.)
+
+For now, mpv goes through a talloc wrapper, which maps the talloc API to TA.
+New code should still use talloc as well. At one point, all talloc calls
+will be replaced with TA calls, and the talloc wrapper will be removed.
+
+Documentation for the talloc API is here:
+
+ http://git.samba.org/?p=samba.git;a=blob;f=lib/talloc/talloc.h;hb=HEAD
+
+There are some minor differences with mpv's talloc bridge. mpv calls abort()
+on allocation failures, and the talloc_set_destructor() signature is slightly
+different. libtalloc also has a weird 256MB limit per allocation. The talloc
+wrapper supports only a strict subset of libtalloc functionality used by mpv.
diff --git a/ta/ta.c b/ta/ta.c
new file mode 100644
index 0000000000..568f6d5f1b
--- /dev/null
+++ b/ta/ta.c
@@ -0,0 +1,439 @@
+/* Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+
+#define TA_NO_WRAPPERS
+#include "ta.h"
+
+// Note: the actual minimum alignment is dictated by malloc(). It doesn't
+// make sense to set this value higher than malloc's alignment.
+#define MIN_ALIGN 16
+
+#ifndef NDEBUG
+#define TA_MEMORY_DEBUGGING
+#endif
+
+struct ta_header {
+ size_t size; // size of the user allocation
+ struct ta_header *prev; // ring list containing siblings
+ struct ta_header *next;
+ struct ta_ext_header *ext;
+#ifdef TA_MEMORY_DEBUGGING
+ unsigned int canary;
+ struct ta_header *leak_next;
+ struct ta_header *leak_prev;
+ const char *name;
+#endif
+};
+
+#define CANARY 0xD3ADB3EF
+
+union aligned_header {
+ struct ta_header ta;
+ // Make sure to satisfy typical alignment requirements
+ void *align_ptr;
+ int align_int;
+ double align_d;
+ long long align_ll;
+ char align_min[(sizeof(struct ta_header) + MIN_ALIGN - 1) & ~(MIN_ALIGN - 1)];
+};
+
+#define PTR_TO_HEADER(ptr) (&((union aligned_header *)(ptr) - 1)->ta)
+#define PTR_FROM_HEADER(h) ((void *)((union aligned_header *)(h) + 1))
+
+#define MAX_ALLOC (((size_t)-1) - sizeof(union aligned_header))
+
+// Needed for non-leaf allocations, or extended features such as destructors.
+struct ta_ext_header {
+ struct ta_header *header; // points back to normal header
+ struct ta_header children; // list of children, with this as sentinel
+ void (*destructor)(void *);
+};
+
+// ta_ext_header.children.size is set to this
+#define CHILDREN_SENTINEL ((size_t)-1)
+
+static void ta_dbg_add(struct ta_header *h);
+static void ta_dbg_check_header(struct ta_header *h);
+static void ta_dbg_remove(struct ta_header *h);
+
+static struct ta_header *get_header(void *ptr)
+{
+ struct ta_header *h = ptr ? PTR_TO_HEADER(ptr) : NULL;
+ ta_dbg_check_header(h);
+ return h;
+}
+
+static struct ta_ext_header *get_or_alloc_ext_header(void *ptr)
+{
+ struct ta_header *h = get_header(ptr);
+ if (!h)
+ return NULL;
+ if (!h->ext) {
+ h->ext = malloc(sizeof(struct ta_ext_header));
+ if (!h->ext)
+ return NULL;
+ *h->ext = (struct ta_ext_header) {
+ .header = h,
+ .children = {
+ .next = &h->ext->children,
+ .prev = &h->ext->children,
+ // Needed by ta_find_parent():
+ .size = CHILDREN_SENTINEL,
+ .ext = h->ext,
+ },
+ };
+ }
+ return h->ext;
+}
+
+/* Set the parent allocation of ptr. If parent==NULL, remove the parent.
+ * Setting parent==NULL (with ptr!=NULL) always succeeds, and unsets the
+ * parent of ptr. Operations ptr==NULL always succeed and do nothing.
+ * Returns true on success, false on OOM.
+ */
+bool ta_set_parent(void *ptr, void *ta_parent)
+{
+ struct ta_header *ch = get_header(ptr);
+ if (!ch)
+ return true;
+ struct ta_ext_header *parent_eh = get_or_alloc_ext_header(ta_parent);
+ if (ta_parent && !parent_eh) // do nothing on OOM
+ return false;
+ // Unlink from previous parent
+ if (ch->next) {
+ ch->next->prev = ch->prev;
+ ch->prev->next = ch->next;
+ ch->next = ch->prev = NULL;
+ }
+ // Link to new parent - insert at end of list (possibly orders destructors)
+ if (parent_eh) {
+ struct ta_header *children = &parent_eh->children;
+ ch->next = children;
+ ch->prev = children->prev;
+ children->prev->next = ch;
+ children->prev = ch;
+ }
+ return true;
+}
+
+/* Allocate size bytes of memory. If ta_parent is not NULL, this is used as
+ * parent allocation (if ta_parent is freed, this allocation is automatically
+ * freed as well). size==0 allocates a block of size 0 (i.e. returns non-NULL).
+ * Returns NULL on OOM.
+ */
+void *ta_alloc_size(void *ta_parent, size_t size)
+{
+ if (size >= MAX_ALLOC)
+ return NULL;
+ struct ta_header *h = malloc(sizeof(union aligned_header) + size);
+ if (!h)
+ return NULL;
+ *h = (struct ta_header) {.size = size};
+ ta_dbg_add(h);
+ void *ptr = PTR_FROM_HEADER(h);
+ if (!ta_set_parent(ptr, ta_parent)) {
+ ta_free(ptr);
+ return NULL;
+ }
+ return ptr;
+}
+
+/* Exactly the same as ta_alloc_size(), but the returned memory block is
+ * initialized to 0.
+ */
+void *ta_zalloc_size(void *ta_parent, size_t size)
+{
+ if (size >= MAX_ALLOC)
+ return NULL;
+ struct ta_header *h = calloc(1, sizeof(union aligned_header) + size);
+ if (!h)
+ return NULL;
+ *h = (struct ta_header) {.size = size};
+ ta_dbg_add(h);
+ void *ptr = PTR_FROM_HEADER(h);
+ if (!ta_set_parent(ptr, ta_parent)) {
+ ta_free(ptr);
+ return NULL;
+ }
+ return ptr;
+}
+
+/* Reallocate the allocation given by ptr and return a new pointer. Much like
+ * realloc(), the returned pointer can be different, and on OOM, NULL is
+ * returned.
+ *
+ * size==0 is equivalent to ta_free(ptr).
+ * ptr==NULL is equivalent to ta_alloc_size(ta_parent, size).
+ *
+ * ta_parent is used only in the ptr==NULL case.
+ *
+ * Returns NULL if the operation failed.
+ * NULL is also returned if size==0.
+ */
+void *ta_realloc_size(void *ta_parent, void *ptr, size_t size)
+{
+ if (size >= MAX_ALLOC)
+ return NULL;
+ if (!size) {
+ ta_free(ptr);
+ return NULL;
+ }
+ if (!ptr)
+ return ta_alloc_size(ta_parent, size);
+ struct ta_header *h = get_header(ptr);
+ struct ta_header *old_h = h;
+ if (h->size == size)
+ return ptr;
+ ta_dbg_remove(h);
+ h = realloc(h, sizeof(union aligned_header) + size);
+ ta_dbg_add(h ? h : old_h);
+ if (!h)
+ return NULL;
+ h->size = size;
+ if (h != old_h) {
+ if (h->next) {
+ // Relink siblings
+ h->next->prev = h;
+ h->prev->next = h;
+ }
+ if (h->ext) {
+ // Relink children
+ h->ext->header = h;
+ h->ext->children.next->prev = &h->ext->children;
+ h->ext->children.prev->next = &h->ext->children;
+ }
+ }
+ return PTR_FROM_HEADER(h);
+}
+
+/* Return the allocated size of ptr. This returns the size parameter of the
+ * most recent ta_alloc.../ta_realloc... call.
+ * If ptr==NULL, return 0.
+ */
+size_t ta_get_size(void *ptr)
+{
+ struct ta_header *h = get_header(ptr);
+ return h ? h->size : 0;
+}
+
+/* Free all allocations that (recursively) have ptr as parent allocation, but
+ * do not free ptr itself.
+ */
+void ta_free_children(void *ptr)
+{
+ struct ta_header *h = get_header(ptr);
+ struct ta_ext_header *eh = h ? h->ext : NULL;
+ if (!eh)
+ return;
+ while (eh->children.next != &eh->children)
+ ta_free(PTR_FROM_HEADER(eh->children.next));
+}
+
+/* Free the given allocation, and all of its direct and indirect children.
+ */
+void ta_free(void *ptr)
+{
+ struct ta_header *h = get_header(ptr);
+ if (!h)
+ return;
+ if (h->ext && h->ext->destructor)
+ h->ext->destructor(ptr);
+ ta_free_children(ptr);
+ if (h->next) {
+ // Unlink from sibling list
+ h->next->prev = h->prev;
+ h->prev->next = h->next;
+ }
+ ta_dbg_remove(h);
+ free(h->ext);
+ free(h);
+}
+
+/* Set a destructor that is to be called when the given allocation is freed.
+ * (Whether the allocation is directly freed with ta_free() or indirectly by
+ * freeing its parent does not matter.) There is only one destructor. If an
+ * destructor was already set, it's overwritten.
+ *
+ * The destructor will be called with ptr as argument. The destructor can do
+ * almost anything, but it must not attempt to free or realloc ptr. The
+ * destructor is run before the allocation's children are freed (also, before
+ * their destructors are run).
+ *
+ * Returns false if ptr==NULL, or on OOM.
+ */
+bool ta_set_destructor(void *ptr, void (*destructor)(void *))
+{
+ struct ta_ext_header *eh = get_or_alloc_ext_header(ptr);
+ if (!eh)
+ return false;
+ eh->destructor = destructor;
+ return true;
+}
+
+/* Return the ptr's parent allocation, or NULL if there isn't any.
+ *
+ * Warning: this has O(N) runtime complexity with N sibling allocations!
+ */
+void *ta_find_parent(void *ptr)
+{
+ struct ta_header *h = get_header(ptr);
+ if (!h || !h->next)
+ return NULL;
+ for (struct ta_header *cur = h->next; cur != h; cur = cur->next) {
+ if (cur->size == CHILDREN_SENTINEL)
+ return PTR_FROM_HEADER(cur->ext->header);
+ }
+ return NULL;
+}
+
+#ifdef TA_MEMORY_DEBUGGING
+
+#include <pthread.h>
+
+static pthread_mutex_t ta_dbg_mutex = PTHREAD_MUTEX_INITIALIZER;
+static bool enable_leak_check; // pretty much constant
+static struct ta_header leak_node;
+static char allocation_is_string;
+
+static void ta_dbg_add(struct ta_header *h)
+{
+ h->canary = CANARY;
+ if (enable_leak_check) {
+ pthread_mutex_lock(&ta_dbg_mutex);
+ h->leak_next = &leak_node;
+ h->leak_prev = leak_node.leak_prev;
+ leak_node.leak_prev->leak_next = h;
+ leak_node.leak_prev = h;
+ pthread_mutex_unlock(&ta_dbg_mutex);
+ }
+}
+
+static void ta_dbg_check_header(struct ta_header *h)
+{
+ if (h)
+ assert(h->canary == CANARY);
+}
+
+static void ta_dbg_remove(struct ta_header *h)
+{
+ ta_dbg_check_header(h);
+ if (h->leak_next) { // assume checking for !=NULL invariant ok without lock
+ pthread_mutex_lock(&ta_dbg_mutex);
+ h->leak_next->leak_prev = h->leak_prev;
+ h->leak_prev->leak_next = h->leak_next;
+ pthread_mutex_unlock(&ta_dbg_mutex);
+ h->leak_next = h->leak_prev = NULL;
+ }
+ h->canary = 0;
+}
+
+static size_t get_children_size(struct ta_header *h)
+{
+ size_t size = 0;
+ if (h->ext) {
+ struct ta_header *s;
+ for (s = h->ext->children.next; s != &h->ext->children; s = s->next)
+ size += s->size + get_children_size(s);
+ }
+ return size;
+}
+
+static void print_leak_report(void)
+{
+ pthread_mutex_lock(&ta_dbg_mutex);
+ if (leak_node.leak_next && leak_node.leak_next != &leak_node) {
+ size_t size = 0;
+ size_t num_blocks = 0;
+ fprintf(stderr, "Blocks not freed:\n");
+ fprintf(stderr, " %-20s %10s %10s %s\n",
+ "Ptr", "Bytes", "C. Bytes", "Name");
+ while (leak_node.leak_next != &leak_node) {
+ struct ta_header *cur = leak_node.leak_next;
+ // Don't list those with parent; logically, only parents are listed
+ if (!cur->next) {
+ size_t c_size = get_children_size(cur);
+ char name[30] = {0};
+ if (cur->name)
+ snprintf(name, sizeof(name), "%s", cur->name);
+ if (cur->name == &allocation_is_string) {
+ snprintf(name, sizeof(name), "'%.*s'",
+ (int)cur->size, (char *)PTR_FROM_HEADER(cur));
+ }
+ for (int n = 0; n < sizeof(name); n++) {
+ if (name[n] && name[n] < 0x20)
+ name[n] = '.';
+ }
+ fprintf(stderr, " %-20p %10zu %10zu %s\n",
+ cur, cur->size, c_size, name);
+ }
+ size += cur->size;
+ num_blocks += 1;
+ // Unlink, and don't confuse valgrind by leaving live pointers.
+ cur->leak_next->leak_prev = cur->leak_prev;
+ cur->leak_prev->leak_next = cur->leak_next;
+ cur->leak_next = cur->leak_prev = NULL;
+ }
+ fprintf(stderr, "%zu bytes in %zu blocks.\n", size, num_blocks);
+ }
+ pthread_mutex_unlock(&ta_dbg_mutex);
+}
+
+void ta_enable_leak_report(void)
+{
+ pthread_mutex_lock(&ta_dbg_mutex);
+ enable_leak_check = true;
+ if (!leak_node.leak_prev && !leak_node.leak_next) {
+ leak_node.leak_prev = &leak_node;
+ leak_node.leak_next = &leak_node;
+ atexit(print_leak_report);
+ }
+ pthread_mutex_unlock(&ta_dbg_mutex);
+}
+
+/* Set a (static) string that will be printed if the memory allocation in ptr
+ * shows up on the leak report. The string must stay valid until ptr is freed.
+ * Calling it on ptr==NULL does nothing.
+ * Typically used to set location info.
+ * Always returns ptr (useful for chaining function calls).
+ */
+void *ta_dbg_set_loc(void *ptr, const char *loc)
+{
+ struct ta_header *h = get_header(ptr);
+ if (h)
+ h->name = loc;
+ return ptr;
+}
+
+/* Mark the allocation as string. The leak report will print it literally.
+ */
+void *ta_dbg_mark_as_string(void *ptr)
+{
+ // Specially handled by leak report code.
+ return ta_dbg_set_loc(ptr, &allocation_is_string);
+}
+
+#else
+
+static void ta_dbg_add(struct ta_header *h){}
+static void ta_dbg_check_header(struct ta_header *h){}
+static void ta_dbg_remove(struct ta_header *h){}
+
+void ta_enable_leak_report(void){}
+void *ta_dbg_set_name(void *ptr, const char *name){return ptr;}
+
+#endif
diff --git a/ta/ta.h b/ta/ta.h
new file mode 100644
index 0000000000..1a9738a9f0
--- /dev/null
+++ b/ta/ta.h
@@ -0,0 +1,146 @@
+/* Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef TA_H_
+#define TA_H_
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdarg.h>
+
+#ifdef __GNUC__
+#define TA_PRF(a1, a2) __attribute__ ((format(printf, a1, a2)))
+#define TA_TYPEOF(t) __typeof__(t)
+#else
+#define TA_PRF(a1, a2)
+#define TA_TYPEOF(t) void *
+#endif
+
+#define TA_STRINGIFY_(x) # x
+#define TA_STRINGIFY(x) TA_STRINGIFY_(x)
+
+#ifdef NDEBUG
+#define TA_LOC ""
+#else
+#define TA_LOC __FILE__ ":" TA_STRINGIFY(__LINE__)
+#endif
+
+// Core functions
+void *ta_alloc_size(void *ta_parent, size_t size);
+void *ta_zalloc_size(void *ta_parent, size_t size);
+void *ta_realloc_size(void *ta_parent, void *ptr, size_t size);
+size_t ta_get_size(void *ptr);
+void ta_free(void *ptr);
+void ta_free_children(void *ptr);
+bool ta_set_destructor(void *ptr, void (*destructor)(void *));
+bool ta_set_parent(void *ptr, void *ta_parent);
+void *ta_find_parent(void *ptr);
+
+// Utility functions
+size_t ta_calc_array_size(size_t element_size, size_t count);
+void *ta_new_context(void *ta_parent);
+void *ta_steal_(void *ta_parent, void *ptr);
+void *ta_memdup(void *ta_parent, void *ptr, size_t size);
+char *ta_strdup(void *ta_parent, const char *str);
+bool ta_strdup_append(char **str, const char *a);
+bool ta_strdup_append_buffer(char **str, const char *a);
+char *ta_strndup(void *ta_parent, const char *str, size_t n);
+bool ta_strndup_append(char **str, const char *a, size_t n);
+bool ta_strndup_append_buffer(char **str, const char *a, size_t n);
+char *ta_asprintf(void *ta_parent, const char *fmt, ...) TA_PRF(2, 3);
+char *ta_vasprintf(void *ta_parent, const char *fmt, va_list ap) TA_PRF(2, 0);
+bool ta_asprintf_append(char **str, const char *fmt, ...) TA_PRF(2, 3);
+bool ta_vasprintf_append(char **str, const char *fmt, va_list ap) TA_PRF(2, 0);
+bool ta_asprintf_append_buffer(char **str, const char *fmt, ...) TA_PRF(2, 3);
+bool ta_vasprintf_append_buffer(char **str, const char *fmt, va_list ap) TA_PRF(2, 0);
+
+#define ta_new(ta_parent, type) (type *)ta_alloc_size(ta_parent, sizeof(type))
+#define ta_znew(ta_parent, type) (type *)ta_zalloc_size(ta_parent, sizeof(type))
+
+#define ta_new_array(ta_parent, type, count) \
+ (type *)ta_alloc_size(ta_parent, ta_calc_array_size(sizeof(type), count))
+
+#define ta_znew_array(ta_parent, type, count) \
+ (type *)ta_zalloc_size(ta_parent, ta_calc_array_size(sizeof(type), count))
+
+#define ta_new_array_size(ta_parent, element_size, count) \
+ ta_alloc_size(ta_parent, ta_calc_array_size(element_size, count))
+
+#define ta_realloc(ta_parent, ptr, type, count) \
+ (type *)ta_realloc_size(ta_parent, ptr, ta_calc_array_size(sizeof(type), count))
+
+#define ta_new_ptrtype(ta_parent, ptr) \
+ (TA_TYPEOF(ptr))ta_alloc_size(ta_parent, sizeof(*ptr))
+
+#define ta_new_array_ptrtype(ta_parent, ptr, count) \
+ (TA_TYPEOF(ptr))ta_new_array_size(ta_parent, sizeof(*(ptr)), count)
+
+#define ta_steal(ta_parent, ptr) (TA_TYPEOF(ptr))ta_steal_(ta_parent, ptr)
+
+// Ugly macros that crash on OOM.
+// All of these mirror real functions (with a 'x' added after the 'ta_'
+// prefix), and the only difference is that they will call abort() on allocation
+// failures (such as out of memory conditions), instead of returning an error
+// code.
+#define ta_xalloc_size(...) ta_oom_p(ta_alloc_size(__VA_ARGS__))
+#define ta_xzalloc_size(...) ta_oom_p(ta_zalloc_size(__VA_ARGS__))
+#define ta_xset_destructor(...) ta_oom_b(ta_set_destructor(__VA_ARGS__))
+#define ta_xset_parent(...) ta_oom_b(ta_set_parent(__VA_ARGS__))
+#define ta_xnew_context(...) ta_oom_p(ta_new_context(__VA_ARGS__))
+#define ta_xstrdup_append(...) ta_oom_b(ta_strdup_append(__VA_ARGS__))
+#define ta_xstrdup_append_buffer(...) ta_oom_b(ta_strdup_append_buffer(__VA_ARGS__))
+#define ta_xstrndup_append(...) ta_oom_b(ta_strndup_append(__VA_ARGS__))
+#define ta_xstrndup_append_buffer(...) ta_oom_b(ta_strndup_append_buffer(__VA_ARGS__))
+#define ta_xasprintf(...) ta_oom_s(ta_asprintf(__VA_ARGS__))
+#define ta_xvasprintf(...) ta_oom_s(ta_vasprintf(__VA_ARGS__))
+#define ta_xasprintf_append(...) ta_oom_b(ta_asprintf_append(__VA_ARGS__))
+#define ta_xvasprintf_append(...) ta_oom_b(ta_vasprintf_append(__VA_ARGS__))
+#define ta_xasprintf_append_buffer(...) ta_oom_b(ta_asprintf_append_buffer(__VA_ARGS__))
+#define ta_xvasprintf_append_buffer(...) ta_oom_b(ta_vasprintf_append_buffer(__VA_ARGS__))
+#define ta_xnew(...) ta_oom_g(ta_new(__VA_ARGS__))
+#define ta_xznew(...) ta_oom_g(ta_znew(__VA_ARGS__))
+#define ta_xnew_array(...) ta_oom_g(ta_new_array(__VA_ARGS__))
+#define ta_xznew_array(...) ta_oom_g(ta_znew_array(__VA_ARGS__))
+#define ta_xnew_array_size(...) ta_oom_p(ta_new_array_size(__VA_ARGS__))
+#define ta_xnew_ptrtype(...) ta_oom_g(ta_new_ptrtype(__VA_ARGS__))
+#define ta_xnew_array_ptrtype(...) ta_oom_g(ta_new_array_ptrtype(__VA_ARGS__))
+
+#define ta_xsteal(ta_parent, ptr) (TA_TYPEOF(ptr))ta_xsteal_(ta_parent, ptr)
+#define ta_xrealloc(ta_parent, ptr, type, count) \
+ (type *)ta_xrealloc_size(ta_parent, ptr, ta_calc_array_size(sizeof(type), count))
+
+// Can't be macros, because the OOM logic is slightly less trivial.
+char *ta_xstrdup(void *ta_parent, const char *str);
+char *ta_xstrndup(void *ta_parent, const char *str, size_t n);
+void *ta_xsteal_(void *ta_parent, void *ptr);
+void *ta_xmemdup(void *ta_parent, void *ptr, size_t size);
+void *ta_xrealloc_size(void *ta_parent, void *ptr, size_t size);
+
+#ifndef TA_NO_WRAPPERS
+#define ta_alloc_size(...) ta_dbg_set_loc(ta_alloc_size(__VA_ARGS__), TA_LOC)
+#define ta_zalloc_size(...) ta_dbg_set_loc(ta_zalloc_size(__VA_ARGS__), TA_LOC)
+#define ta_realloc_size(...) ta_dbg_set_loc(ta_realloc_size(__VA_ARGS__), TA_LOC)
+#define ta_memdup(...) ta_dbg_set_loc(ta_memdup(__VA_ARGS__), TA_LOC)
+#endif
+
+void ta_oom_b(bool b);
+char *ta_oom_s(char *s);
+void *ta_oom_p(void *p);
+// Generic pointer
+#define ta_oom_g(ptr) (TA_TYPEOF(ptr))ta_oom_p(ptr)
+
+void ta_enable_leak_report(void);
+void *ta_dbg_set_loc(void *ptr, const char *name);
+void *ta_dbg_mark_as_string(void *ptr);
+
+#endif
diff --git a/ta/ta_talloc.c b/ta/ta_talloc.c
new file mode 100644
index 0000000000..9c52bbab08
--- /dev/null
+++ b/ta/ta_talloc.c
@@ -0,0 +1,75 @@
+/* Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+
+#include "ta_talloc.h"
+
+char *ta_talloc_strdup_append(char *s, const char *a)
+{
+ ta_xstrdup_append(&s, a);
+ return s;
+}
+
+char *ta_talloc_strdup_append_buffer(char *s, const char *a)
+{
+ ta_xstrdup_append_buffer(&s, a);
+ return s;
+}
+
+char *ta_talloc_strndup_append(char *s, const char *a, size_t n)
+{
+ ta_xstrndup_append(&s, a, n);
+ return s;
+}
+
+char *ta_talloc_strndup_append_buffer(char *s, const char *a, size_t n)
+{
+ ta_xstrndup_append_buffer(&s, a, n);
+ return s;
+}
+
+char *ta_talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
+{
+ ta_xvasprintf_append(&s, fmt, ap);
+ return s;
+}
+
+char *ta_talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
+{
+ ta_xvasprintf_append_buffer(&s, fmt, ap);
+ return s;
+}
+
+char *ta_talloc_asprintf_append(char *s, const char *fmt, ...)
+{
+ char *res;
+ va_list ap;
+ va_start(ap, fmt);
+ res = talloc_vasprintf_append(s, fmt, ap);
+ va_end(ap);
+ return res;
+}
+
+char *ta_talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
+{
+ char *res;
+ va_list ap;
+ va_start(ap, fmt);
+ res = talloc_vasprintf_append_buffer(s, fmt, ap);
+ va_end(ap);
+ return res;
+}
diff --git a/ta/ta_talloc.h b/ta/ta_talloc.h
new file mode 100644
index 0000000000..cd41e63818
--- /dev/null
+++ b/ta/ta_talloc.h
@@ -0,0 +1,74 @@
+/* Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef TA_TALLOC_H_
+#define TA_TALLOC_H_
+
+#include "ta.h"
+
+// Note: all talloc wrappers are wired to the "x" functions, which abort on OOM.
+// libtalloc doesn't do that, but the mplayer2 internal copy of it did.
+
+#define talloc ta_xnew
+#define talloc_zero ta_xznew
+
+#define talloc_array ta_xnew_array
+#define talloc_zero_array ta_xznew_array
+
+#define talloc_array_size ta_xnew_array_size
+#define talloc_realloc ta_xrealloc
+#define talloc_ptrtype ta_xnew_ptrtype
+#define talloc_array_ptrtype ta_xnew_array_ptrtype
+
+#define talloc_steal ta_xsteal
+#define talloc_realloc_size ta_xrealloc_size
+#define talloc_new ta_xnew_context
+#define talloc_set_destructor ta_xset_destructor
+#define talloc_parent ta_find_parent
+#define talloc_enable_leak_report ta_enable_leak_report
+#define talloc_size ta_xalloc_size
+#define talloc_zero_size ta_xzalloc_size
+#define talloc_get_size ta_get_size
+#define talloc_free_children ta_free_children
+#define talloc_free ta_free
+#define talloc_memdup ta_xmemdup
+#define talloc_strdup ta_xstrdup
+#define talloc_strndup ta_xstrndup
+#define talloc_asprintf ta_xasprintf
+#define talloc_vasprintf ta_xvasprintf
+
+// Don't define linker-level symbols, as that would clash with real libtalloc.
+#define talloc_strdup_append ta_talloc_strdup_append
+#define talloc_strdup_append_buffer ta_talloc_strdup_append_buffer
+#define talloc_strndup_append ta_talloc_strndup_append
+#define talloc_strndup_append_buffer ta_talloc_strndup_append_buffer
+#define talloc_vasprintf_append ta_talloc_vasprintf_append
+#define talloc_vasprintf_append_buffer ta_talloc_vasprintf_append_buffer
+#define talloc_asprintf_append ta_talloc_asprintf_append
+#define talloc_asprintf_append_buffer ta_talloc_asprintf_append_buffer
+
+char *ta_talloc_strdup(void *t, const char *p);
+char *ta_talloc_strdup_append(char *s, const char *a);
+char *ta_talloc_strdup_append_buffer(char *s, const char *a);
+
+char *ta_talloc_strndup(void *t, const char *p, size_t n);
+char *ta_talloc_strndup_append(char *s, const char *a, size_t n);
+char *ta_talloc_strndup_append_buffer(char *s, const char *a, size_t n);
+
+char *ta_talloc_vasprintf_append(char *s, const char *fmt, va_list ap) TA_PRF(2, 0);
+char *ta_talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap) TA_PRF(2, 0);
+
+char *ta_talloc_asprintf_append(char *s, const char *fmt, ...) TA_PRF(2, 3);
+char *ta_talloc_asprintf_append_buffer(char *s, const char *fmt, ...) TA_PRF(2, 3);
+
+#endif
diff --git a/ta/ta_utils.c b/ta/ta_utils.c
new file mode 100644
index 0000000000..19ab77a733
--- /dev/null
+++ b/ta/ta_utils.c
@@ -0,0 +1,320 @@
+/* Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+
+#define TA_NO_WRAPPERS
+#include "ta.h"
+
+// Return element_size * count. If it overflows, return (size_t)-1 (SIZE_MAX).
+// I.e. this returns the equivalent of: MIN(element_size * count, SIZE_MAX).
+// The idea is that every real memory allocator will reject (size_t)-1, thus
+// this is a valid way to handle too large array allocation requests.
+size_t ta_calc_array_size(size_t element_size, size_t count)
+{
+ if (count > (((size_t)-1) / element_size))
+ return (size_t)-1;
+ return element_size * count;
+}
+
+static void dummy_dtor(void *p){}
+
+/* Create an empty (size 0) TA allocation, which is prepared in a way such that
+ * using it as parent with ta_set_parent() always succeed. Calling
+ * ta_set_destructor() on it will always succeed as well.
+ */
+void *ta_new_context(void *ta_parent)
+{
+ void *new = ta_alloc_size(ta_parent, 0);
+ // Force it to allocate an extended header.
+ if (!ta_set_destructor(new, dummy_dtor)) {
+ ta_free(new);
+ new = NULL;
+ }
+ return new;
+}
+
+/* Set parent of ptr to ta_parent, return the ptr.
+ * Note that ta_parent==NULL will simply unset the current parent of ptr.
+ * If the operation fails (on OOM), return NULL. (That's pretty bad behavior,
+ * but the only way to signal failure.)
+ */
+void *ta_steal_(void *ta_parent, void *ptr)
+{
+ if (!ta_set_parent(ptr, ta_parent))
+ return NULL;
+ return ptr;
+}
+
+/* Duplicate the memory at ptr with the given size.
+ */
+void *ta_memdup(void *ta_parent, void *ptr, size_t size)
+{
+ if (!ptr) {
+ assert(!size);
+ return NULL;
+ }
+ void *res = ta_alloc_size(ta_parent, size);
+ if (!res)
+ return NULL;
+ memcpy(res, ptr, size);
+ return res;
+}
+
+// *str = *str[0..at] + append[0..append_len]
+// (append_len being a maximum length; shorter if embedded \0s are encountered)
+static bool strndup_append_at(char **str, size_t at, const char *append,
+ size_t append_len)
+{
+ assert(ta_get_size(*str) >= at);
+
+ if (!*str && !append)
+ return true; // stays NULL, but not an OOM condition
+
+ size_t real_len = append ? strnlen(append, append_len) : 0;
+ if (append_len > real_len)
+ append_len = real_len;
+
+ if (ta_get_size(*str) < at + append_len + 1) {
+ char *t = ta_realloc_size(NULL, *str, at + append_len + 1);
+ if (!t)
+ return false;
+ *str = t;
+ }
+
+ memcpy(*str + at, append, append_len);
+ (*str)[at + append_len] = '\0';
+
+ ta_dbg_mark_as_string(*str);
+
+ return true;
+}
+
+/* Return a copy of str.
+ * Returns NULL on OOM.
+ */
+char *ta_strdup(void *ta_parent, const char *str)
+{
+ return ta_strndup(ta_parent, str, str ? strlen(str) : 0);
+}
+
+/* Return a copy of str. If the string is longer than n, copy only n characters
+ * (the returned allocation will be n+1 bytes and contain a terminating '\0').
+ * The returned string will have the length MIN(strlen(str), n)
+ * If str==NULL, return NULL. Returns NULL on OOM as well.
+ */
+char *ta_strndup(void *ta_parent, const char *str, size_t n)
+{
+ if (!str)
+ return NULL;
+ char *new = NULL;
+ strndup_append_at(&new, 0, str, n);
+ if (!ta_set_parent(new, ta_parent)) {
+ ta_free(new);
+ new = NULL;
+ }
+ return new;
+}
+
+/* Append a to *str. If *str is NULL, the string is newly allocated, otherwise
+ * ta_realloc() is used on *str as needed.
+ * Return success or failure (it can fail due to OOM only).
+ */
+bool ta_strdup_append(char **str, const char *a)
+{
+ return strndup_append_at(str, *str ? strlen(*str) : 0, a, (size_t)-1);
+}
+
+/* Like ta_strdup_append(), but use ta_get_size(*str)-1 instead of strlen(*str).
+ * (See also: ta_asprintf_append_buffer())
+ */
+bool ta_strdup_append_buffer(char **str, const char *a)
+{
+ size_t size = ta_get_size(*str);
+ if (size > 0)
+ size -= 1;
+ return strndup_append_at(str, size, a, (size_t)-1);
+}
+
+/* Like ta_strdup_append(), but limit the length of a with n.
+ * (See also: ta_strndup())
+ */
+bool ta_strndup_append(char **str, const char *a, size_t n)
+{
+ return strndup_append_at(str, *str ? strlen(*str) : 0, a, n);
+}
+
+/* Like ta_strdup_append_buffer(), but limit the length of a with n.
+ * (See also: ta_strndup())
+ */
+bool ta_strndup_append_buffer(char **str, const char *a, size_t n)
+{
+ size_t size = ta_get_size(*str);
+ if (size > 0)
+ size -= 1;
+ return strndup_append_at(str, size, a, n);
+}
+
+static bool ta_vasprintf_append_at(char **str, size_t at, const char *fmt,
+ va_list ap)
+{
+ assert(ta_get_size(*str) >= at);
+
+ int size;
+ va_list copy;
+ va_copy(copy, ap);
+ char c;
+ size = vsnprintf(&c, 1, fmt, copy);
+ va_end(copy);
+
+ if (size < 0)
+ return false;
+
+ if (ta_get_size(*str) < at + size + 1) {
+ char *t = ta_realloc_size(NULL, *str, at + size + 1);
+ if (!t)
+ return false;
+ *str = t;
+ }
+ vsnprintf(*str + at, size + 1, fmt, ap);
+
+ ta_dbg_mark_as_string(*str);
+
+ return true;
+}
+
+/* Like snprintf(); returns the formatted string as allocation (or NULL on OOM
+ * or snprintf() errors).
+ */
+char *ta_asprintf(void *ta_parent, const char *fmt, ...)
+{
+ char *res;
+ va_list ap;
+ va_start(ap, fmt);
+ res = ta_vasprintf(ta_parent, fmt, ap);
+ va_end(ap);
+ return res;
+}
+
+char *ta_vasprintf(void *ta_parent, const char *fmt, va_list ap)
+{
+ char *res = NULL;
+ ta_vasprintf_append_at(&res, 0, fmt, ap);
+ if (!res || !ta_set_parent(res, ta_parent)) {
+ ta_free(res);
+ return NULL;
+ }
+ return res;
+}
+
+/* Append the formatted string to *str (after strlen(*str)). The allocation is
+ * ta_realloced if needed.
+ * Returns false on OOM or snprintf() errors, with *str left untouched.
+ */
+bool ta_asprintf_append(char **str, const char *fmt, ...)
+{
+ bool res;
+ va_list ap;
+ va_start(ap, fmt);
+ res = ta_vasprintf_append(str, fmt, ap);
+ va_end(ap);
+ return res;
+}
+
+bool ta_vasprintf_append(char **str, const char *fmt, va_list ap)
+{
+ return ta_vasprintf_append_at(str, str && *str ? strlen(*str) : 0, fmt, ap);
+}
+
+/* Append the formatted string at the end of the allocation of *str. It
+ * overwrites the last byte of the allocation too (which is assumed to be the
+ * '\0' terminating the sttring). Compared to ta_asprintf_append(), this is
+ * useful if you know that the string ends with the allocation, so that the
+ * extra strlen() can be avoided for better performance.
+ * Returns false on OOM or snprintf() errors, with *str left untouched.
+ */
+bool ta_asprintf_append_buffer(char **str, const char *fmt, ...)
+{
+ bool res;
+ va_list ap;
+ va_start(ap, fmt);
+ res = ta_vasprintf_append_buffer(str, fmt, ap);
+ va_end(ap);
+ return res;
+}
+
+bool ta_vasprintf_append_buffer(char **str, const char *fmt, va_list ap)
+{
+ size_t size = ta_get_size(*str);
+ if (size > 0)
+ size -= 1;
+ return ta_vasprintf_append_at(str, size, fmt, ap);
+}
+
+
+void *ta_oom_p(void *p)
+{
+ if (!p)
+ abort();
+ return p;
+}
+
+void ta_oom_b(bool b)
+{
+ if (!b)
+ abort();
+}
+
+char *ta_oom_s(char *s)
+{
+ if (!s)
+ abort();
+ return s;
+}
+
+void *ta_xsteal_(void *ta_parent, void *ptr)
+{
+ ta_oom_b(ta_set_parent(ptr, ta_parent));
+ return ptr;
+}
+
+void *ta_xmemdup(void *ta_parent, void *ptr, size_t size)
+{
+ void *new = ta_memdup(ta_parent, ptr, size);
+ ta_oom_b(new || !ptr);
+ return new;
+}
+
+void *ta_xrealloc_size(void *ta_parent, void *ptr, size_t size)
+{
+ ptr = ta_realloc_size(ta_parent, ptr, size);
+ ta_oom_b(ptr || !size);
+ return ptr;
+}
+
+char *ta_xstrdup(void *ta_parent, const char *str)
+{
+ char *res = ta_strdup(ta_parent, str);
+ ta_oom_b(res || !str);
+ return res;
+}
+
+char *ta_xstrndup(void *ta_parent, const char *str, size_t n)
+{
+ char *res = ta_strndup(ta_parent, str, n);
+ ta_oom_b(res || !str);
+ return res;
+}