#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;
+ /* Use is_prop_hdr tell if this is a struct prop_hdr or string! */
+ char *prop;
+ /* XOR with TAL_PTR_OBFUSTICATOR */
+ intptr_t parent_child;
+ size_t bytelen;
};
struct prop_hdr {
enum prop_type type;
- struct prop_hdr *next;
+ /* Use is_prop_hdr to tell if this is a struct prop_hdr or string! */
+ char *next;
};
struct children {
char name[];
};
-struct length {
- struct prop_hdr hdr; /* LENGTH */
- size_t len;
-};
-
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 */
struct tal_hdr hdr;
struct children c;
} null_parent = { { { &null_parent.hdr.list, &null_parent.hdr.list },
- &null_parent.c.hdr, NULL },
+ (char *)&null_parent.c.hdr, TAL_PTR_OBFUSTICATOR, 0 },
{ { CHILDREN, NULL },
&null_parent.hdr,
{ { &null_parent.c.children.n,
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. */
}
/* We carefully start all real properties with a zero byte. */
-static bool is_literal(const struct prop_hdr *prop)
+static struct prop_hdr *is_prop_hdr(const char *ptr)
{
- return ((char *)prop)[0] != 0;
+ if (*ptr != 0)
+ return NULL;
+ return (struct prop_hdr *)ptr;
}
#ifndef NDEBUG
check_bounds(ignore_destroying_bit(t->parent_child));
check_bounds(t->list.next);
check_bounds(t->list.prev);
- if (t->prop && !is_literal(t->prop))
- check_bounds(t->prop);
+ if (t->prop) {
+ struct prop_hdr *p = is_prop_hdr(t->prop);
+ if (p)
+ check_bounds(p);
+ }
return t;
}
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 ");
enum tal_notify_type type, const void *info,
int saved_errno)
{
- const struct prop_hdr *p;
+ const char *ptr;
+ const struct prop_hdr *p;
- for (p = ctx->prop; p; p = p->next) {
+ for (ptr = ctx->prop; ptr && (p = is_prop_hdr(ptr)) != NULL; ptr = p->next) {
struct notifier *n;
- if (is_literal(p))
- break;
if (p->type != NOTIFIER)
continue;
n = (struct notifier *)p;
if (n->types & 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)
- n->u.destroy2(from_tal_hdr(ctx),
- EXTRA_ARG(n));
+ cb.destroy2(from_tal_hdr(ctx),
+ EXTRA_ARG(n));
else
- n->u.destroy(from_tal_hdr(ctx));
+ cb.destroy(from_tal_hdr(ctx));
} else
- n->u.notifyfn(from_tal_hdr(ctx), type,
+ n->u.notifyfn(from_tal_hdr_or_null(ctx), type,
(void *)info);
}
}
return ret;
}
-static struct prop_hdr **find_property_ptr(const struct tal_hdr *t,
- enum prop_type type)
+/* Returns a pointer to the pointer: can cast (*ret) to a (struct prop_ptr *) */
+static char **find_property_ptr(struct tal_hdr *t, enum prop_type type)
{
- struct prop_hdr **p;
+ char **ptr;
+ struct prop_hdr *p;
- for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) {
- if (is_literal(*p)) {
- if (type == NAME)
- return p;
- break;
- }
- if ((*p)->type == type)
- return p;
- }
- return NULL;
+ /* NAME is special, as it can be a literal: see find_name_property */
+ assert(type != NAME);
+ for (ptr = &t->prop; *ptr; ptr = &p->next) {
+ if (!is_prop_hdr(*ptr))
+ break;
+ p = (struct prop_hdr *)*ptr;
+ if (p->type == type)
+ return ptr;
+ }
+ return NULL;
+}
+
+/* This is special:
+ * NULL - not found
+ * *literal: true - char **, pointer to literal pointer.
+ * *literal: false - struct prop_hdr **, pointer to header ptr.
+ */
+static char **find_name_property(struct tal_hdr *t, bool *literal)
+{
+ char **ptr;
+ struct prop_hdr *p;
+
+ for (ptr = &t->prop; *ptr; ptr = &p->next) {
+ if (!is_prop_hdr(*ptr)) {
+ *literal = true;
+ return ptr;
+ }
+ p = (struct prop_hdr *)*ptr;
+ if (p->type == NAME) {
+ *literal = false;
+ return ptr;
+ }
+ }
+ return NULL;
}
-static void *find_property(const struct tal_hdr *parent, enum prop_type type)
+static void *find_property(struct tal_hdr *parent, enum prop_type type)
{
- struct prop_hdr **p = find_property_ptr(parent, type);
+ char **ptr = find_property_ptr(parent, type);
- if (p)
- return *p;
+ if (ptr)
+ return (struct prop_hdr *)*ptr;
return NULL;
}
{
hdr->type = type;
hdr->next = parent->prop;
- parent->prop = hdr;
+ parent->prop = (char *)hdr;
}
static struct notifier *add_notifier_property(struct tal_hdr *t,
bool match_extra_arg,
void *extra_arg)
{
- struct prop_hdr **p;
+ char **ptr;
+ struct prop_hdr *p;
- for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) {
+ for (ptr = &t->prop; *ptr; ptr = &p->next) {
struct notifier *n;
enum tal_notify_type types;
- if (is_literal(*p))
+ p = is_prop_hdr(*ptr);
+ if (!p)
break;
- if ((*p)->type != NOTIFIER)
+
+ if (p->type != NOTIFIER)
continue;
- n = (struct notifier *)*p;
+ n = (struct notifier *)p;
if (n->u.notifyfn != fn)
continue;
&& extra_arg != EXTRA_ARG(n))
continue;
- *p = (*p)->next;
- freefn(n);
+ *ptr = p->next;
+ freefn(p);
return types & ~(NOTIFY_IS_DESTRUCTOR|NOTIFY_EXTRA_ARG);
}
return 0;
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, int saved_errno)
{
- struct prop_hdr **prop, *p, *next;
+ struct prop_hdr *prop;
+ char *ptr, *next;
+
+ assert(!taken(from_tal_hdr(t)));
/* Already being destroyed? Don't loop. */
if (unlikely(get_destroying_bit(t->parent_child)))
notify(t, TAL_NOTIFY_FREE, (tal_t *)orig, saved_errno);
/* Now free children and groups. */
- prop = find_property_ptr(t, CHILDREN);
+ prop = find_property(t, CHILDREN);
if (prop) {
struct tal_hdr *i;
- struct children *c = (struct children *)*prop;
+ struct children *c = (struct children *)prop;
while ((i = list_top(&c->children, struct tal_hdr, list))) {
list_del(&i->list);
}
/* Finally free our properties. */
- for (p = t->prop; p && !is_literal(p); p = next) {
- next = p->next;
- /* LENGTH is appended, so don't free separately! */
- if (p->type != LENGTH)
- freefn(p);
+ for (ptr = t->prop; ptr && (prop = is_prop_hdr(ptr)); ptr = next) {
+ next = prop->next;
+ freefn(ptr);
}
freefn(t);
}
-static size_t extra_for_length(size_t size)
+/* Don't have compiler complain we're returning NULL if we promised not to! */
+static void *null_alloc_failed(void)
{
- size_t extra;
- const size_t align = ALIGNOF(struct length);
-
- /* Round up size, and add tailer. */
- extra = ((size + align-1) & ~(align-1)) - size;
- extra += sizeof(struct length);
- return extra;
+#ifdef CCAN_TAL_NEVER_RETURN_NULL
+ abort();
+#else
+ return NULL;
+#endif /* CCAN_TAL_NEVER_RETURN_NULL */
}
-void *tal_alloc_(const tal_t *ctx, size_t size,
- bool clear, bool add_length, const char *label)
+void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label)
{
- size_t req_size = size;
struct tal_hdr *child, *parent = debug_tal(to_tal_hdr_or_null(ctx));
-#ifdef CCAN_TAL_DEBUG
- /* Always record length if debugging. */
- add_length = true;
-#endif
- if (add_length)
- size += extra_for_length(size);
-
child = allocate(sizeof(struct tal_hdr) + size);
if (!child)
- return NULL;
+ return null_alloc_failed();
+
if (clear)
- memset(from_tal_hdr(child), 0, req_size);
+ memset(from_tal_hdr(child), 0, size);
child->prop = (void *)label;
+ child->bytelen = size;
- if (add_length) {
- struct length *lprop;
- lprop = (struct length *)((char *)(child+1) + size) - 1;
- init_property(&lprop->hdr, child, LENGTH);
- lprop->len = req_size;
- }
if (!add_child(parent, child)) {
freefn(child);
- return NULL;
+ return null_alloc_failed();
}
debug_tal(parent);
if (notifiers)
static bool adjust_size(size_t *size, size_t count)
{
- const size_t extra = sizeof(struct tal_hdr) + sizeof(struct length)*2;
+ const size_t extra = sizeof(struct tal_hdr);
/* Multiplication wrap */
if (count && unlikely(*size * count / *size != count))
*size *= count;
- /* Make sure we don't wrap adding header/tailer. */
+ /* Make sure we don't wrap adding header. */
if (*size + extra < extra)
goto overflow;
return true;
}
void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
- bool add_length, const char *label)
+ const char *label)
{
if (!adjust_size(&size, count))
- return NULL;
+ return null_alloc_failed();
- return tal_alloc_(ctx, size, clear, add_length, label);
+ 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, saved_errno);
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();
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);
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, match_extra_arg, extra_arg);
bool tal_set_name_(tal_t *ctx, const char *name, bool literal)
{
struct tal_hdr *t = debug_tal(to_tal_hdr(ctx));
- struct prop_hdr **prop = find_property_ptr(t, NAME);
+ bool was_literal;
+ char **nptr;
/* Get rid of any old name */
- if (prop) {
- struct name *name = (struct name *)*prop;
- if (is_literal(&name->hdr))
- *prop = NULL;
- else {
- *prop = name->hdr.next;
- freefn(name);
- }
+ nptr = find_name_property(t, &was_literal);
+ if (nptr) {
+ if (was_literal)
+ *nptr = NULL;
+ else {
+ struct name *oldname;
+
+ oldname = (struct name *)*nptr;
+ *nptr = oldname->hdr.next;
+ freefn(oldname);
+ }
}
if (literal && name[0]) {
- struct prop_hdr **p;
+ char **ptr;
+ struct prop_hdr *prop;
/* Append literal. */
- for (p = &t->prop; *p && !is_literal(*p); p = &(*p)->next);
- *p = (struct prop_hdr *)name;
+ for (ptr = &t->prop; *ptr; ptr = &prop->next) {
+ prop = is_prop_hdr(*ptr);
+ if (!prop)
+ break;
+ }
+ *ptr = (char *)name;
} else if (!add_name_property(t, name))
return false;
const char *tal_name(const tal_t *t)
{
- struct name *n;
+ char **nptr;
+ bool literal;
- n = find_property(debug_tal(to_tal_hdr(t)), NAME);
- if (!n)
+ nptr = find_name_property(debug_tal(to_tal_hdr(t)), &literal);
+ if (!nptr)
return NULL;
+ if (literal)
+ return *nptr;
- if (is_literal(&n->hdr))
- return (const char *)n;
- return n->name;
+ return ((struct name *)(*nptr))->name;
}
-size_t tal_len(const tal_t *ptr)
+size_t tal_bytelen(const tal_t *ptr)
{
- struct length *l;
-
- if (!ptr)
- return 0;
+ /* 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->len;
+ return t->bytelen;
}
/* Start one past first child: make stopping natural in circ. list. */
{
struct tal_hdr *old_t, *t;
struct children *child;
- struct prop_hdr **lenp;
- struct length len;
- size_t extra = 0;
old_t = debug_tal(to_tal_hdr(*ctxp));
if (!adjust_size(&size, count))
return false;
- lenp = find_property_ptr(old_t, LENGTH);
- if (lenp) {
- /* Copy here, in case we're shrinking! */
- len = *(struct length *)*lenp;
- extra = extra_for_length(size);
- } else /* If we don't have an old length, we can't clear! */
- assert(!clear);
-
- t = resizefn(old_t, sizeof(struct tal_hdr) + size + extra);
+ t = resizefn(old_t, sizeof(struct tal_hdr) + size);
if (!t) {
call_error("Reallocation failure");
return false;
}
- /* Copy length to end. */
- if (lenp) {
- struct length *new_len;
-
- /* Clear between old end and new end. */
- if (clear && size > len.len) {
- char *old_end = (char *)(t + 1) + len.len;
- memset(old_end, 0, size - len.len);
- }
-
- new_len = (struct length *)((char *)(t + 1) + size
- + extra - sizeof(len));
- len.len = size;
- *new_len = len;
-
- /* Be careful replacing next ptr; could be old hdr. */
- if (lenp == &old_t->prop)
- t->prop = &new_len->hdr;
- else
- *lenp = &new_len->hdr;
+ /* 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_bounds(t, sizeof(struct tal_hdr) + size + extra);
+ /* 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) {
/* Fix up linked list pointers. */
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);
if (child) {
bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)
{
- struct length *l;
size_t old_len;
bool ret = false;
- l = find_property(debug_tal(to_tal_hdr(*ctxp)), LENGTH);
- old_len = l->len;
+ old_len = debug_tal(to_tal_hdr(*ctxp))->bytelen;
/* Check for additive overflow */
if (old_len + count * size < old_len) {
}
void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
- size_t n, size_t extra, bool add_length,
- 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);
return (void *)p;
}
- ret = tal_alloc_arr_(ctx, size, n + extra, false, add_length, label);
- if (ret)
+ ret = tal_alloc_arr_(ctx, size, n + extra, false, label);
+ if (ret && p)
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 *),
static void dump_node(unsigned int indent, const struct tal_hdr *t)
{
unsigned int i;
- const struct prop_hdr *p;
+ const struct prop_hdr *prop;
+ const char *ptr;
for (i = 0; i < indent; i++)
- printf(" ");
- printf("%p", t);
- for (p = t->prop; p; p = p->next) {
+ fprintf(stderr, " ");
+ fprintf(stderr, "%p len=%zu", t, t->bytelen);
+ for (ptr = t->prop; ptr; ptr = prop->next) {
struct children *c;
struct name *n;
struct notifier *no;
- struct length *l;
- if (is_literal(p)) {
- printf(" \"%s\"", (const char *)p);
+ prop = is_prop_hdr(ptr);
+ if (!prop) {
+ fprintf(stderr, " \"%s\"", ptr);
break;
}
- switch (p->type) {
+ switch (prop->type) {
case CHILDREN:
- c = (struct children *)p;
- printf(" CHILDREN(%p):parent=%p,children={%p,%p}\n",
- p, c->parent,
+ c = (struct children *)prop;
+ fprintf(stderr, " CHILDREN(%p):parent=%p,children={%p,%p}",
+ prop, c->parent,
c->children.n.prev, c->children.n.next);
break;
case NAME:
- n = (struct name *)p;
- printf(" NAME(%p):%s", p, n->name);
+ n = (struct name *)prop;
+ fprintf(stderr, " NAME(%p):%s", prop, 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):len=%zu", p, l->len);
+ no = (struct notifier *)prop;
+ fprintf(stderr, " NOTIFIER(%p):fn=%p", prop, no->u.notifyfn);
break;
default:
- printf(" **UNKNOWN(%p):%i**", p, p->type);
+ fprintf(stderr, " **UNKNOWN(%p):%i**", prop, prop->type);
}
}
- printf("\n");
+ fprintf(stderr, "\n");
}
static void tal_dump_(unsigned int level, const struct tal_hdr *t)
dump_node(level, t);
- children = find_property(t, CHILDREN);
+ children = find_property((struct tal_hdr *)t, CHILDREN);
if (children) {
struct tal_hdr *i;
static bool check_node(struct children *parent_child,
struct tal_hdr *t, const char *errorstr)
{
- struct prop_hdr *p;
+ struct prop_hdr *prop;
+ char *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 (ignore_destroying_bit(t->parent_child) != parent_child)
return check_err(t, errorstr, "incorrect parent");
- for (p = t->prop; p; p = p->next) {
- if (is_literal(p)) {
+ for (p = t->prop; p; p = prop->next) {
+ prop = is_prop_hdr(p);
+ if (!prop) {
if (name)
return check_err(t, errorstr,
"has extra literal");
break;
}
- if (!in_bounds(p))
+ if (!in_bounds(prop))
return check_err(t, errorstr,
"has bad property pointer");
- switch (p->type) {
+ switch (prop->type) {
case CHILDREN:
if (children)
return check_err(t, errorstr,
"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;
+ children = (struct children *)prop;
break;
case NOTIFIER:
break;
if (name)
return check_err(t, errorstr,
"has two names");
- name = (struct name *)p;
+ name = (struct name *)prop;
break;
default:
return check_err(t, errorstr, "has unknown property");