#include <ccan/tal/tal.h>
#include <ccan/compiler/compiler.h>
#include <ccan/list/list.h>
-#include <ccan/take/take.h>
+#include <ccan/alignof/alignof.h>
#include <assert.h>
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <limits.h>
+#include <stdint.h>
#include <errno.h>
//#define TAL_DEBUG 1
#define NOTIFY_IS_DESTRUCTOR 512
+#define NOTIFY_EXTRA_ARG 1024
+
+/* This makes our parent_child ptr stand out for to_tal_hdr checks */
+#define TAL_PTR_OBFUSTICATOR ((intptr_t)0x1984200820142016ULL)
/* 32-bit type field, first byte 0 in either endianness. */
enum prop_type {
CHILDREN = 0x00c1d500,
NAME = 0x00111100,
NOTIFIER = 0x00071f00,
- LENGTH = 0x00515300
};
struct tal_hdr {
struct list_node list;
struct prop_hdr *prop;
- struct children *parent_child;
+ /* XOR with TAL_PTR_OBFUSTICATOR */
+ intptr_t parent_child;
+ size_t bytelen;
};
struct prop_hdr {
char name[];
};
-struct length {
- struct prop_hdr hdr; /* LENGTH */
- size_t count;
-};
-
struct notifier {
struct prop_hdr hdr; /* NOTIFIER */
enum tal_notify_type types;
- union {
+ union notifier_cb {
void (*notifyfn)(tal_t *, enum tal_notify_type, void *);
void (*destroy)(tal_t *); /* If NOTIFY_IS_DESTRUCTOR set */
+ void (*destroy2)(tal_t *, void *); /* If NOTIFY_EXTRA_ARG */
} u;
};
+/* Extra arg */
+struct notifier_extra_arg {
+ struct notifier n;
+ void *arg;
+};
+
+#define EXTRA_ARG(n) (((struct notifier_extra_arg *)(n))->arg)
+
static struct {
struct tal_hdr hdr;
struct children c;
} null_parent = { { { &null_parent.hdr.list, &null_parent.hdr.list },
- &null_parent.c.hdr, NULL },
+ &null_parent.c.hdr, TAL_PTR_OBFUSTICATOR, 0 },
{ { CHILDREN, NULL },
&null_parent.hdr,
{ { &null_parent.c.children.n,
static void *(*resizefn)(void *, size_t size) = realloc;
static void (*freefn)(void *) = free;
static void (*errorfn)(const char *msg) = (void *)abort;
-static bool initialized = false;
/* Count on non-destrutor notifiers; often stays zero. */
static size_t notifiers = 0;
errorfn(msg);
}
-static bool get_destroying_bit(struct children *parent_child)
+static bool get_destroying_bit(intptr_t parent_child)
{
- return (size_t)parent_child & 1;
+ return parent_child & 1;
}
-static void set_destroying_bit(struct children **parent_child)
+static void set_destroying_bit(intptr_t *parent_child)
{
- *parent_child = (void *)((size_t)*parent_child | 1);
+ *parent_child |= 1;
}
-static struct children *ignore_destroying_bit(struct children *parent_child)
+static struct children *ignore_destroying_bit(intptr_t parent_child)
{
- return (void *)((size_t)parent_child & ~(size_t)1);
+ return (void *)((parent_child ^ TAL_PTR_OBFUSTICATOR) & ~(intptr_t)1);
}
/* This means valgrind can see leaks. */
-static void tal_cleanup(void)
+void tal_cleanup(void)
{
struct tal_hdr *i;
- while ((i = list_top(&null_parent.c.children, struct tal_hdr, list)))
+ while ((i = list_top(&null_parent.c.children, struct tal_hdr, list))) {
list_del(&i->list);
+ memset(i, 0, sizeof(*i));
+ }
/* Cleanup any taken pointers. */
take_cleanup();
}
-/* For allocation failures inside ccan/take */
-static void take_alloc_failed(const void *p)
-{
- tal_free(p);
-}
-
/* We carefully start all real properties with a zero byte. */
static bool is_literal(const struct prop_hdr *prop)
{
return (void *)(hdr + 1);
}
-#ifdef TAL_DEBUG
-static void *from_tal_hdr_or_null(struct tal_hdr *hdr)
+static void *from_tal_hdr_or_null(const struct tal_hdr *hdr)
{
if (hdr == &null_parent.hdr)
return NULL;
return from_tal_hdr(hdr);
}
+#ifdef TAL_DEBUG
static struct tal_hdr *debug_tal(struct tal_hdr *tal)
{
tal_check(from_tal_hdr_or_null(tal), "TAL_DEBUG ");
#endif
static void notify(const struct tal_hdr *ctx,
- enum tal_notify_type type, const void *info)
+ enum tal_notify_type type, const void *info,
+ int saved_errno)
{
const struct prop_hdr *p;
continue;
n = (struct notifier *)p;
if (n->types & type) {
- if (n->types & NOTIFY_IS_DESTRUCTOR)
- n->u.destroy(from_tal_hdr(ctx));
- else
- n->u.notifyfn(from_tal_hdr(ctx), type,
+ errno = saved_errno;
+ if (n->types & NOTIFY_IS_DESTRUCTOR) {
+ /* Blatt this notifier in case it tries to
+ * tal_del_destructor() from inside */
+ union notifier_cb cb = n->u;
+ /* It's a union, so this NULLs destroy2 too! */
+ n->u.destroy = NULL;
+ if (n->types & NOTIFY_EXTRA_ARG)
+ cb.destroy2(from_tal_hdr(ctx),
+ EXTRA_ARG(n));
+ else
+ cb.destroy(from_tal_hdr(ctx));
+ } else
+ n->u.notifyfn(from_tal_hdr_or_null(ctx), type,
(void *)info);
}
}
enum tal_notify_type types,
void (*fn)(void *,
enum tal_notify_type,
- void *))
+ void *),
+ void *extra_arg)
{
- struct notifier *prop = allocate(sizeof(*prop));
+ struct notifier *prop;
+
+ if (types & NOTIFY_EXTRA_ARG)
+ prop = allocate(sizeof(struct notifier_extra_arg));
+ else
+ prop = allocate(sizeof(struct notifier));
+
if (prop) {
init_property(&prop->hdr, t, NOTIFIER);
prop->types = types;
prop->u.notifyfn = fn;
+ if (types & NOTIFY_EXTRA_ARG)
+ EXTRA_ARG(prop) = extra_arg;
}
return prop;
}
static enum tal_notify_type del_notifier_property(struct tal_hdr *t,
void (*fn)(tal_t *,
enum tal_notify_type,
- void *))
+ void *),
+ bool match_extra_arg,
+ void *extra_arg)
{
struct prop_hdr **p;
for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) {
struct notifier *n;
+ enum tal_notify_type types;
if (is_literal(*p))
break;
if ((*p)->type != NOTIFIER)
continue;
n = (struct notifier *)*p;
- if (n->u.notifyfn == fn) {
- enum tal_notify_type types = n->types;
- *p = (*p)->next;
- freefn(n);
- return types & ~NOTIFY_IS_DESTRUCTOR;
- }
+ if (n->u.notifyfn != fn)
+ continue;
+
+ types = n->types;
+ if ((types & NOTIFY_EXTRA_ARG)
+ && match_extra_arg
+ && extra_arg != EXTRA_ARG(n))
+ continue;
+
+ *p = (*p)->next;
+ freefn(n);
+ return types & ~(NOTIFY_IS_DESTRUCTOR|NOTIFY_EXTRA_ARG);
}
return 0;
}
return prop;
}
-static struct length *add_length_property(struct tal_hdr *t, size_t count)
-{
- struct length *prop;
-
- prop = allocate(sizeof(*prop));
- if (prop) {
- init_property(&prop->hdr, t, LENGTH);
- prop->count = count;
- }
- return prop;
-}
-
static struct children *add_child_property(struct tal_hdr *parent,
- struct tal_hdr *child)
+ struct tal_hdr *child UNNEEDED)
{
struct children *prop = allocate(sizeof(*prop));
if (prop) {
struct children *children = find_property(parent, CHILDREN);
if (!children) {
- if (unlikely(!initialized)) {
- atexit(tal_cleanup);
- take_allocfail(take_alloc_failed);
- initialized = true;
- }
children = add_child_property(parent, child);
if (!children)
return false;
}
list_add(&children->children, &child->list);
- child->parent_child = children;
+ child->parent_child = (intptr_t)children ^ TAL_PTR_OBFUSTICATOR;
return true;
}
-static void del_tree(struct tal_hdr *t, const tal_t *orig)
+static void del_tree(struct tal_hdr *t, const tal_t *orig, int saved_errno)
{
struct prop_hdr **prop, *p, *next;
+ assert(!taken(from_tal_hdr(t)));
+
/* Already being destroyed? Don't loop. */
if (unlikely(get_destroying_bit(t->parent_child)))
return;
set_destroying_bit(&t->parent_child);
/* Call free notifiers. */
- notify(t, TAL_NOTIFY_FREE, (tal_t *)orig);
+ notify(t, TAL_NOTIFY_FREE, (tal_t *)orig, saved_errno);
/* Now free children and groups. */
prop = find_property_ptr(t, CHILDREN);
while ((i = list_top(&c->children, struct tal_hdr, list))) {
list_del(&i->list);
- del_tree(i, orig);
+ del_tree(i, orig, saved_errno);
}
}
if (clear)
memset(from_tal_hdr(child), 0, size);
child->prop = (void *)label;
+ child->bytelen = size;
+
if (!add_child(parent, child)) {
freefn(child);
return NULL;
}
debug_tal(parent);
if (notifiers)
- notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(child));
+ notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(child), 0);
return from_tal_hdr(debug_tal(child));
}
static bool adjust_size(size_t *size, size_t count)
{
+ const size_t extra = sizeof(struct tal_hdr);
+
/* Multiplication wrap */
if (count && unlikely(*size * count / *size != count))
goto overflow;
*size *= count;
/* Make sure we don't wrap adding header. */
- if (*size + sizeof(struct tal_hdr) < sizeof(struct tal_hdr))
+ if (*size + extra < extra)
goto overflow;
return true;
overflow:
}
void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
- bool add_count, const char *label)
+ const char *label)
{
- void *ret;
-
if (!adjust_size(&size, count))
return NULL;
- ret = tal_alloc_(ctx, size, clear, label);
- if (likely(ret) && add_count) {
- if (unlikely(!add_length_property(to_tal_hdr(ret), count)))
- ret = tal_free(ret);
- }
- return ret;
+ return tal_alloc_(ctx, size, clear, label);
}
void *tal_free(const tal_t *ctx)
struct tal_hdr *t;
int saved_errno = errno;
t = debug_tal(to_tal_hdr(ctx));
+ if (unlikely(get_destroying_bit(t->parent_child)))
+ return NULL;
if (notifiers)
notify(ignore_destroying_bit(t->parent_child)->parent,
- TAL_NOTIFY_DEL_CHILD, ctx);
+ TAL_NOTIFY_DEL_CHILD, ctx, saved_errno);
list_del(&t->list);
- del_tree(t, ctx);
+ del_tree(t, ctx, saved_errno);
errno = saved_errno;
}
return NULL;
old_parent = ignore_destroying_bit(t->parent_child)->parent;
if (unlikely(!add_child(newpar, t))) {
- /* We can always add to old parent, becuase it has a
+ /* We can always add to old parent, because it has a
* children property already. */
if (!add_child(old_parent, t))
abort();
}
debug_tal(newpar);
if (notifiers)
- notify(t, TAL_NOTIFY_STEAL, new_parent);
+ notify(t, TAL_NOTIFY_STEAL, new_parent, 0);
}
return (void *)ctx;
}
{
tal_t *t = debug_tal(to_tal_hdr(ctx));
return add_notifier_property(t, TAL_NOTIFY_FREE|NOTIFY_IS_DESTRUCTOR,
- (void *)destroy);
+ (void *)destroy, NULL);
+}
+
+bool tal_add_destructor2_(const tal_t *ctx, void (*destroy)(void *me, void *arg),
+ void *arg)
+{
+ tal_t *t = debug_tal(to_tal_hdr(ctx));
+ return add_notifier_property(t, TAL_NOTIFY_FREE|NOTIFY_IS_DESTRUCTOR
+ |NOTIFY_EXTRA_ARG,
+ (void *)destroy, arg);
}
+/* We could support notifiers with an extra arg, but we didn't add to API */
bool tal_add_notifier_(const tal_t *ctx, enum tal_notify_type types,
void (*callback)(tal_t *, enum tal_notify_type, void *))
{
- tal_t *t = debug_tal(to_tal_hdr(ctx));
+ struct tal_hdr *t = debug_tal(to_tal_hdr_or_null(ctx));
struct notifier *n;
assert(types);
| TAL_NOTIFY_DEL_NOTIFIER)) == 0);
/* Don't call notifier about itself: set types after! */
- n = add_notifier_property(t, 0, callback);
+ n = add_notifier_property(t, 0, callback, NULL);
if (unlikely(!n))
return false;
if (notifiers)
- notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback);
+ notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback, 0);
n->types = types;
if (types != TAL_NOTIFY_FREE)
}
bool tal_del_notifier_(const tal_t *ctx,
- void (*callback)(tal_t *, enum tal_notify_type, void *))
+ void (*callback)(tal_t *, enum tal_notify_type, void *),
+ bool match_extra_arg, void *extra_arg)
{
- struct tal_hdr *t = debug_tal(to_tal_hdr(ctx));
+ struct tal_hdr *t = debug_tal(to_tal_hdr_or_null(ctx));
enum tal_notify_type types;
- types = del_notifier_property(t, callback);
+ types = del_notifier_property(t, callback, match_extra_arg, extra_arg);
if (types) {
- notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback);
+ notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback, 0);
if (types != TAL_NOTIFY_FREE)
notifiers--;
return true;
bool tal_del_destructor_(const tal_t *ctx, void (*destroy)(void *me))
{
- return tal_del_notifier_(ctx, (void *)destroy);
+ return tal_del_notifier_(ctx, (void *)destroy, false, NULL);
+}
+
+bool tal_del_destructor2_(const tal_t *ctx, void (*destroy)(void *me, void *arg),
+ void *arg)
+{
+ return tal_del_notifier_(ctx, (void *)destroy, true, arg);
}
bool tal_set_name_(tal_t *ctx, const char *name, bool literal)
/* Get rid of any old name */
if (prop) {
- struct name *name = (struct name *)*prop;
- if (is_literal(&name->hdr))
+ struct name *oldname = (struct name *)*prop;
+ if (is_literal(&oldname->hdr))
*prop = NULL;
else {
- *prop = name->hdr.next;
- freefn(name);
+ *prop = oldname->hdr.next;
+ freefn(oldname);
}
}
debug_tal(t);
if (notifiers)
- notify(t, TAL_NOTIFY_RENAME, name);
+ notify(t, TAL_NOTIFY_RENAME, name, 0);
return true;
}
return n->name;
}
-size_t tal_count(const tal_t *ptr)
+size_t tal_bytelen(const tal_t *ptr)
{
- struct length *l;
+ /* NULL -> null_parent which has bytelen 0 */
+ struct tal_hdr *t = debug_tal(to_tal_hdr_or_null(ptr));
- l = find_property(debug_tal(to_tal_hdr(ptr)), LENGTH);
- if (!l)
- return 0;
- return l->count;
+ return t->bytelen;
}
/* Start one past first child: make stopping natural in circ. list. */
return from_tal_hdr(c);
}
-tal_t *tal_next(const tal_t *root, const tal_t *prev)
+tal_t *tal_next(const tal_t *prev)
{
- struct tal_hdr *c, *t = debug_tal(to_tal_hdr(prev)), *top;
-
- /* Children? */
- c = first_child(t);
- if (c)
- return from_tal_hdr(c);
-
- top = to_tal_hdr_or_null(root);
- do {
- struct tal_hdr *next;
- struct list_node *end;
-
- end = &ignore_destroying_bit(t->parent_child)->children.n;
-
- next = list_entry(t->list.next, struct tal_hdr, list);
- if (&next->list != end)
- return from_tal_hdr(next);
+ struct tal_hdr *next, *prevhdr = debug_tal(to_tal_hdr(prev));
+ struct list_head *head;
- /* OK, go back to parent. */
- t = ignore_destroying_bit(t->parent_child)->parent;
- } while (t != top);
-
- return NULL;
+ head = &ignore_destroying_bit(prevhdr->parent_child)->children;
+ next = list_next(head, prevhdr, list);
+ if (!next)
+ return NULL;
+ return from_tal_hdr(next);
}
tal_t *tal_parent(const tal_t *ctx)
return from_tal_hdr(ignore_destroying_bit(t->parent_child)->parent);
}
-bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
+bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear)
{
struct tal_hdr *old_t, *t;
struct children *child;
- struct length *len;
old_t = debug_tal(to_tal_hdr(*ctxp));
if (!adjust_size(&size, count))
return false;
- t = resizefn(old_t, size + sizeof(struct tal_hdr));
+ t = resizefn(old_t, sizeof(struct tal_hdr) + size);
if (!t) {
call_error("Reallocation failure");
return false;
}
+ /* Clear between old end and new end. */
+ if (clear && size > t->bytelen) {
+ char *old_end = (char *)(t + 1) + t->bytelen;
+ memset(old_end, 0, size - t->bytelen);
+ }
+
+ /* Update length. */
+ t->bytelen = size;
+ update_bounds(t, sizeof(struct tal_hdr) + size);
+
/* If it didn't move, we're done! */
if (t != old_t) {
- update_bounds(t, size + sizeof(struct tal_hdr));
-
/* Fix up linked list pointers. */
- if (list_entry(t->list.next, struct tal_hdr, list) != old_t)
- t->list.next->prev = t->list.prev->next = &t->list;
+ t->list.next->prev = t->list.prev->next = &t->list;
+
+ /* Copy take() property. */
+ if (taken(from_tal_hdr(old_t)))
+ take(from_tal_hdr(t));
/* Fix up child property's parent pointer. */
child = find_property(t, CHILDREN);
}
*ctxp = from_tal_hdr(debug_tal(t));
if (notifiers)
- notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
+ notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t), 0);
}
- len = find_property(t, LENGTH);
- if (len)
- len->count = count;
if (notifiers)
- notify(t, TAL_NOTIFY_RESIZE, (void *)size);
+ notify(t, TAL_NOTIFY_RESIZE, (void *)size, 0);
return true;
}
+bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)
+{
+ size_t old_len;
+ bool ret = false;
+
+ old_len = debug_tal(to_tal_hdr(*ctxp))->bytelen;
+
+ /* Check for additive overflow */
+ if (old_len + count * size < old_len) {
+ call_error("dup size overflow");
+ goto out;
+ }
+
+ /* Don't point src inside thing we're expanding! */
+ assert(src < *ctxp
+ || (char *)src >= (char *)(*ctxp) + old_len);
+
+ if (!tal_resize_(ctxp, size, old_len/size + count, false))
+ goto out;
+
+ memcpy((char *)*ctxp + old_len, src, count * size);
+ ret = true;
+
+out:
+ if (taken(src))
+ tal_free(src);
+ return ret;
+}
+
void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
- size_t n, size_t extra, bool add_count,
- const char *label)
+ size_t n, size_t extra, bool nullok, const char *label)
{
void *ret;
size_t nbytes = size;
+ if (nullok && p == NULL) {
+ /* take(NULL) works. */
+ (void)taken(p);
+ return NULL;
+ }
+
if (!adjust_size(&nbytes, n)) {
if (taken(p))
tal_free(p);
if (taken(p)) {
if (unlikely(!p))
return NULL;
- if (unlikely(!tal_resize_((void **)&p, size, n + extra)))
+ if (unlikely(!tal_resize_((void **)&p, size, n + extra, false)))
return tal_free(p);
if (unlikely(!tal_steal(ctx, p)))
return tal_free(p);
return (void *)p;
}
- ret = tal_alloc_arr_(ctx, size, n + extra, false, add_count, label);
+ ret = tal_alloc_arr_(ctx, size, n + extra, false, label);
if (ret)
memcpy(ret, p, nbytes);
return ret;
}
+void *tal_dup_talarr_(const tal_t *ctx, const tal_t *src TAKES, const char *label)
+{
+ return tal_dup_(ctx, src, 1, tal_bytelen(src), 0, true, label);
+}
+
void tal_set_backend(void *(*alloc_fn)(size_t size),
void *(*resize_fn)(void *, size_t size),
void (*free_fn)(void *),
const struct prop_hdr *p;
for (i = 0; i < indent; i++)
- printf(" ");
- printf("%p", t);
+ fprintf(stderr, " ");
+ fprintf(stderr, "%p len=%zu", t, t->bytelen);
for (p = t->prop; p; p = p->next) {
struct children *c;
struct name *n;
struct notifier *no;
- struct length *l;
if (is_literal(p)) {
- printf(" \"%s\"", (const char *)p);
+ fprintf(stderr, " \"%s\"", (const char *)p);
break;
}
switch (p->type) {
case CHILDREN:
c = (struct children *)p;
- printf(" CHILDREN(%p):parent=%p,children={%p,%p}\n",
+ fprintf(stderr, " CHILDREN(%p):parent=%p,children={%p,%p}",
p, c->parent,
c->children.n.prev, c->children.n.next);
break;
case NAME:
n = (struct name *)p;
- printf(" NAME(%p):%s", p, n->name);
+ fprintf(stderr, " NAME(%p):%s", p, n->name);
break;
case NOTIFIER:
no = (struct notifier *)p;
- printf(" NOTIFIER(%p):fn=%p", p, no->u.notifyfn);
- break;
- case LENGTH:
- l = (struct length *)p;
- printf(" LENGTH(%p):count=%zu", p, l->count);
+ fprintf(stderr, " NOTIFIER(%p):fn=%p", p, no->u.notifyfn);
break;
default:
- printf(" **UNKNOWN(%p):%i**", p, p->type);
+ fprintf(stderr, " **UNKNOWN(%p):%i**", p, p->type);
}
}
- printf("\n");
+ fprintf(stderr, "\n");
}
static void tal_dump_(unsigned int level, const struct tal_hdr *t)
struct prop_hdr *p;
struct name *name = NULL;
struct children *children = NULL;
- struct length *length = NULL;
if (!in_bounds(t))
return check_err(t, errorstr, "invalid pointer");
if (name)
return check_err(t, errorstr,
"has extra literal");
- name = (struct name *)p;
break;
}
if (!in_bounds(p))
"has two child nodes");
children = (struct children *)p;
break;
- case LENGTH:
- if (length)
- return check_err(t, errorstr,
- "has two lengths");
- length = (struct length *)p;
- break;
case NOTIFIER:
break;
case NAME: