X-Git-Url: http://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Ftal%2Ftal.c;h=866f263ba871f7e2ca4cb430bc9a790f1637b941;hb=96dcdfbf1a400f7cb43cf3f0761f52fd6de9ff65;hp=c78185be01aa12715a0499088974ab8f561ccee6;hpb=83c75170a2be2e3fa58a139f866e957aa6b82995;p=ccan diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c index c78185be..866f263b 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 @@ -47,7 +47,7 @@ struct name { struct length { struct prop_hdr hdr; /* LENGTH */ - size_t count; + size_t len; }; struct notifier { @@ -76,7 +76,6 @@ 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; -static bool initialized = false; /* Count on non-destrutor notifiers; often stays zero. */ static size_t notifiers = 0; @@ -101,23 +100,19 @@ static struct children *ignore_destroying_bit(struct children *parent_child) } /* 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) { @@ -208,7 +203,8 @@ static struct tal_hdr *debug_tal(struct tal_hdr *tal) #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; @@ -221,6 +217,7 @@ static void notify(const struct tal_hdr *ctx, continue; n = (struct notifier *)p; if (n->types & type) { + errno = saved_errno; if (n->types & NOTIFY_IS_DESTRUCTOR) n->u.destroy(from_tal_hdr(ctx)); else @@ -327,20 +324,8 @@ static struct name *add_name_property(struct tal_hdr *t, const char *name) 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) { @@ -356,11 +341,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; @@ -370,7 +350,7 @@ static bool add_child(struct tal_hdr *parent, struct tal_hdr *child) 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; @@ -381,7 +361,7 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig) 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); @@ -391,48 +371,79 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig) while ((i = list_top(&c->children, struct tal_hdr, list))) { list_del(&i->list); - del_tree(i, orig); + del_tree(i, orig, saved_errno); } } /* 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); } -void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label) +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_(const tal_t *ctx, size_t size, + bool clear, bool add_length, 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; if (clear) - memset(from_tal_hdr(child), 0, size); + memset(from_tal_hdr(child), 0, req_size); child->prop = (void *)label; + + 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; } 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) + 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. */ - if (*size + sizeof(struct tal_hdr) < sizeof(struct tal_hdr)) + /* Make sure we don't wrap adding header/tailer. */ + if (*size + extra < extra) goto overflow; return true; overflow: @@ -441,19 +452,12 @@ overflow: } void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear, - bool add_count, const char *label) + bool add_length, 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, add_length, label); } void *tal_free(const tal_t *ctx) @@ -464,9 +468,9 @@ void *tal_free(const tal_t *ctx) t = debug_tal(to_tal_hdr(ctx)); 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; @@ -493,7 +497,7 @@ void *tal_steal_(const tal_t *new_parent, const tal_t *ctx) } debug_tal(newpar); if (notifiers) - notify(t, TAL_NOTIFY_STEAL, new_parent); + notify(t, TAL_NOTIFY_STEAL, new_parent, 0); } return (void *)ctx; } @@ -524,7 +528,7 @@ bool tal_add_notifier_(const tal_t *ctx, enum tal_notify_type types, 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) @@ -540,7 +544,7 @@ bool tal_del_notifier_(const tal_t *ctx, types = del_notifier_property(t, callback); 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; @@ -580,7 +584,7 @@ bool tal_set_name_(tal_t *ctx, const char *name, bool literal) debug_tal(t); if (notifiers) - notify(t, TAL_NOTIFY_RENAME, name); + notify(t, TAL_NOTIFY_RENAME, name, 0); return true; } @@ -597,14 +601,14 @@ const char *tal_name(const tal_t *t) return n->name; } -size_t tal_count(const tal_t *ptr) +size_t tal_len(const tal_t *ptr) { struct length *l; l = find_property(debug_tal(to_tal_hdr(ptr)), LENGTH); if (!l) return 0; - return l->count; + return l->len; } /* Start one past first child: make stopping natural in circ. list. */ @@ -629,31 +633,16 @@ tal_t *tal_first(const tal_t *root) 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; + struct tal_hdr *next, *prevhdr = debug_tal(to_tal_hdr(prev)); + struct list_head *head; - /* 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); - - /* 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) @@ -669,30 +658,61 @@ 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; + 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; - t = resizefn(old_t, size + sizeof(struct tal_hdr)); + 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); 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; + } + + 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); @@ -702,45 +722,47 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count) } *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; } -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, p, 1, p ? strlen(p) + 1: 1, 0, false, - TAL_LABEL(char, "[]")); -} + struct length *l; + size_t old_len; + 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_len = l->len; - /* 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_len + count * size < old_len) { + call_error("dup size overflow"); + goto out; + } - ret = tal_dup_(ctx, p, 1, len, 1, false, TAL_LABEL(char, "[]")); - if (ret) - ret[len] = '\0'; + /* 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, + size_t n, size_t extra, bool add_length, const char *label) { void *ret; @@ -763,60 +785,19 @@ void *tal_dup_(const tal_t *ctx, const void *p, size_t size, 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, add_length, label); if (ret) memcpy(ret, p, nbytes); 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); - - 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 *), @@ -867,7 +848,7 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t) break; case LENGTH: l = (struct length *)p; - printf(" LENGTH(%p):count=%zu", p, l->count); + printf(" LENGTH(%p):len=%zu", p, l->len); break; default: printf(" **UNKNOWN(%p):%i**", p, p->type); @@ -929,7 +910,6 @@ static bool check_node(struct children *parent_child, if (name) return check_err(t, errorstr, "has extra literal"); - name = (struct name *)p; break; } if (!in_bounds(p))