From: Rusty Russell Date: Mon, 3 Dec 2012 08:59:38 +0000 (+1030) Subject: tal: add general notifiers. X-Git-Url: https://git.ozlabs.org/?p=ccan;a=commitdiff_plain;h=d73a2bcb320a016aa74262991cfd7685dc132056 tal: add general notifiers. Signed-off-by: Rusty Russell --- diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c index 194e74c6..9b84c6e1 100644 --- a/ccan/tal/tal.c +++ b/ccan/tal/tal.c @@ -18,6 +18,7 @@ enum prop_type { CHILDREN = 0x00c1d500, DESTRUCTOR = 0x00de5700, NAME = 0x00111100, + NOTIFIER = 0x00071f00 }; struct tal_hdr { @@ -47,6 +48,12 @@ struct name { char name[]; }; +struct notifier { + struct prop_hdr hdr; /* NOTIFIER */ + enum tal_notify_type types; + void (*notifyfn)(tal_t *, enum tal_notify_type, void *); +}; + static struct { struct tal_hdr hdr; struct children c; @@ -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,24 @@ 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) + n->notifyfn(from_tal_hdr(ctx), type, (void *)info); + } +} + static void *allocate(size_t size) { void *ret; @@ -280,6 +305,44 @@ static bool del_destructor_property(struct tal_hdr *t, return false; } +static struct notifier *add_notifier_property(struct tal_hdr *t, + enum tal_notify_type types, + void (*fn)(void *, + enum tal_notify_type, + void *)) +{ + struct notifier *prop = allocate(sizeof(*prop)); + if (prop) { + init_property(&prop->hdr, t, NOTIFIER); + prop->types = types; + prop->notifyfn = fn; + } + return prop; +} + +static bool 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 notifier *n; + + if (is_literal(*p)) + break; + if ((*p)->type != NOTIFIER) + continue; + n = (struct notifier *)*p; + if (n->notifyfn == fn) { + *p = (*p)->next; + freefn(n); + return true; + } + } + return false; +} + static struct name *add_name_property(struct tal_hdr *t, const char *name) { struct name *prop; @@ -323,7 +386,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; @@ -341,6 +404,9 @@ static void del_tree(struct tal_hdr *t) freefn(d); } + /* Call free notifiers. */ + notify(t, TAL_NOTIFY_FREE, (tal_t *)orig); + /* Now free children and groups. */ prop = find_property_ptr(t, CHILDREN); if (prop) { @@ -349,7 +415,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 +442,7 @@ 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))); return from_tal_hdr(debug_tal(child)); } @@ -385,8 +452,10 @@ void *tal_free(const tal_t *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); list_del(&t->list); - del_tree(t); + del_tree(t, ctx); errno = saved_errno; } return NULL; @@ -412,18 +481,56 @@ void *tal_steal_(const tal_t *new_parent, const tal_t *ctx) return NULL; } debug_tal(newpar); + 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_destructor_property(t, 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; + + notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback); + n->types = types; + 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)); + bool ret; + + ret = del_notifier_property(t, callback); + if (ret) + notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback); + return ret; } bool tal_del_destructor_(tal_t *ctx, void (*destroy)(void *me)) { - return del_destructor_property(debug_tal(to_tal_hdr(ctx)), destroy); + struct tal_hdr *t = debug_tal(to_tal_hdr(ctx)); + return del_destructor_property(t, destroy); } bool tal_set_name_(tal_t *ctx, const char *name, bool literal) @@ -448,11 +555,11 @@ 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); + notify(t, TAL_NOTIFY_RENAME, name); return true; } @@ -551,21 +658,24 @@ 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)); + notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t)); } - *ctxp = from_tal_hdr(debug_tal(t)); + notify(t, TAL_NOTIFY_RESIZE, (void *)size); + return true; } @@ -691,6 +801,7 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t) struct children *c; struct destructor *d; struct name *n; + struct notifier *no; if (is_literal(p)) { printf(" \"%s\"", (const char *)p); break; @@ -710,6 +821,10 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t) 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); + break; default: printf(" **UNKNOWN(%p):%i**", p, p->type); } @@ -784,6 +899,7 @@ static bool check_node(struct children *parent_child, children = (struct children *)p; break; case DESTRUCTOR: + case NOTIFIER: break; case NAME: if (name) diff --git a/ccan/tal/tal.h b/ccan/tal/tal.h index 7efc824a..8ee27c36 100644 --- a/ccan/tal/tal.h +++ b/ccan/tal/tal.h @@ -126,6 +126,8 @@ void *tal_free(const tal_t *p); * tal_add_destructor - add a callback function when this context is destroyed. * @ptr: The tal allocated object. * @function: the function to call before it's freed. + * + * Note that this can only fail if your allocfn fails and your errorfn returns. */ #define tal_add_destructor(ptr, function) \ tal_add_destructor_((ptr), typesafe_cb(void, void *, (function), (ptr))) @@ -141,6 +143,71 @@ void *tal_free(const tal_t *p); #define tal_del_destructor(ptr, function) \ tal_del_destructor_((ptr), typesafe_cb(void, void *, (function), (ptr))) +enum tal_notify_type { + TAL_NOTIFY_FREE = 1, + TAL_NOTIFY_STEAL = 2, + TAL_NOTIFY_MOVE = 4, + TAL_NOTIFY_RESIZE = 8, + TAL_NOTIFY_RENAME = 16, + TAL_NOTIFY_ADD_CHILD = 32, + TAL_NOTIFY_DEL_CHILD = 64, + TAL_NOTIFY_ADD_NOTIFIER = 128, + TAL_NOTIFY_DEL_NOTIFIER = 256 +}; + +/** + * tal_add_notifier - add a callback function when this context changes. + * @ptr: The tal allocated object. + * @types: Bitwise OR of the types the callback is interested in. + * @callback: the function to call. + * + * Note that this can only fail if your allocfn fails and your errorfn + * returns. Also note that notifiers are not reliable in the case + * where an allocation fails, as they may be called before any + * allocation is actually done. + * + * TAL_NOTIFY_FREE is called when @ptr is freed, either directly or + * because an ancestor is freed: @info is the argument to tal_free(). + * It is exactly equivalent to a destructor, with more information. + * + * TAL_NOTIFY_STEAL is called when @ptr's parent changes: @info is the + * new parent. + * + * TAL_NOTIFY_MOVE is called when @ptr is realloced (via tal_resize) + * and moved. In this case, @ptr arg here is the new memory, and + * @info is the old pointer. + * + * TAL_NOTIFY_RESIZE is called when @ptr is realloced via tal_resize: + * @info is the new size, in bytes. If the pointer has moved, + * TAL_NOTIFY_MOVE callbacks are called first. + * + * TAL_NOTIFY_ADD_CHILD/TAL_NOTIFY_DEL_CHILD are called when @ptr is + * the context for a tal() allocating call, or a direct child is + * tal_free()d: @info is the child. Note that TAL_NOTIFY_DEL_CHILD is + * not called when this context is tal_free()d: TAL_NOTIFY_FREE is + * considered sufficient for that case. + * + * TAL_NOTIFY_ADD_NOTIFIER/TAL_NOTIFIER_DEL_NOTIFIER are called when + * a notifier is added or removed (not for this notifier): @info is the + * callback. + */ +#define tal_add_notifier(ptr, types, callback) \ + tal_add_notifier_((ptr), (types), \ + typesafe_cb_postargs(void, tal_t *, (callback), \ + (ptr), \ + enum tal_notify_type, void *)) + +/** + * tal_del_notifier - remove a notifier callback function. + * @ptr: The tal allocated object. + * @callback: the function to call. + */ +#define tal_del_notifier(ptr, callback) \ + tal_del_notifier_((ptr), \ + typesafe_cb_postargs(void, void *, (callback), \ + (ptr), \ + enum tal_notify_type, void *)) + /** * tal_set_name - attach a name to a tal pointer. * @ptr: The tal allocated object. @@ -337,4 +404,10 @@ bool tal_resize_(tal_t **ctxp, size_t size); bool tal_add_destructor_(tal_t *ctx, void (*destroy)(void *me)); bool tal_del_destructor_(tal_t *ctx, void (*destroy)(void *me)); +bool tal_add_notifier_(tal_t *ctx, enum tal_notify_type types, + void (*notify)(tal_t *ctx, enum tal_notify_type, + void *info)); +bool tal_del_notifier_(tal_t *ctx, + void (*notify)(tal_t *ctx, enum tal_notify_type, + void *info)); #endif /* CCAN_TAL_H */ diff --git a/ccan/tal/test/run-notifier.c b/ccan/tal/test/run-notifier.c new file mode 100644 index 00000000..f085b825 --- /dev/null +++ b/ccan/tal/test/run-notifier.c @@ -0,0 +1,130 @@ +#include +#include +#include + +static enum tal_notify_type expect; +static void *expect_info; +static char *ctx; +static unsigned int notified1, notified2; + +/* Make sure we always move on resize. */ +static void *my_realloc(void *old, size_t size) +{ + void *new = realloc(old, size); + if (new == old) { + void *p = malloc(size); + memcpy(p, old, size); + free(old); + new = p; + } + return new; +} + +static void notify1(char *p, enum tal_notify_type notify, void *info) +{ + ok1(ctx == ctx); + ok1(notify == expect); + if (expect_info == &expect_info) + expect_info = info; + else + ok1(info == expect_info); + notified1++; +} + +static void notify2(char *ctx, enum tal_notify_type notify, void *info) +{ + notified2++; +} + +static bool seen_move, seen_resize; +static void resize_notifier(char *p, enum tal_notify_type notify, void *info) +{ + if (notify == TAL_NOTIFY_MOVE) { + ok1(!seen_move); + ok1(!seen_resize); + ok1(info == ctx); + ok1(p != ctx); + ctx = p; + seen_move = true; + } else if (notify == TAL_NOTIFY_RESIZE) { + ok1(!seen_resize); + ok1(seen_move); + ok1(p == ctx); + ok1((size_t)info == 100); + seen_resize = true; + } else + fail("Unexpected notifier %i", notify); +} + +int main(void) +{ + char *child, *new_ctx; + + plan_tests(56); + + ctx = tal(NULL, char); + ok1(tal_add_notifier(ctx, 511, notify1)); + ok1(notified1 == 0); + ok1(notified2 == 0); + + expect = TAL_NOTIFY_STEAL; + expect_info = NULL; + ok1(tal_steal(NULL, ctx) == ctx); + ok1(notified1 == 1); + + expect = TAL_NOTIFY_ADD_NOTIFIER; + expect_info = notify2; + ok1(tal_add_notifier(ctx, TAL_NOTIFY_RENAME|TAL_NOTIFY_ADD_NOTIFIER + |TAL_NOTIFY_DEL_NOTIFIER, notify2)); + ok1(notified1 == 2); + ok1(notified2 == 0); + + expect = TAL_NOTIFY_RENAME; + expect_info = (char *)"newname"; + ok1(tal_set_name(ctx, (char *)expect_info)); + ok1(notified1 == 3); + ok1(notified2 == 1); + + expect = TAL_NOTIFY_DEL_NOTIFIER; + expect_info = notify2; + ok1(tal_del_notifier(ctx, notify2)); + ok1(notified1 == 4); + ok1(notified2 == 1); + + /* Failed delete should not call notifier! */ + expect = TAL_NOTIFY_DEL_NOTIFIER; + expect_info = notify2; + ok1(!tal_del_notifier(ctx, notify2)); + ok1(notified1 == 4); + ok1(notified2 == 1); + + expect = TAL_NOTIFY_ADD_CHILD; + expect_info = &expect_info; + child = tal(ctx, char); + ok1(notified1 == 5); + ok1(notified2 == 1); + ok1(expect_info == child); + + expect = TAL_NOTIFY_DEL_CHILD; + expect_info = child; + tal_free(child); + ok1(notified1 == 6); + ok1(notified2 == 1); + + expect = TAL_NOTIFY_FREE; + expect_info = ctx; + tal_free(ctx); + ok1(notified1 == 7); + ok1(notified2 == 1); + + tal_set_backend(NULL, my_realloc, NULL, NULL); + ctx = new_ctx = tal(NULL, char); + ok1(tal_add_notifier(new_ctx, 511, resize_notifier)); + ok1(tal_resize(&new_ctx, 100)); + ok1(seen_move); + ok1(seen_resize); + tal_del_notifier(new_ctx, resize_notifier); + tal_free(new_ctx); + + return exit_status(); +}