#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 <stdarg.h>
#include <stddef.h>
#include <string.h>
#include <limits.h>
enum prop_type {
CHILDREN = 0x00c1d500,
NAME = 0x00111100,
- NOTIFIER = 0x00071f00
+ NOTIFIER = 0x00071f00,
+ LENGTH = 0x00515300
};
struct tal_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;
static void *(*resizefn)(void *, size_t size) = realloc;
static void (*freefn)(void *) = free;
static void (*errorfn)(const char *msg) = (void *)abort;
+/* Count on non-destrutor notifiers; often stays zero. */
+static size_t notifiers = 0;
static inline void COLD call_error(const char *msg)
{
return (void *)((size_t)parent_child & ~(size_t)1);
}
-static bool initialized = false;
-
/* 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)
{
static void *allocate(size_t size)
{
- void *ret;
-
- /* Don't hand silly sizes to malloc. */
- if (size >> (CHAR_BIT*sizeof(size) - 1)) {
- call_error("allocation size overflow");
- return NULL;
- }
-
- ret = allocfn(size);
+ void *ret = allocfn(size);
if (!ret)
call_error("allocation failed");
else
return prop;
}
-static bool del_notifier_property(struct tal_hdr *t,
- void (*fn)(tal_t *,
- enum tal_notify_type, void *))
+static enum tal_notify_type del_notifier_property(struct tal_hdr *t,
+ void (*fn)(tal_t *,
+ enum tal_notify_type,
+ void *))
{
struct prop_hdr **p;
continue;
n = (struct notifier *)*p;
if (n->u.notifyfn == fn) {
+ enum tal_notify_type types = n->types;
*p = (*p)->next;
freefn(n);
- return true;
+ return types & ~NOTIFY_IS_DESTRUCTOR;
}
}
- return false;
+ return 0;
}
static struct name *add_name_property(struct tal_hdr *t, const char *name)
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;
/* Finally free our properties. */
for (p = t->prop; p && !is_literal(p); p = next) {
next = p->next;
- freefn(p);
+ /* LENGTH is appended, so don't free separately! */
+ if (p->type != LENGTH)
+ freefn(p);
}
freefn(t);
}
return NULL;
}
debug_tal(parent);
- notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(debug_tal(child)));
+ if (notifiers)
+ notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(child));
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) + sizeof(struct length)*2;
+
+ /* Multiplication wrap */
+ if (count && unlikely(*size * count / *size != count))
+ goto overflow;
+
+ *size *= count;
+
+ /* Make sure we don't wrap adding header/tailer. */
+ if (*size + extra < extra)
+ goto overflow;
+ return true;
+overflow:
+ call_error("allocation size overflow");
+ return false;
+}
+
+static size_t extra_for_length(size_t size)
+{
+ 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;
+}
+
+void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
+ bool add_count, const char *label)
+{
+ void *ret;
+
+ if (!adjust_size(&size, count))
+ return NULL;
+
+ if (add_count)
+ size += extra_for_length(size);
+
+ ret = tal_alloc_(ctx, size, clear, label);
+ if (unlikely(!ret))
+ return ret;
+
+ if (add_count) {
+ struct length *lprop;
+ lprop = (struct length *)((char *)ret + size) - 1;
+ init_property(&lprop->hdr, to_tal_hdr(ret), LENGTH);
+ lprop->count = count;
+ }
+ return ret;
+}
+
void *tal_free(const tal_t *ctx)
{
if (ctx) {
struct tal_hdr *t;
int saved_errno = errno;
t = debug_tal(to_tal_hdr(ctx));
- notify(ignore_destroying_bit(t->parent_child)->parent,
- TAL_NOTIFY_DEL_CHILD, ctx);
+ if (notifiers)
+ notify(ignore_destroying_bit(t->parent_child)->parent,
+ TAL_NOTIFY_DEL_CHILD, ctx);
list_del(&t->list);
del_tree(t, ctx);
errno = saved_errno;
return NULL;
}
debug_tal(newpar);
- notify(t, TAL_NOTIFY_STEAL, new_parent);
+ if (notifiers)
+ notify(t, TAL_NOTIFY_STEAL, new_parent);
}
return (void *)ctx;
}
-bool tal_add_destructor_(tal_t *ctx, void (*destroy)(void *me))
+bool tal_add_destructor_(const tal_t *ctx, void (*destroy)(void *me))
{
tal_t *t = debug_tal(to_tal_hdr(ctx));
return add_notifier_property(t, TAL_NOTIFY_FREE|NOTIFY_IS_DESTRUCTOR,
(void *)destroy);
}
-bool tal_add_notifier_(tal_t *ctx, enum tal_notify_type types,
+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));
if (unlikely(!n))
return false;
- notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback);
+ if (notifiers)
+ notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback);
+
n->types = types;
+ if (types != TAL_NOTIFY_FREE)
+ notifiers++;
return true;
}
-bool tal_del_notifier_(tal_t *ctx,
+bool tal_del_notifier_(const tal_t *ctx,
void (*callback)(tal_t *, enum tal_notify_type, void *))
{
struct tal_hdr *t = debug_tal(to_tal_hdr(ctx));
- bool ret;
+ enum tal_notify_type types;
- ret = del_notifier_property(t, callback);
- if (ret)
+ types = del_notifier_property(t, callback);
+ if (types) {
notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback);
- return ret;
+ if (types != TAL_NOTIFY_FREE)
+ notifiers--;
+ return true;
+ }
+ return false;
}
-bool tal_del_destructor_(tal_t *ctx, void (*destroy)(void *me))
+bool tal_del_destructor_(const tal_t *ctx, void (*destroy)(void *me))
{
return tal_del_notifier_(ctx, (void *)destroy);
}
return false;
debug_tal(t);
- notify(t, TAL_NOTIFY_RENAME, name);
+ if (notifiers)
+ notify(t, TAL_NOTIFY_RENAME, name);
return true;
}
return n->name;
}
+size_t tal_count(const tal_t *ptr)
+{
+ struct length *l;
+
+ l = find_property(debug_tal(to_tal_hdr(ptr)), LENGTH);
+ if (!l)
+ return 0;
+ return l->count;
+}
+
/* Start one past first child: make stopping natural in circ. list. */
static struct tal_hdr *first_child(struct tal_hdr *parent)
{
return from_tal_hdr(ignore_destroying_bit(t->parent_child)->parent);
}
-bool tal_resize_(tal_t **ctxp, size_t size)
+bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
{
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));
- /* Don't hand silly sizes to realloc. */
- if (size >> (CHAR_BIT*sizeof(size) - 1)) {
- call_error("Reallocation size overflow");
+ 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);
}
- t = resizefn(old_t, size + sizeof(struct tal_hdr));
+ t = resizefn(old_t, sizeof(struct tal_hdr) + size + extra);
if (!t) {
call_error("Reallocation failure");
return false;
}
+ /* Copy length to end. */
+ if (lenp) {
+ struct length *new_len;
+
+ new_len = (struct length *)((char *)(t + 1) + size);
+ len.count = count;
+ *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;
+ }
+
+ update_bounds(t, sizeof(struct tal_hdr) + size + extra);
+
/* 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;
/* Fix up child property's parent pointer. */
child = find_property(t, CHILDREN);
child->parent = t;
}
*ctxp = from_tal_hdr(debug_tal(t));
- notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
+ if (notifiers)
+ notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
}
- notify(t, TAL_NOTIFY_RESIZE, (void *)size);
+ if (notifiers)
+ notify(t, TAL_NOTIFY_RESIZE, (void *)size);
return true;
}
-char *tal_strdup(const tal_t *ctx, const char *p)
+bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)
{
- /* We have to let through NULL for take(). */
- return tal_dup(ctx, char, p, p ? strlen(p) + 1: 1, 0);
-}
+ struct length *l;
+ size_t old_count;
+ bool ret = false;
-char *tal_strndup(const tal_t *ctx, const char *p, size_t n)
-{
- size_t len;
- char *ret;
+ l = find_property(debug_tal(to_tal_hdr(*ctxp)), LENGTH);
+ old_count = l->count;
+
+ /* Check for additive overflow */
+ if (old_count + count < count) {
+ call_error("dup size overflow");
+ goto out;
+ }
- /* We have to let through NULL for take(). */
- if (likely(p)) {
- len = strlen(p);
- if (len > n)
- len = n;
- } else
- len = n;
+ /* Don't point src inside thing we're expanding! */
+ assert(src < *ctxp
+ || (char *)src >= (char *)(*ctxp) + (size * old_count));
- ret = tal_dup(ctx, char, p, len, 1);
- if (ret)
- ret[len] = '\0';
+ if (!tal_resize_(ctxp, size, old_count + count))
+ goto out;
+
+ memcpy((char *)*ctxp + size * old_count, 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 n, size_t extra,
+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)
{
void *ret;
+ size_t nbytes = size;
- /* Beware overflow! */
- if (n + extra < n || n + extra + sizeof(struct tal_hdr) < n) {
+ if (!adjust_size(&nbytes, n)) {
+ if (taken(p))
+ tal_free(p);
+ return NULL;
+ }
+
+ /* Beware addition overflow! */
+ if (n + extra < n) {
call_error("dup size overflow");
if (taken(p))
tal_free(p);
if (taken(p)) {
if (unlikely(!p))
return NULL;
- if (unlikely(!tal_resize_((void **)&p, n + extra)))
+ if (unlikely(!tal_resize_((void **)&p, size, n + extra)))
return tal_free(p);
if (unlikely(!tal_steal(ctx, p)))
return tal_free(p);
return (void *)p;
}
- ret = tal_alloc_(ctx, n + extra, false, label);
- if (ret)
- memcpy(ret, p, n);
- return ret;
-}
-
-char *tal_asprintf(const tal_t *ctx, const char *fmt, ...)
-{
- va_list ap;
- char *ret;
-
- va_start(ap, fmt);
- ret = tal_vasprintf(ctx, fmt, ap);
- va_end(ap);
+ ret = tal_alloc_arr_(ctx, size, n + extra, false, add_count, label);
+ if (ret)
+ memcpy(ret, p, nbytes);
return ret;
}
-char *tal_vasprintf(const tal_t *ctx, const char *fmt, va_list ap)
-{
- size_t max;
- char *buf;
- int ret;
-
- if (!fmt && taken(fmt))
- return NULL;
-
- /* A decent guess to start. */
- max = strlen(fmt) * 2;
- buf = tal_arr(ctx, char, max);
- while (buf) {
- va_list ap2;
-
- va_copy(ap2, ap);
- ret = vsnprintf(buf, max, fmt, ap2);
- va_end(ap2);
-
- if (ret < max)
- break;
- if (!tal_resize(&buf, max *= 2))
- buf = tal_free(buf);
- }
- if (taken(fmt))
- tal_free(fmt);
- return buf;
-}
-
void tal_set_backend(void *(*alloc_fn)(size_t size),
void *(*resize_fn)(void *, size_t size),
void (*free_fn)(void *),
struct children *c;
struct name *n;
struct notifier *no;
+ struct length *l;
if (is_literal(p)) {
printf(" \"%s\"", (const char *)p);
break;
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);
+ break;
default:
printf(" **UNKNOWN(%p):%i**", p, p->type);
}
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");
"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:
projects / ccan / blobdiff