X-Git-Url: http://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Ftal%2Ftal.c;h=c9006857e599e3cea89ef39418b2dd62b0274d1a;hb=fce7c22f5ccfc10b0bd2bad8cc7553d113e1cde2;hp=194e74c68afc8d9662b00a2924a2b2cb1da28fb6;hpb=ca6991d861a02d1da8d51f71607a4d9d8e145850;p=ccan diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c index 194e74c6..c9006857 100644 --- a/ccan/tal/tal.c +++ b/ccan/tal/tal.c @@ -13,11 +13,13 @@ //#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 }; struct tal_hdr { @@ -37,16 +39,20 @@ 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 notifier { + struct prop_hdr hdr; /* NOTIFIER */ + enum tal_notify_type types; + union { + void (*notifyfn)(tal_t *, enum tal_notify_type, void *); + void (*destroy)(tal_t *); /* If NOTIFY_IS_DESTRUCTOR set */ + } u; +}; + static struct { struct tal_hdr hdr; struct children c; @@ -64,6 +70,9 @@ 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; static inline void COLD call_error(const char *msg) { @@ -85,8 +94,6 @@ 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) { @@ -169,9 +176,9 @@ static struct tal_hdr *to_tal_hdr_or_null(const void *ctx) return to_tal_hdr(ctx); } -static void *from_tal_hdr(struct tal_hdr *hdr) +static void *from_tal_hdr(const struct tal_hdr *hdr) { - return hdr + 1; + return (void *)(hdr + 1); } #ifdef TAL_DEBUG @@ -194,6 +201,29 @@ 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) +{ + const struct prop_hdr *p; + + for (p = ctx->prop; p; p = p->next) { + struct notifier *n; + + if (is_literal(p)) + break; + if (p->type != NOTIFIER) + 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, + (void *)info); + } + } +} + static void *allocate(size_t size) { void *ret; @@ -247,37 +277,44 @@ static void init_property(struct prop_hdr *hdr, parent->prop = hdr; } -static struct destructor *add_destructor_property(struct tal_hdr *t, - void (*destroy)(void *)) +static struct notifier *add_notifier_property(struct tal_hdr *t, + enum tal_notify_type types, + void (*fn)(void *, + enum tal_notify_type, + void *)) { - struct destructor *prop = allocate(sizeof(*prop)); + struct notifier *prop = allocate(sizeof(*prop)); if (prop) { - init_property(&prop->hdr, t, DESTRUCTOR); - prop->destroy = destroy; + init_property(&prop->hdr, t, NOTIFIER); + prop->types = types; + prop->u.notifyfn = fn; } return prop; } -static bool del_destructor_property(struct tal_hdr *t, - void (*destroy)(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; for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) { - struct destructor *d; + struct notifier *n; if (is_literal(*p)) break; - if ((*p)->type != DESTRUCTOR) + if ((*p)->type != NOTIFIER) continue; - d = (struct destructor *)*p; - if (d->destroy == destroy) { + n = (struct notifier *)*p; + if (n->u.notifyfn == fn) { + enum tal_notify_type types = n->types; *p = (*p)->next; - freefn(d); - return true; + freefn(n); + return types & ~NOTIFY_IS_DESTRUCTOR; } } - return false; + return 0; } static struct name *add_name_property(struct tal_hdr *t, const char *name) @@ -323,7 +360,7 @@ static bool add_child(struct tal_hdr *parent, struct tal_hdr *child) return true; } -static void del_tree(struct tal_hdr *t) +static void del_tree(struct tal_hdr *t, const tal_t *orig) { struct prop_hdr **prop, *p, *next; @@ -333,13 +370,8 @@ static void del_tree(struct tal_hdr *t) 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); /* Now free children and groups. */ prop = find_property_ptr(t, CHILDREN); @@ -349,7 +381,7 @@ static void del_tree(struct tal_hdr *t) while ((i = list_top(&c->children, struct tal_hdr, list))) { list_del(&i->list); - del_tree(i); + del_tree(i, orig); } } @@ -376,6 +408,8 @@ void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label) return NULL; } debug_tal(parent); + if (notifiers) + notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(child)); return from_tal_hdr(debug_tal(child)); } @@ -385,8 +419,11 @@ void *tal_free(const tal_t *ctx) struct tal_hdr *t; int saved_errno = errno; t = debug_tal(to_tal_hdr(ctx)); + if (notifiers) + notify(ignore_destroying_bit(t->parent_child)->parent, + TAL_NOTIFY_DEL_CHILD, ctx); list_del(&t->list); - del_tree(t); + del_tree(t, ctx); errno = saved_errno; } return NULL; @@ -412,18 +449,65 @@ void *tal_steal_(const tal_t *new_parent, const tal_t *ctx) return NULL; } debug_tal(newpar); + if (notifiers) + notify(t, TAL_NOTIFY_STEAL, new_parent); } return (void *)ctx; } bool tal_add_destructor_(tal_t *ctx, void (*destroy)(void *me)) { - return add_destructor_property(debug_tal(to_tal_hdr(ctx)), destroy); + 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, + void (*callback)(tal_t *, enum tal_notify_type, void *)) +{ + tal_t *t = debug_tal(to_tal_hdr(ctx)); + struct notifier *n; + + assert(types); + assert((types & ~(TAL_NOTIFY_FREE | TAL_NOTIFY_STEAL | TAL_NOTIFY_MOVE + | TAL_NOTIFY_RESIZE | TAL_NOTIFY_RENAME + | TAL_NOTIFY_ADD_CHILD | TAL_NOTIFY_DEL_CHILD + | TAL_NOTIFY_ADD_NOTIFIER + | TAL_NOTIFY_DEL_NOTIFIER)) == 0); + + /* Don't call notifier about itself: set types after! */ + n = add_notifier_property(t, 0, callback); + if (unlikely(!n)) + return false; + + 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, + void (*callback)(tal_t *, enum tal_notify_type, void *)) +{ + struct tal_hdr *t = debug_tal(to_tal_hdr(ctx)); + enum tal_notify_type types; + + types = del_notifier_property(t, callback); + if (types) { + notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback); + if (types != TAL_NOTIFY_FREE) + notifiers--; + return true; + } + return false; } bool tal_del_destructor_(tal_t *ctx, void (*destroy)(void *me)) { - return del_destructor_property(debug_tal(to_tal_hdr(ctx)), destroy); + return tal_del_notifier_(ctx, (void *)destroy); } bool tal_set_name_(tal_t *ctx, const char *name, bool literal) @@ -448,11 +532,12 @@ bool tal_set_name_(tal_t *ctx, const char *name, bool literal) /* Append literal. */ for (p = &t->prop; *p && !is_literal(*p); p = &(*p)->next); *p = (struct prop_hdr *)name; - return true; - } - if (!add_name_property(t, name)) + } else if (!add_name_property(t, name)) return false; + debug_tal(t); + if (notifiers) + notify(t, TAL_NOTIFY_RENAME, name); return true; } @@ -551,21 +636,26 @@ bool tal_resize_(tal_t **ctxp, size_t size) } /* If it didn't move, we're done! */ - if (t == old_t) - return true; - 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; - - /* Fix up child property's parent pointer. */ - child = find_property(t, CHILDREN); - if (child) { - assert(child->parent == old_t); - child->parent = t; + 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; + + /* Fix up child property's parent pointer. */ + child = find_property(t, CHILDREN); + if (child) { + assert(child->parent == old_t); + child->parent = t; + } + *ctxp = from_tal_hdr(debug_tal(t)); + if (notifiers) + notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t)); } - *ctxp = from_tal_hdr(debug_tal(t)); + if (notifiers) + notify(t, TAL_NOTIFY_RESIZE, (void *)size); + return true; } @@ -689,8 +779,8 @@ 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; if (is_literal(p)) { printf(" \"%s\"", (const char *)p); break; @@ -702,14 +792,14 @@ 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->u.notifyfn); + break; default: printf(" **UNKNOWN(%p):%i**", p, p->type); } @@ -783,7 +873,7 @@ static bool check_node(struct children *parent_child, "has two child nodes"); children = (struct children *)p; break; - case DESTRUCTOR: + case NOTIFIER: break; case NAME: if (name)