X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftal%2Ftal.c;h=05d52e1dbe5cab4409461c42b2c26ed57b009987;hp=842059d031b76977d665b31f1aedd3259a86ff0f;hb=ca7c5a9e04f3ef526cb2a10ad63105af025aa49c;hpb=61f58ff94e35c9b8ac5488554e2554bc5c9888b3 diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c index 842059d0..05d52e1d 100644 --- a/ccan/tal/tal.c +++ b/ccan/tal/tal.c @@ -2,31 +2,36 @@ #include #include #include -#include #include #include #include #include #include #include +#include #include //#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 { @@ -45,25 +50,29 @@ struct name { 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 */ } 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, @@ -84,19 +93,19 @@ static inline void COLD call_error(const char *msg) 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. */ @@ -182,14 +191,14 @@ static void *from_tal_hdr(const struct tal_hdr *hdr) 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 "); @@ -203,7 +212,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; @@ -216,10 +226,20 @@ static void notify(const struct tal_hdr *ctx, 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); } } @@ -274,13 +294,22 @@ static struct notifier *add_notifier_property(struct tal_hdr *t, 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; } @@ -288,24 +317,33 @@ static struct notifier *add_notifier_property(struct tal_hdr *t, 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; } @@ -344,14 +382,16 @@ static bool add_child(struct tal_hdr *parent, struct tal_hdr *child) 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; @@ -359,7 +399,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); @@ -369,70 +409,43 @@ 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; - /* LENGTH is appended, so don't free separately! */ - if (p->type != LENGTH) - freefn(p); + freefn(p); } freefn(t); } -static size_t extra_for_length(size_t size) +void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label) { - 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, 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; } 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; + const size_t extra = sizeof(struct tal_hdr); /* Multiplication wrap */ if (count && unlikely(*size * count / *size != count)) @@ -440,7 +453,7 @@ static bool adjust_size(size_t *size, size_t 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; @@ -450,12 +463,12 @@ overflow: } 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 tal_alloc_(ctx, size, clear, add_length, label); + return tal_alloc_(ctx, size, clear, label); } void *tal_free(const tal_t *ctx) @@ -464,11 +477,13 @@ 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; @@ -487,7 +502,7 @@ void *tal_steal_(const tal_t *new_parent, const tal_t *ctx) 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(); @@ -495,7 +510,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; } @@ -504,13 +519,23 @@ 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); + (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); @@ -521,12 +546,12 @@ bool tal_add_notifier_(const tal_t *ctx, enum tal_notify_type 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) @@ -535,14 +560,15 @@ bool tal_add_notifier_(const tal_t *ctx, enum tal_notify_type types, } 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; @@ -552,7 +578,13 @@ bool tal_del_notifier_(const tal_t *ctx, 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) @@ -582,7 +614,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; } @@ -599,14 +631,12 @@ const char *tal_name(const tal_t *t) return n->name; } -size_t tal_len(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->len; + return t->bytelen; } /* Start one past first child: make stopping natural in circ. list. */ @@ -660,58 +690,37 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear) { 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) { @@ -720,22 +729,20 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear) } *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); } 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) { - 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) { @@ -760,8 +767,7 @@ out: } 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, const char *label) { void *ret; size_t nbytes = size; @@ -790,7 +796,7 @@ void *tal_dup_(const tal_t *ctx, const void *p, size_t size, return (void *)p; } - ret = tal_alloc_arr_(ctx, size, n + extra, false, add_length, label); + ret = tal_alloc_arr_(ctx, size, n + extra, false, label); if (ret) memcpy(ret, p, nbytes); return ret; @@ -818,41 +824,36 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t) 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):len=%zu", p, l->len); + 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) @@ -895,7 +896,6 @@ 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"); @@ -921,12 +921,6 @@ static bool check_node(struct children *parent_child, "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: