tal: add general notifiers.
authorRusty Russell <rusty@rustcorp.com.au>
Mon, 3 Dec 2012 08:59:38 +0000 (19:29 +1030)
committerRusty Russell <rusty@rustcorp.com.au>
Mon, 3 Dec 2012 08:59:38 +0000 (19:29 +1030)
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
ccan/tal/tal.c
ccan/tal/tal.h
ccan/tal/test/run-notifier.c [new file with mode: 0644]

index 194e74c68afc8d9662b00a2924a2b2cb1da28fb6..9b84c6e17bdf9b94856157d54bbab4f648981406 100644 (file)
@@ -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)
index 7efc824ab9da37b806f159d7107caf57bef66c18..8ee27c36ed1dce69e45d40187f976b23292712a2 100644 (file)
@@ -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 (file)
index 0000000..f085b82
--- /dev/null
@@ -0,0 +1,130 @@
+#include <ccan/tal/tal.h>
+#include <ccan/tal/tal.c>
+#include <ccan/tap/tap.h>
+
+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();
+}