X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftal%2Ftal.c;h=1934a01318a3f09060614e144d189fff8467469b;hp=9b84c6e17bdf9b94856157d54bbab4f648981406;hb=d61a0d6c2c9d2b385075338665d64ae1d1bbe3dc;hpb=d73a2bcb320a016aa74262991cfd7685dc132056 diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c index 9b84c6e1..1934a013 100644 --- a/ccan/tal/tal.c +++ b/ccan/tal/tal.c @@ -3,9 +3,9 @@ #include #include #include +#include #include #include -#include #include #include #include @@ -13,12 +13,14 @@ //#define TAL_DEBUG 1 +#define NOTIFY_IS_DESTRUCTOR 512 + /* 32-bit type field, first byte 0 in either endianness. */ enum prop_type { CHILDREN = 0x00c1d500, - DESTRUCTOR = 0x00de5700, NAME = 0x00111100, - NOTIFIER = 0x00071f00 + NOTIFIER = 0x00071f00, + LENGTH = 0x00515300 }; struct tal_hdr { @@ -38,20 +40,23 @@ struct children { struct list_head children; /* Head of siblings. */ }; -struct destructor { - struct prop_hdr hdr; /* DESTRUCTOR */ - void (*destroy)(void *me); -}; - struct name { struct prop_hdr hdr; /* NAME */ char name[]; }; +struct length { + struct prop_hdr hdr; /* LENGTH */ + size_t count; +}; + struct notifier { struct prop_hdr hdr; /* NOTIFIER */ enum tal_notify_type types; - void (*notifyfn)(tal_t *, enum tal_notify_type, void *); + union { + void (*notifyfn)(tal_t *, enum tal_notify_type, void *); + void (*destroy)(tal_t *); /* If NOTIFY_IS_DESTRUCTOR set */ + } u; }; static struct { @@ -71,6 +76,8 @@ static void *(*allocfn)(size_t size) = malloc; 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) { @@ -92,26 +99,20 @@ static struct children *ignore_destroying_bit(struct children *parent_child) 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) { @@ -214,22 +215,19 @@ static void notify(const struct tal_hdr *ctx, if (p->type != NOTIFIER) continue; n = (struct notifier *)p; - if (n->types & type) - n->notifyfn(from_tal_hdr(ctx), type, (void *)info); + 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, + (void *)info); + } } } 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 @@ -272,39 +270,6 @@ static void init_property(struct prop_hdr *hdr, parent->prop = hdr; } -static struct destructor *add_destructor_property(struct tal_hdr *t, - void (*destroy)(void *)) -{ - struct destructor *prop = allocate(sizeof(*prop)); - if (prop) { - init_property(&prop->hdr, t, DESTRUCTOR); - prop->destroy = destroy; - } - return prop; -} - -static bool del_destructor_property(struct tal_hdr *t, - void (*destroy)(void *)) -{ - struct prop_hdr **p; - - for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) { - struct destructor *d; - - if (is_literal(*p)) - break; - if ((*p)->type != DESTRUCTOR) - continue; - d = (struct destructor *)*p; - if (d->destroy == destroy) { - *p = (*p)->next; - freefn(d); - return true; - } - } - return false; -} - static struct notifier *add_notifier_property(struct tal_hdr *t, enum tal_notify_type types, void (*fn)(void *, @@ -315,14 +280,15 @@ static struct notifier *add_notifier_property(struct tal_hdr *t, if (prop) { init_property(&prop->hdr, t, NOTIFIER); prop->types = types; - prop->notifyfn = fn; + prop->u.notifyfn = fn; } 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; @@ -334,13 +300,14 @@ static bool del_notifier_property(struct tal_hdr *t, if ((*p)->type != NOTIFIER) continue; n = (struct notifier *)*p; - if (n->notifyfn == fn) { + 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) @@ -372,11 +339,6 @@ static bool add_child(struct tal_hdr *parent, struct tal_hdr *child) 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; @@ -396,14 +358,6 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig) set_destroying_bit(&t->parent_child); - /* Carefully call destructors, removing as we go. */ - while ((prop = find_property_ptr(t, DESTRUCTOR))) { - struct destructor *d = (struct destructor *)*prop; - d->destroy(from_tal_hdr(t)); - *prop = d->hdr.next; - freefn(d); - } - /* Call free notifiers. */ notify(t, TAL_NOTIFY_FREE, (tal_t *)orig); @@ -422,7 +376,9 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig) /* 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); } @@ -442,18 +398,74 @@ void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label) 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; @@ -481,18 +493,20 @@ void *tal_steal_(const tal_t *new_parent, const tal_t *ctx) 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_destructor_property(t, destroy); + 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)); @@ -510,27 +524,34 @@ bool tal_add_notifier_(tal_t *ctx, enum tal_notify_type types, 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)) { - struct tal_hdr *t = debug_tal(to_tal_hdr(ctx)); - return del_destructor_property(t, destroy); + return tal_del_notifier_(ctx, (void *)destroy); } bool tal_set_name_(tal_t *ctx, const char *name, bool literal) @@ -559,7 +580,8 @@ bool tal_set_name_(tal_t *ctx, const char *name, bool literal) return false; debug_tal(t); - notify(t, TAL_NOTIFY_RENAME, name); + if (notifiers) + notify(t, TAL_NOTIFY_RENAME, name); return true; } @@ -576,6 +598,16 @@ const char *tal_name(const tal_t *t) 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) { @@ -638,32 +670,53 @@ 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) +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); @@ -672,45 +725,61 @@ bool tal_resize_(tal_t **ctxp, size_t size) 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; - /* We have to let through NULL for take(). */ - if (likely(p)) { - len = strlen(p); - if (len > n) - len = n; - } else - len = n; + /* Check for additive overflow */ + if (old_count + count < count) { + call_error("dup size overflow"); + goto out; + } - ret = tal_dup(ctx, char, p, len, 1); - if (ret) - ret[len] = '\0'; + /* Don't point src inside thing we're expanding! */ + assert(src < *ctxp + || (char *)src >= (char *)(*ctxp) + (size * old_count)); + + 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; + + if (!adjust_size(&nbytes, n)) { + if (taken(p)) + tal_free(p); + return NULL; + } - /* Beware overflow! */ - if (n + extra < n || n + extra + sizeof(struct tal_hdr) < n) { + /* Beware addition overflow! */ + if (n + extra < n) { call_error("dup size overflow"); if (taken(p)) tal_free(p); @@ -720,59 +789,19 @@ void *tal_dup_(const tal_t *ctx, const void *p, size_t n, size_t extra, 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 *), @@ -799,9 +828,9 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t) printf("%p", t); for (p = t->prop; p; p = p->next) { struct children *c; - struct destructor *d; struct name *n; struct notifier *no; + struct length *l; if (is_literal(p)) { printf(" \"%s\"", (const char *)p); break; @@ -813,17 +842,17 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t) p, c->parent, c->children.n.prev, c->children.n.next); break; - case DESTRUCTOR: - d = (struct destructor *)p; - printf(" DESTRUCTOR(%p):fn=%p", p, d->destroy); - break; case NAME: n = (struct name *)p; printf(" NAME(%p):%s", p, n->name); break; case NOTIFIER: no = (struct notifier *)p; - printf(" NOTIFIER(%p):fn=%p", p, no->notifyfn); + 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); @@ -872,6 +901,7 @@ static bool check_node(struct children *parent_child, 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"); @@ -898,7 +928,12 @@ static bool check_node(struct children *parent_child, "has two child nodes"); children = (struct children *)p; break; - case DESTRUCTOR: + case LENGTH: + if (length) + return check_err(t, errorstr, + "has two lengths"); + length = (struct length *)p; + break; case NOTIFIER: break; case NAME: